Classes under "rulesets" have been moved to "rules", and split up into
futher subdirectories matching their library. As a result we can now
better separate the python bindings, so that things that belongs to the
simulation are separeted from things that belongs to the ai.
The main change is that the client now sends and received Relay ops.
This will make things much safer, since it's no longer up to the client
to check that any received normal operation is relayed. Instead it just
has to check for Relay ops and handle them separately.
* A character is no "taken" by sending a Possess op.
* External minds communicate with the entity through Thought ops. These
can be intercepted by scripts etc.
This would allow scripts to intercept thoughts from the mind, and act on
them. Another goal is to allow for an account to possess multiple
entities.
For example an admin account which would be able to possess other
entities. Or just to have it part of the gameplay.
Though we need to alter the way the MindProperty requests possessions,
as we don't want to generate possession requests for anything that's
handled by a client anyway. Problem right now is that we won't know that
at the time of MindProperty being applied.
The idea is that the aiclient runs in a separate process and handles all
AI functionality.
This is done by having a "possession" client which recieves possession
requests from the server, and spawns new AI clients for each request.
This is now on by default whenever the persistence is also enabled. It's
not clear why it wasn't on before though.
As a result Account has also been changed to be able to report whether
it should be persisted or not.
All IG code should use the interface of LocatedEntity when dealing
with any entity, rather than sometimes requiring Entity. Add virtual
functions to the interface where required, and modify all other interfaces
to stop them using Entity. This makes the code way cleaner, and much better
de-coupled.
The Link reference provided is the object allowing direct communication
back to the external source of the operation. This allows us to handle
things more cleanly in some cases.
Objects using this base class are all long lived, so while they are
often associated with a connection, they most commonly will outlive
that connection, and be unconnected.
