Simulating sentient agents
One important consideration when it comes to graphical simulations is the
idea of intelligent thought. Particle engines, for example, have been used
to simulate crowds that flee from giant monsters as well as to simulate
traffic. One thing these two things have in common is human thought, people
don't just flee in straight lines, or bounce off of each like pinballs.
A Framework for Sentient Agents
One way to solve this problem is to create a framework for simulating
sentient behavior. Each timestep one would pass parameters of a thing
(person, robot, Godzilla) into a rules engine that would decide on how
that thing would move, that is, based on a creature's knowledge, it will
react. If Godzilla sees the puny tank in front of it, he will crush it,
but if he sees Mothra and Super Mechagodzilla, he might flee. This
framework will be composed like so:
Population Generator -> Rule engine -> Visualizer
The population generator is one of the most important parts of this
framework. This will create your objects, and give each parameters that
will make them all similar, but still different. For example, your
population generator might create people that are trapped in a building.
Your class might look as follows:
The population generator will fill these with random, but sensible values,
so there will be no negative ages, nor ages above, say 100. These values
will be placed into the rule engine.
The Rule Engine has several different components to it, that simulate a
variety of actions that a sentient agent can do. It is composed of a sensor
, decision rules, and actuators. The sensor is how each sentient agent
"sees" its world. One can have an agent have a ray that is cast ahead of
them, and returns true if it hits something. Alternatively, one can just
simply check to see if anything is near or collides with it.
The sensor is incredibly important, as it makes each agent have an
imperfect view of the world, so it does not know everying about the
Decision rules are what happens if an agent sees something. This operates
on a variety of factors: What does the agent see? Does it have any internal
attributes (importance, aggression, tension) that it responds to? So if
you have a person encounter Godzilla and he's very aggressive and angry, he
might choose to attack, whereas someone not aggressive would flee.
Another portion of the Rule engine is the Global Database. This holds the
information about every individual, and the environment. This is so a
general feel of the crowd (the total crowd's tension or reaction for example
) can be used to modify an individual's behavior. One person fleeing from
Godzilla our aggressive hero could ignore, 30 or 40 terrified people, and
our hero might reconsider his attack.
Combining all of these is what creates the rules engine. Each agent steps
through an iterative process: ask for a decision, get immediate environment
(that is tension level/crowd density/immediate dangers), check for rules.
These rules are all based on what independent attributes each agent has.
To be honest, there isn't a lot to talk about the visualizer. This could be
anything from points on a polygon, to an incredibly well rendered 3d game.
Really, the sky's the limit here.
One thing that must be considered when doing a simulation of sentient
agents is that all actions for every agent must be done "simultaneously".
This does not mean that to do this, one must have parallel algorithms, but
that all movements have to happen at the same time, followed by the rule
engine. If one tries to couple movement and rules, then agents could be
acting on incorrect data.
Designating the environment is incredibly important for this sort of
simulation as well. If agents are operating on a faulty "understanding" of
the world, then weird things can happen, such as walking through walls, if
for example, an agent's speed is larger than the width of a wall.
Repast Symphony is a Java agent simulation framework and handy GUI.