Every 30 seconds the thoughts are persisted to the server, by sending a
Think op which wraps a Set op with the name of "persistthoughts".
An improvement to this would be to only send these ops when the thoughts
actually have changed.
Instead of using separate Commune and Think goals depending on
whether we're querying for or setting thoughts we now instead solely use
the Think op. This op wraps another op, which is then used to determine
what to do. The ops that are supported are: Set, Get, Delete and Look
Think(Set): sets new thoughts and updates existing ones, if an id is
supplied.
Think(Get): get all or specific thoughts (replaces Commune)
Think(Look): inspects a specific goal
Think(Delete): deletes all or a specific thoughts (i.e. both goals and
knowledge)
Entities are references using a format of "'$eid:...'".
For example, an entity with id 2 would be references as "'$eid:2'".
This specific pattern is handled specifically by both the importer, the
exporter and the minds themselves, allowing for entities to be properly
restored with correct minds.
The way goals are authored is refactoed so that each goal gets assigned
an id. The client can then refer to this id when issuing both Think and
Commune commands. This makes it much easier for the client to properly
author the goals, independent of the "subject" they are attached to
(which is an Interlinguish construct which isn't relevant to direct goal
introspection).
All tree code is now handle by Plant.cpp. However, this file is kept as
reference (it's of course still in Git, but people tend to never look
for it there if it's removed).
This goal will move a character close to something, and then keep the
character within a certain distance of this thing.
This is useful when you want the character to get close to something,
but then search for something else within the vicinity.
Also forget these after a while.
This makes sure that this goal doesn't result in the character getting
stuck on one thing. If used with the clear_focus goal the character can
instead move on to other things, and then return to the same thing after
a while after it's "forgotten".
