[0.6.5]
This release comes with a number of enhancements and some bug fixes. Most 
notably, the automated referee is improved to prevent many agents to collide
with each other which is required for running games with more players. Also, to
better suite the field for running 9 vs 9 games, the field size is increased
and it is 21x14 now. There are some visual improvements and minor enhancements 
to improve the general experience with the simulator. Finally, simspark.rb is
renamed to rcssserver3d.rb for more consistency.  

* New touch rules:
The automated referee now enforces two new rules to better prevent crowding and
a high number of collisions in 9 vs 9 games:
- If an agent is in touch with more than 2 agents (including himself), and he
  wasn't in such a situation in the previous time step - which means he is the
  last to join the group - he is relocated outside of the field. However, if
  the number of opponents in the group are more than teammates, an unspecified
  opponent will be relocated instead.
- If it is not clear which agent joined the group last, e.g. when 3 players
  were all separate at time t, but were all touching each other in time t + 1,
  an agent is chosen at random for relocation.

* Other Enhancements:
- Visual improvements in rcssmonitor3d: new field texture, colored team names
  and scores
- Set different agent and monitor ports with --agent-port and --server-port
- Bigger field size: 21x14
- Updated PDF documentation
- Bug fixes, specially in the automated referee
- New Trainer command (killsim) to terminate the simulator
- Compilation fixes
- Nao robots now sense visual information about field lines by default
- Now you should change the value of enableRealTimeMode variable in 
  rcssserver3d.rb if you want to turn off using real time mode

[0.6.4]
This release is supposed to be the final version of rcssserver3d for
RoboCup 2010 in Singapore. The release includes a referee patch contributed
by FCPortugal team which enforces some rules to avoid crowding of many players
in a small area and to penalize ill-behaved players. Additionally, this 
release comes with some more facilities for a human referee to control the game
and individual players in the field.

* New keys in rcssmonitor3d:
- n: Cycle through agents. A red marker disc shows which agent is currently
  selected
- e: Clear selection
- lctrl+s: Go into specific-agent-selection-mode. A specific agent can now be
  selected by pressing l or r and then a number. So the sequence 'lctrl+s, l, 4'
  selects the agent with uniform number 4 of the left team
- m: Move selected agent FreeKickDist meters back
- x: Kill selected agent

* Other changes:
- Improved referee to enforce more fair games
- Visual Studio 2010 compilation fixes
- Agents can sense field lines if enabled (currently disabled)

[0.6.3]
In this release, we are preparing for a simulation with more robots than before.
The current target is to have 6 vs 6 games, so we have made some changes to
make the simulator more suitable for it. The most notable changes made in
rcssserver3d package in this direction are:
1. Disabling the internal monitor by default: starting from this version, the
simulation server (simspark binary, now called rcssserver3d) no longer brings
up a monitor when run. To actually view the simulation, a monitor (e.g.
rcsmonitor3d which is included in this package) should be run separately. This
separation noticeably improves the performance of the server. A new executable
called "rcsoccersim3d" is provided which runs both the simulation server and a 
monitor on the local machine. 
2. Bigger field: in this version, field dimensions and goal width are 1.5 times
larger than before to provide enough area for 6 vs 6 games.

* New names:
  - rcssserver3d: the old simspark binary has been renamed to rcssserver3d, as
    it more clearly shows the functionality of the simulator. A symbolic link
    called simspark is provided for compatibility.
  - rcsoccersim3d: as stated above, running rcssserver3d (formerly simspark)
    no longer starts a monitor to view the simulation, and a monitor should be
    run separately. For users' convenience a new executable called rcsoccersim3d
    is provided which runs both rcssserver3d and rcssmonitor3 to connect to
    the running simulator. 

* Other notable changes:
 - Added HMDP effector/perceptor
 - Some compilation fixes
 - Improved Windows support 

[0.6.2]
This release is mainly a bug-fix release, and is the last release before
RoboCup 2009 competitions.

* Some improvements:
 - improved Windows and MacOSX support
 - improved external monitor
 - fixed a bug in rcssserver3d's goal counting
 - added right kick-off key to the monitor (Simon Raffeiner)
 - simspark can take command line argument specifying the rb script to run
   (using --script-path command line option)

[0.6.1]
This is the first release of the simulator after RoboCup 2008 competitions,
and the first release of rcssserver3d package as a separate package which 
uses simspark package to implement a hunamoid soccer simulation environment.
In this version of the simulator, restricted vision perceptor is enabled again,
and is going to be used in 2009 competitions. You can read more about this
perceptor in 0.5.9 NEWS section.
Finally, we do not use autotools for our build system anymore. You should use
CMake (version 2.6) to build the package. See INSTALL for further installation
instructions.

* Restricted Vision: 
  - restricted vision perceptor is installed on Nao.

* New requirements for building the pacakge:
  - You'll need CMake 2.6 to configure and build the package
  - this package depends on simspark package, so you should install it first

* New program names:
  - agentspark is now called rcssagent3d
  - monitorspark is now called rcssmonitor3d

* Some small enhancements and bug fixes 

[0.6]
This release is the final version for RoboCup 2008 in Suzhou China. It
is little different from version 0.5.9 in simulation, excepting some
changes for the rule of RoboCup 2008, including the vision perceptor.
And also, the eye-catching sky and goal are added. The monitor
protocol is improved due to the team requirement.

* Physics:
 - set ball angluar drag to 0.00005

* Vision perceptor:
 The old vision perceptor (just the same as last year) is used for
 both Nao and soccerbot058.

* Eye-Catcher:
 - the sky box is added
 - the goal with net is added

* Monitor Protocol ( Thanks Carlos from Borregos3D):
 - Add 'move' command for setting the agent's position and rotation.
   The whole command may like this:
   (agent (team $teamname)(unum $id)(move $x $y $z $dir))
   where, ($x, $y, $z) is the desired position, and $dir is the
   desired face direction of the robot. 
 - Fix bug in set ball command.

* Rule bug fix:
 - fix bug of the goal kick position
 - fix bug of the size of penalty

[0.5.9]
This release is the candidate of RoboCup 2008. There are some
important improvements. Firstly, the physics parameters are well
adjusted to make the simulation more real and stabler. Secondly, the
restrict vision perceptor is used, with which the vision range is
limited, but more details will be seen, i.e. the head, hands and feet
of robots can be seen. Furthermore, the soccer rule and visual
features are improved.

* Physics Parameters:
 Some physics parameters are adjusted to make the simulation more real
 and stabler.
 - Joint parameters: the max force and max speed of the joint are
 restricted, and some other parameters are modified.
 - Ball parameters: the parameters of drag are modified.

* Restrict Vision: 
 The restrict vision perceptor is installed both in nao and
 soccerbot058. This perceptor have some restriction compared with
 original vision perceptor. Firstly, the robots can only see object in
 the limited angle range (both horizontal and vertical angle ranges
 are [-60, 60] in degree). Secondly, the frequent is restricted, the
 robot can get one vision message every 3 cycles. Furthermore, note
 that the noise is added to the vision information.

 However, the information is richer: the robot's torso, head, hands
 and feet can be seen. The flags placed in the field can also be seen
 (They are no visual in the screen now, but the robot can see them).
 Four flags are placed at the field corners (the height is 0), and the
 four flags are placed at the goal posts (the corner of the goal).

* Visual:
 - The Nao robot can be identified by team colors and numbers. You can
 play a match with Nao robots ;-)
 - the monitor camera can be controlled by number keys (from 1 to 7)

* Soccer Rule:
 - Field Size: the field size is 12mx8m, the center circle radius is
1.3m, the penalty size is 1.2mx4m. More information please see
naosoccersim.rb.
 - Kick Off: the kicking off team can enter the center circle, and the
   opponents will be moved away from the center circle.

[0.5.8]
 In this release, we have a simulator which is much more like the
 RoboCup Humanoid League: The smaller size, the smaller robot and
 ball. The integrated agent is added as a new feature. Furthermore,
 the external monitor works now.

* New Robot Models:
 - Nao: robot from Aldebaran Robotics, see rsg/agent/nao/nao.rsg. The
 robot looks great with textures.
 - soccerbot058: robot based on soccerbotcomp with joint limits, and
   its size is scaled ( default 0.1 ), see
   rsg/agent/soccerbot058/soccerbot.rsg.
 
* New Nao Soccer Simulation:
 The simulator start naosoccersim.rb in default now, the new field
 size is the same as RoboCup Standard Platform League, please see
 naosoccersim.rb for details. The old soccersim.rb are still there,
 you can switch between naosoccersim and soccersim in simspark.rb.

* New Feature:
 - Integrated Agent: The agent can run internally now, in this case it
 is easier to debug the skill that you have designed, since it can get
 the simulation information directly. Note that the action is
 performed with a delay of one cycle (This is just like external
 agent). There is an example in plugin/soccer/agentintegration. To run
 the demo just enable two lines in the simspark.rb:
 sparkSetupTrain()
 addIntegratedAgent('SoccerbotBehavior',1)

* Important Fixes:
 - the external monitor works now, you can run to monitor remotely(set
 $monitorServer in spark.rb). And also, the internal monitor can be
 disabled by setting $enableInternalMonitor to false in simspark.rb.
 - the OBJ importer is extended, we have really good 3D graphics now.
 - joint limits: the simulation runs stably with joint limits.

For details have a look into the ChangeLog coming with the package.

[0.5.7] 
 This is the first release after the competition in Atlanta.
 The simulator now contains the auto-adjust speed mode(by default),the
 server will run slower when needed, and print warning. We also
 applied changes what be made in Atlanta, and re-enabled the
 communication between robots. Furthermore, we imported some new
 features from SimSpark Project, including rsgedit, rosimporter, and
 etc. Although they are optional, you may want to try the rsgedit,
 please install the wxWidgets[1] firstly and take a look at the 'Quick
 start to RsgEdit' in the doc directory. Finally, there is a new robot
 model which is built with composite bodies for better performance.
 The monitor logger was also bug-fixed and improved. With the help of
 the community, the documents about the server are available now, but
 they are still in progress.

* Documents:
 - the user's manual in doc/users
 - the server developer's manual in doc/devel
 - there are also some useful information at SimSpark Wiki[1]

* Important fixes:
 - mointor logger:
  - fixed methods to work properly.
  - solve the update problem (reported by team Apollo).
  - remove invisible nodes to save  bandwidth(thanks to Carlos
    Bustamante from Borregos3D).

* Features:
- applied Atlanta 2007 server changes:
               - 'm' and 'c' for killing agents
               - two robot models with different facilities
               - using materials with textures
               - free kick distance changed to 4.5
               - one half time (8 mins)
               - agents can beam in Goal_Left or Goal_Right play modes
               - no longer possible to move agents by pressing m
- re-enabled communication, the soccerbot056 has SayEffector and
 HearPerceptor
- add AdjustSpeed mode (It is enabled by default). In this mode, the
 server will run slower when needed.
- new multi-threaded implementation
- rosimporter, model importer for RoSiML[2] modeling language
- rsgedit, a cool simspark simulator with graphic user interface.
- soccerbotcomp, the new robot mode which is built with composite
 bodies, it can advance the simulation speed.
- include some useful utilities: tinyxml, wxflatnotebook and wxscintilla

For details have a look into the ChangeLog coming with the package.

[1] http://simspark.sourceforge.net/wiki/

[2] www.wxwidgets.org

[3] Laue, T., Spiess, K., Refer, T.: Simrobot - a general physical
robot simulator and its application in robocup. In: RoboCup 2005:
Robot Soccer World Cup IX. Lecture Notes in Artificial Intelligence,
Springer (2006)

[0.5.6]
This is the final release for the competition in Atlanta, GA. The simulator
now contains the new timer running in single-threaded mode by default. We also
fixed the soccer rules plug-in (communication and offside not supported
yet). Furthermore, we completed the game state info display in both the
internal and external monitors, and fixed the trainer command parser to work
with the new agents. The SoccerBot model was modified, the performance was
slightly improved, and several bugs were fixed.

* Important fixes:

beameffector & singlematiniteffector:
- fixed beaming with rotation

gyrorateperceptor:
- output is now in the local coordinate system of the robot

trainercommandparser:
- fixed several methods to work with the new agent

* Features:

- new GameTimePerceptor added which senses game time instead of sim time (not
  used in Atlanta)
- GameStatePerceptor added which provides the agent with information about the
  current game state (play mode, game time, unum, and side)
- play modes and rules re-integrated (no communication and no offside yet)
- slight performance improvement by caching references to important classes
- game state info display fixed in the internal and external monitors
- key bindings for 7 different camera positions, kick off, and drop ball
- the SoccerBot was modified to have a two-part torso to facilitate stand-up
  motions, it got colliders (and very small masses) at the hands, it uses the
  ForceResistanceReceptor instead of the TouchPerceptor
- the hinge joint and universal joint effectors will not set any velocity if a
  joint stop is reached to prevent large forces and instabilities (not used in Atlanta)
- the maximum joint velocity that can be requested was restricted to 9000
  deg/sec (for stability reasons)
- Field size was reduced to 50m x 32m, penalty area reduced to 8m x 19.5m
- Goal size was increased to 9m width and 4m height
- The ball model was improved according to suggestions from wjq and Tobias Warden
- The visualization of the corner flags was moved back to allow proper corner kicks


[0.5.5]
The simulator has been ported to MacOS, the network messages were shortened,
we did some performance tuning, improved the log player, added a new perceptor,
and fixed some bugs.

* Important fixes:

simspark:
- fixed setup of goal flags (thanks Carlos)
- several files were missing break statments in the physicsserver directory
  (thanks Shivaram)

gyrorateperceptor:
- "rt" keyword was added to enable correct parsing of the perceptor values

* Features:

- MacOS compatibility (please see README.MacOS file for comments)
- individual ODE CollisionSpaces are used to encapsulate each agent and 
  each goal now
- the protocols for the monitor and the agents have been shortened
- new basic importer for Wavefront OBJ files
- textures can be enabled for the ball, the field, and the agent torso
  (player numbers :-) )
- several computationally expensive function calls have been replaced
  with calls to more efficient versions
- the log player now plays logfiles in forward and backward mode, and 
  supports pause, and forward/backward stepping
- a new perceptor (ForceResistancePerceptor) was implemented that gives 
  feedback about position and resulting force due to a collision of the 
  body the perceptor is attached to   (see doc/TEXT_INSTEAD_OF_A_MANUAL.txt 
  for details)
- BeamEffector now takes 3 arguments: position (x and y) and angle in the
  x-y-plane (rotation around z-axis) at the beam position (DEG)

[0.5.4] 
This release contains fixes for known problems (e.g. in the
visionperceptor or the spark sample agent), updates of old plug-ins
for the new simulation (beameffector, initeffector), and new features
like a log player, and new perceptors.

* Important fixes:

visionperceptor: 
- patch (vision6) by Yuan to fix problems related to the local 
  reference frame of the robot

soccerbot:
- anchor of the ankle joint was set higher to avoid foot penetration
  when doing large steps (thanks Guangbin Cui)

beameffector:
- all the bodies below the parent of the effector are moved now 
  instead of only one (thanks Amin)

initeffector:
- move all the bodies below the parent of the effector to the initial position

simspark:
- increased goal height
- reduced ball size and mass
- internal rendering can be switched off without affecting timing now
- support for ODE collision spaces was implemented by Markus
- a 64-Bit compile issue was fixed (thanks Sander van Dijk)

agentspark:
- patch by snow to fix problems in the GetMessage function
- sending init message in the SoccerBotBehavior

* Features:

- simspark now uses the new SingleMatInitEffector to initialize 
  agents based on their teamname (different initial position and 
  different uniform color)
- simspark can record logfiles (thanks Hesham & Amin)
- monitorspark can playback the recorded logfiles (thanks Hesham & Amin)
- new gyro rate perceptor (thanks Hedayat)
- new binary touch sensor


[0.5.3] 
This release contains some fixes for the offside code and some
eye candy for the lite monitor. Furthermore, it includes the new
Fujitsu HOAP-2 inspired robot for simspark as well as the derived
SoccerBot (work in progress), and some improvements to the physics
code (mainly related to stability issues).

* Features:

- rcssmonitor3D-lite features a SkyBox (by Heni Ben Amor) and improved 
  colors and lights (by Tobias Warden). Please see the comment about
  texture files in the INSTALL file.
- simspark includes hoap2.rsg and soccerbot.rsg robot models
- agent communication was restricted to a message length of 20 Bytes in
  rcssserver3D

* Important fixes:

rcssmonitor3D-lite:
- toggling pause with p (r will be used for assigning free kicks)
- correct aspect in 2D overview
- Mousehandling patch (by Junqing Wang)

rcssserver3D:
- several fixes for the offside rule code
- fixed bug that prevents arguments to be passed to SPADES (by Sander van Dijk)

simspark:
- fixed bug in the sceneffector that resulted in a crash if defines were used in RSG
  agent descriptions
- modified several parameters of the physics system to get a more stable simulation
- fixed the fixed joint type ;-)


[0.5.2]
This is mainly a bug fix release to get a stable version and change some parameters
for the RoboCup-2006 in Bremen. Some new features, mainly in the monitor are
introduced as well.

* Features (general):

- the catch margin of the catch effector has been reduced to 0.8m and the goal
  height was increased to 1.6m to reflect the stronger goalie capabilities and
  offside rule implications.
- the monitor features a new autocam mode, "picture-in-picture" view, a
  display of the current camera mode, and the ground texture can be toggled
- logfiles can now be stepped backwards
- agenttest was updated with a say command and sample code

* Important fixes:

- the calculation of the torque vector in the kickeffector was fixed
- the parameters for the pan/tilt effector are checked for NAN
- the list of the monitor keybindings was updated
- a bug in offside was fixed that could occur if a player and the ball cross the
  opponents line of defense, and this player was the last one to shot the ball
  before crossing.
- the code has been updated for gcc 4.1
- some bugs relating to kickoff have been fixed
- say effector ignores some illegal characters


[0.5.1]
Release 0.5.1 contains mainly two fixes:
- the Offside rules are now closer to the FIFA rules. 
- the RestrictedVisionPerceptor (RVP) was hardly useable. The RVP 
  can now be controlled by using a PanTilt Effector.


[0.5]
This release introduces a few new features, and also some bugfixes 
(and probably some new bugs :). Important new features and fixes are 
as follows:

* Features (soccer):

- Goalies. 
  Players with uniform number '1' can catch the ball using the (catch) 
  command. 

- A restricted vision perceptor, so that not all other agents are
  visible at the same time. With this perceptor, the communication
  introduced in the 0.4 release becomes important.

- The offside and some other rules have been cleaned up and some bugs
  have been removed. Also, files that have been missing in the
  0.4. release are now present.

- rcssmonitor3D-lite looks a little more interesting now, and 
  some bugs with the random number generators have been fixed.

* Features (general):

- a couple of new physics functions have been added, general simulation 
  settings have been fixed. This doesn't change the current soccer 
  simulation, but is important for the general simulator.


[0.4]
This release includes some speed improvements, agent communication,
an implementation of the offside rule, and a first, unfinished version
of the new legged-sphere agent type amongst other things. 
Here is a summary with some more details:

* Features (general):

- A cache for node references has been added to the Zeitgeist
  core to speed up the simulation considerably. Thanks go to the
  Brainstormers3D team for the initial patch and to Markus Rollmann
  for the modification and integration.
- The Spark based simulation (which will be used in the future for
  simulations using the articulated agents) has been made much more
  flexible by Markus Rollmann.
- A sample agent and behaviors for a Spark based soccer simulation
  using either small cars or legged-sphere agents has been
  added. Currently, the legged-sphere agents are used by default. 
  The behavior of the agents is very simple (in the legged-sphere case) 
  and is solely meant to demonstrate how to use the new perceptors and 
  effectors.

* Features (soccer):

- The offside rule has been implemented by Hesham Ebrahimi
- Agent communication is now possible. It is based on the
  2D communication model. Documentation can be found in the
  file doc/TEXT_INSTEAD_OF_A_MANUAL.txt. Thanks go again to
  Hesham Ebrahimi for the implementation and documentation
- The lite-monitor is able to draw velocities in 2D and 3D. 
  Added by Jan Murray.

* Important fixes:

- Fix for gcc 4.0 and above compatibility by Jan Murray
- An issue with 64bit builds, reported by Li Yang and Patrick Riley,
  was fixed by Markus Rollmann
- The distance error in the vision perceptor was made dependent on the
  real distance by Oliver Obst

[0.x.x]
This release has been ported to OS X.  Besides the normal
requirements, it requires an X server to be installed on the machine,
along with a glut library for X windows.

[0.3]
This release is intended to be used as official version on RoboCup 2004.
With respect to the soccer rules, this release mainly fixes some bugs contained
in the 0.2.2 release. New things here are both an automatic and a manual drop 
ball feature and physical goal posts.
With respect to the simulation system itself and usability, a few keys have 
been added to the rcssmonitor3d-lite and the system shuts down automatically
after a match is over. Printing messages is turned off by default now (can be
changed by adding log streams from a ruby file).
Bugs that have been fixed included some math things (like a bug in the setup of
axis aligned bounding boxes), bugs in the use of SPADES, and in the sample 
agent communication server.

[0.2.2]
This release adds both soccer simulation specific features (like better rules 
 and an initial version of a logplayer) and general simulation features 
(almost all ODE features are supported now, and an initial version of an
alternative simulation server as a SPADES replacement). For the 0.3 release,
some of these new features need some polishing :-). Below a short summary of 
new features. 

* Features (soccer):

- The rcssmonitor3D protocol has been changed to produce less redundant data. 
  Specifically, field flags will only be sent once, and information like team 
  names and scores will be sent only if they change.
- rcssmonitor3D-lite can be used as a logplayer now. To do this, replace the 
  CommServer plugin setup in rcssserver3D-lite.rb by the LogfileServer setup.
  Monitor logfiles get recorded by SPADES automatically, and the new monitor
  protocol can be used as Logfile format.
- The rcssmonitor3D - library got an user-friendly interface.
- rcssmonitor3D-lite looks better now and the display is more informative.
- The body and effector parameters have been changed based on suggestions from
  the mailing lists.
- A trainercommandparser has been added so that it is possible to use soccer
  monitor applications as trainer program (to repoduce specific situations etc).
- Players are moved away from the ball in certain situations (like kick in for 
  the other team or kick off, etc).
- It is possible to do automatic kick offs now (in rcssserver3D.rb).
- Due to various improvements and changes, the simulator is now reasonable fast
  to extend the half time length to 4 minutes; suggestions for the competition 
  match lenght are welcome. 
- Players accelerate (and break) faster; something like air resistance or 
  friction was added to the players and the ball so that they eventually stop 
  with no acceleration.
- The torque from the kicker was made configurable from rcssserver3D.rb
- An experimental say-effector has been added; up to now, only monitors 
  (and trainers implemented as monitors) can hear the messages.

* Features (general):

- Several types of ODE joints are supported now.
- An initial version of a generic simulation server has been added. It 
  reimplements some of the more general SPADES concepts (like network support 
  and a run loop). It is intended to use it as an alternative to SPADES when 
  reproducibility of events is not key. The advantage is that faster 
  simulations (or simulations with more agents) are possible by less overhead.
- A general description language for 3D simulations has been added. By using
  this description language, it is possible to set up different 3D simulations
  based on text configuration files. Simulations are described by sets of 
  S-Expressions (any other format possible by changing plugins).
- The ScriptServer has been changed so that ruby functions can also read back
  values from the simulator easily.
- Body controllers have been introduced. Body controllers can be used to 
  constrain/control the motion of associated bodies (things like adding drag 
  forces or changing the "bouncyness" of objects can be controlled).
- Added a tool that visualizes the internal zeitgeist class hierarchy.
- Added a new library libspark that contains an application framework for
  applications using both liboxygen and libkerosin classes. 
- Added a new application SimSpark. SimSpark is a monolithic simulator bases
  on libspark. With this new simulator, we have been testing most of the new
  generic features (like the description language and ODE joints) we have been
  adding. 
- Got rid of the rcssbase package dependency. The "net" part of this package
  is part of rcssserver3D now and has been extended by TCP sockets. The list 
  of required libraries should be reasonable small now.
- Added simspark demo simulations. 

* Important fixes/Changes (both soccer specific and general):

- The simulator compiles with recent versions of boost (tested with 1-31-0).
- Goals are properly counted now.
- Goals are only 50cm heigh now because agents cannot jump high. 
- The default torque from the kicker is low now (was way to high before).
- Building the API documentation has been reduced to only the necessary cases.
- Some math bugs in libsalt have been fixed.
- The kerosin library has been overhauled (lights / meshes / etc).
- Added support to update cached script variables after reading ruby files.

[0.2.1]
This is a bugfix release. It removes some (but not all) bugs found
in rcssserver3D-0.2.

- Configuration was made a little stricter and more complete so that
  it should be easier to install the whole thing.
- The missing agenttest.rb file is included into the distribution
- The Makefile.am's have been fixed for those not building the libkerosin part.
- A fix for the recent SPADES versions has been added.
- A major bug with the weight of objects in the simulation has been removed.
  The dynamics of the drive of the robots and of the kicker have been adapted.
  (This bug was found after a report from Nuno Lau on the sserver list).
- The artificial slowdown of bodies has been removed. 
- The default timer of the sample agents (agenttest) is now jiffies.

A few features have been added to the zeitgeist library. This is mostly stuff 
dealing with the ruby interface.


[0.2]
This release adds already big parts of the soccer specific parts to the 
simulator. All soccer specific things are realized as plugins to the 
simulator, they are located in the soccer bundle in plugin/soccer/.

- rcssmonitor3D and soccer simulation:
  Starting with our simple monitor: here are the most visible changes.
  You can see a soccer field with two goals, a ball and agents in different
  colors dependend on the side they are playing on. 
  You can use keys 'a', 's,', 'd', and 'w' to move the camera (as was as 
  the mouse). The monitor can send simple commands to the simulator now.
  ('k' is of kick off, that is what you probably wanted to know).
  The soccer field is a standard FIFA size field with variable size, same with
  the ball and goals.
- Soccer Plugins
  Here is the really big part of the changes. Agents have an (omni-)drive and 
  a kicker now, they can perceive the environment with a kind of 360ओ omnicam
  and they get updates about the game state and things like the battery state.
  Using the omnidrive, agents can do 100m in something about 13s or 14s.

On startup, the simulator will start two different types of agents now. Even 
though there are only a few soccer rules implemented, it should be possible
to implement a simple soccer team. To facilitate programming a new team, we 
enhanced the sample client a bit. 

Finally, we added a small text (lacking a comprehensive manual),
describing the basic features of the simulated robots in the simulation. 

[0.1]
This is the initial release of rcssserver3D. To get an idea of what
rcssserver3D provides in general, please see also the file README.

- liboxygen / libkerosin
  libkerosin, the library containing the big part of the simulation
  system has been split up. We have now liboxygen containing the
  pure simulator part, and libkerosin containing the graphical output,
  user input and stuff like this. Because of issues with different
  OpenGL drivers, libkerosin is currently not used for graphical
  output. Another advantage of the split into liboxygen and libkerosin
  is that we can have a standalone simulator with no graphics.
  By default, libkerosin will not be build (if you want to build it
   anyway: libkerosin needs a few other libaries. See the
   documentation for details).

- SPADES integration
  For handling agents as external processes, we integrated SPADES into
  the simulator. SPADES is a middleware system for agent-based
  distributed simulation and was introduced by Patrick Riley on the 
  RoboCup 2002 symposium. Among other things, the simulator gets a
  model of simulation time and support for external monitors by using
  SPADES.  

- GameControlServer
  We added a GameControlServer as central instance for keeping
  information and classes relevant to agents in a simulation. An
  important part of the GameControlServer is a reference to a 
  parser responsible for parsing messages from agents into an internal
  representation. Parsers can be plugged in into the
  GameControlServer, so the simulator does not depend on a fixed
  protocol. Parsers are also responsible for generating messages from
  the internal representation.

- S-Expressions parser
  As a specific instance of a pluggable parser, we implemented a
  parser for parsing and generating S-Expressions (lists as used in 
  functional programming languages like LISP or Scheme). We also
  discussed using XML as protocol between agents and simulator. There
  was no clear joint position for or against XML or
  S-Expressions. There is no XML parser module now because noone
  implemented it :)

- CreateEffector
  We added a CreateEffector. The idea behind the CreateEffector is
  that once the agents connected to the simulator, they do not have a
  physical representation, other effectors or perceptors yet. By using
  the CreateEffector, agents can request specific effectors,
  perceptors, and bodies. Right now, the create effector requests a
  default agent with a perfect vision sensor, a simple force effector,
  an InitEffector for changing the team name, and a sphere like body.

- simple external monitor
  To get an impression of what actually happens we implemented a
  simple external monitor based on simple OpenGL stuff (it does not
  use our libkerosin library). The external monitor also uses
  sexpressions as syntax. The protocol is even more preliminary 
  than the agent protocol...

- a simple external SPADES agent
  We also implemented a very simple agent as sample implementation for
  external agents. The sample agent does (almost) nothing.

- ...

[Demo]

Physical Simulator as shown on RoboCup 2003 symposium
=====================================================
- libzeitgeist
  A class object system as core of the simulation system. A class
  object is just a factory of class instances. In addition to this
  mechanism, it also implements an object hierarchy. This hierarchy is
  essentially a virtual file system, where the 'directories' and
  'files' are instances of C++ classes. These two concepts are quite
  intertwined with each other, as class objects can also live inside
  the object hierarchy. Objects within the hierarchy are identified
  with a unique name. Class objects can also be loaded as plugins
  (loadable modules).

- libkerosin
  A physical simulator for simulation of rigid body dynamics based on
  ODE. We created a library that contains the big part of the
  simulator including visualization, physics, geometry, agents. We can
  also handle user input and playing sounds. The simulator library
  build upon the class object system mentioned above.

- demo
  A demo application with some spheres as agents. Agents try to get
  some food. The agents are part of the simulator loop; a simulation
  step is over if all agents finished thinking. Because of this, agents
  have infinite thinking time (in priciple). There is no model of time.