[9.0.3]

[rcssserver-9.0.3]

  * Fixed errors in default server.conf generation.  Thanks go to Michael
  Gollin for providing the fix.


[rcssbase-9.0.3]

  * Fixed problems with parser.h and gcc 3.x.  Thanks go to Fredrik Heintz for
  the corrections. 


[9.0.2]

  Fixed bug in make NEWS on Solaris


[rcssserver-9.0.2]

  * The server can now be run automatically.  When 'auto_mode' is on the server
  will wait 'connect_wait' cycles for the players to connect and
 'kick_off_wait' cycles before kicking off.  At the end of the two halves, the
  server will wait 'game_over_wait' cycles before exiting.  It will not
  continue into extra time.

  * String command line and .conf parameters may now be enclosed in quotes.

  * Two new parameters have been added, 'team_l_start' and 'team_r_start' that
  can be used to specify a command to run to start the left and right team
  respectively.  If the command contains a space make sure you enclose the
  entire command in double quotes.

  For instance, to start the left team on 'team_host', connecting to a server
  on 'server_host', one could use something like

  rcssserver -team_l_start "ssh team_host \"~/startMyTeam server_host\""

  or add

  team_l_start : "ssh another_host "~/startMyTeam some_host""

  to the '~/.rcssserver-server.conf' file


[rcsslogplayer-9.0.2]

  * Fixed problem compiling on Solaris 8


[rcssbase-9.0.2]

  * UDPSockets now have the close-on-exec flags set automatically.


[9.0.1]

[rcssserver-9.0.1]

  * The automatic output of CLang messages as full hear messages has been
  disabled due to problems with output during games.


[9.0.0]

[rcssserver-9.0.0]

  * CLang messages will now output as

  (hear TIME_SENT online_coach_{left|right} TIME_RECV (message))

  if the side and time recv have been set, otherwise they are output as normal.
  This is only intended as a convenience feature for clients so that they can
  compare the output of the parsed message with the actual message parsed.

  * rcss::clang::Parser now inherits from the new rcss::Parser, found in
  ./rcssserver/rcssbase/parser.h

  * The CLang lexer is now reentrant, and can only be rebuilt using flex.

  * The order in which the search for the rcssbase files is performed has
  changed.  If the "rcssbase" environment variable is set, then it will first
  look in the path specified by "rcssbase".  Next it will try to look into
  rcssbase directly, by assuming rcssserver and rcssbase are being installed as
  part of the larger rcsoccersim package.  Failing that it will then search for
  the headers as it would for any other header file.


[rcssbase-9.0.0]

  * Added rcss::Parser, a abstract parser class


[8.05]

  * Fixed mergeCL.awk problems when used by pre v3 gawk or other awks.


[rcssserver-8.05]

  [rcssserver-rel_10]
  * Fixed defect where a back passes is detected when the goalie sends a
   catch but the ball is too far away.

  [rcssserver-rel_9]
  * To save on compile time and space, debuging infomration is now disabled by
  default.  Use `./configure CXXFLASG="<YOUR FLAGS>"' to overide the new
  defualt of "-O2".

  * Shared libraries are no longer built by default.  If you want to use shared
  libraries you will need to specify --enable-shared at configure time.

  [rcssserver-rel_8]
  * Fixed egcs 2.91.66 compilation problems

  [rcssserver-rel_7]
  * Fixed minor defect which would reverse the order of points in CLang Quad,
  Tri and Rec regions.

  * Fixed defect where quotes where missing from CLang define messages.

  * Fixed defect that would send CLang messages that required support for both
  CLang 7 and CLang 8 to clients that supported only one of CLang 7 or CLang 8.

  * Disabled by default the sending of (hear time TEAM [rcssserver-UNUM]) messages.

  * The type audio messages received by a player can now be enabled and
  disabled via the ear command in the form

  (ear ({on|off} [rcssserver-TEAM] [TYPE]))

  TEAM is "our", "opp", "left", "l", "right", "r" or the team name of a team.
  If TEAM is omitted, the message will apply to messages from both teams.
  TYPE is used to specify the type of audio, where "complete" or "c" is used to
  specify messages which contain the audio data and "partial" or "p" is used to
  specify messages which do not contain audio data.  If TYPE is not specified,
  the message will apply to both types.

  For example:

  '(ear (on))' enables all audio.
  '(ear (off partial))' disables '(hear time TEAM [rcssserver-UNUM])' messages.
  '(ear (on our complete))' enables '(hear time TEAM [rcssserver-UNUM] "message")'
  messages from the players team mates.
  '(ear (off opp))' disables all audio from opponent players.

  * Fixed compilation problem on GCC 2.96

  * Added support for queueing of CLang RuleMsgs and DelMsgs.  The number of
  these types of messages that can be sent each CLang windows is specifed by
  two new parameters, 'clang_rule_win' and 'clang_del_win', both of whcih have
  defaults of 1. 

  * Fixed bug with proper goal kicks which would award a goal kick to the
  opposition it a opposing team member kicked the ball when the play mode was
  still goal kick.  Instead the goal kick is retaken.

  * Fixed some problems when compiling on Cygwin

  * Fixed bug that would allow a player to kick the ball if the goalie had
  caught the ball and move on top of the player.

  * Defualt for the offide area is now 2.5

  * Proper goal kicks (aka LAW 16) is now off by default.

  * Fixed rcssclient compilation problem when libz is not detected on the
  system.

  * Replay parameter in no longer available.  This was for some pretty old code
  to replay the games.  This is done by rcsslogplayer instead (and has been for
  a long while).

  * Corrected an old defect that would allow players to dash in before kick off
  and have the acceleration accumulate until the kick off.  Thanks go to
  Michael Gollin for reporting this bug and how to correct it.

  [rcssserver-rel_6]
  * The team graphic protocol has been changed to make it easier to detect
  and recover from lost messages.  The new format requires the 256x64 image to
  be broken up into 8x8 tiles (to make sure it will fit into the message to
  the monitors) and has the form

  (team_graphic (<X> <Y> "<XPM line>" ... "<XPM line>"))

  Where X and Y are the co-ordinates of the 8x8 tile in the complete 256x64
  image, starting at 0 and ranging upto 31 and 7 respectively.  Each XPM line
  is a line from the 8x8 xpm tile.

  The server responds with 

  (ok team_graphic <X> <Y>)

  The server then sends

  (team_graphic_{l|r} (<X> <Y> "<XPM line>" ... "<XPM line>"))

  to each monitor via the message board.

  * Fixed defaut values for new parameters in server.conf.

  * Fixed defect which would not allow online coaches to substitute a player
  for the same player type if there was already the maximum of that player type
  on the field.

  * Tackle power is no longer reduced by the probablility of the tackle.

  * Substitutions are now explicitly recorded in the log-files. The message
  board is now used to record player substitutions in the game log and send
  the data to the monitors in the form

  (change_player_type {l|r} <unum> <player_type>)

  * Fixed problem parsing parameters when compiled with gcc 3.x

  [rcssserver-rel_5]
  * Parameters have been added to enable and disable free kick faults and back
  passes.  They are

  free_kick_faults
  back_passes

  and they are both enabled by default.

  * Parameters have been added for the enforcement of proper goal kicks.  They
  are

  proper_goal_kicks 
  stopped_ball_vel
  max_goal_kicks

  and they have default values of on, 0.01 and 3 respectively.

  * The server will now allow online coaches to send team_graphic commands
  before kick off.  The graphic must be a 256 x 64 XPM and each team_graphic
  command must contain just one line of the XPM.  The command has the form

  (team_graphic "<line>")

  and the server will respond with

  (ok team_graphic)

  for each line and

  (ok team_graphic_done)

  when the image is complete.

  As each line is received it is sent to the monitors on the message board in
  the form
  
  team_graphic_{l|r} "<line>"

  At this stage the monitor must be connected at the time the lines are sent.

	* Fixed defect which dereferenced Stadium::M_caught_ball when NULL.

  * Fixed defect in kick faults where a kick fault was not called if the player
  taking the free kick, kicked the ball multiple times before dashing and then
  kicking.

  * Fixed defect in server params where visible_angle was reported in radians
  instead of degrees.

  * Corrected defect where the ball going out of bounds from a goal kick would
  result in a drop ball on the side line.

  [rcssserver-rel_4]
  * Server param messages now contain tackle parameters of version 8+ clients.
  The way the message is generated now means that the order of items has
  changed and derived values are not sent.  All string values are now quoted to
  ease paring should they contain brakets.

  * Fixed defect where collisions were modelled between the goalie and the ball
  when the ball was caught by the goalie.

  * The it is now required that the ball is kicked directly into play from the
  goal kick in compliance with FIFA law 16.  If the ball stops or another
  player kicks the ball before it leaves the penalty area, the kick is
  re-taken. If the player taking the goal kick cannot manage to kick the
  ball directly into play after 3 attempts, a free kick is awarded to the
  opposing team in the nearest penalty corner.  IMO the player should also
  receive a yellow card for incompetence and time wasting, but we don't have
  yellow cards yet.

  * Added a tackle_power_rate(0.027), which was previously missing and resulted
  in all but the smallest of tackles producing a maximum ball speed.  The
  effective power is now reduced by the probability of the tackle succeeding.
  This is done by simply multiplying the probability of success with power
  requested.

  * Fixed defect that allowed players to kick and tackle after a free kick or
  back pass infringement but before the free kick was awarded.

  * Fixed defect that allowed players to be close to the ball during an
  opponents free kick.

  * Fixed 1 cycle delay in play mode change after a free kick was taken.

  * Removed audio debugging messages

  * Fixed defect in backpasses where a kick from a player on team A followed
  by a freekick and a catch by the goalie would be incorrectly called a back
  pass.

	* Fixed bug in the reported pointto directions.  Previously they were
  incorrectly adjusted by the players orientation.  Thanks to Michael Gollin
  for pointing out the bug and providing the correction.

  * Fixed bug in the bracket counting of quoted say messages.  Messages such as
  (say "Test)") are now parsed correctly.

  * Fixed bug in new Vectors that are uses in pointto.  The setHead() method
  would transpose the X and Y coordinates.  Thanks to Michael Gollin for
  pointing out the bug and providing the correction.

  [rcssserver-rel_3]
  * Added rules to CLang.  Clients can now define rules, which can be turned on
  and off and deleted later on.  Rules are can be defined as follows

  (define DEFS)

  DEFS : // same as old defs
       | (definerule VAR {model|direc} RULE)

  VAR : [rcssserver-abe-oqrt-zA-Z_]+[a-zA-Z0-9_]*

  RULE : (CONDITION DIRECTIVE_LIST)
       | (CONDITION RULE_LIST)
       | ID_LIST

  RULE_LIST : RULE_LIST RULE | RULE

  ID_LIST : all | VAR | (ID_LIST2)

  ID_LIST2 : ID_LIST2 VAR | VAR

  CONDITION :  // unchanged

  DIRECTIVE_LIST : // unchanged

  For example the following messages are valid

  (define (definerule MyRule12345 model ((true) "dostuff")))
  (define (definerule MyRule2 direc ((true) "doStuff" "andOtherStuff")))
  (define (definerule MyRule3 model ((true) "dostuff"))
          (definerule MyRule3 model ((true) "doStuff" "andOtherStuff")))
  (define (definerule MyRule4 direc MyRule2))
  (define (definerule MyRule4 direc (MyRule2 MyRule3)))
  (define (definerule MyRule4 direc ((true) MyRule2)))
  (define (definerule MyRule4 direc ((true) (MyRule2 MyRule3))))
  (define (definerule MyRule4 direc all))
  (define (definerule MyRule4 direc ((true) all)))

  Rules may be deleted at a later date by using the delete message, which has
  the form

  (delete IDLIST)

  For example the following messages are valid

  (delete all)
  (delete MyRule12345)
  (delete (foo bar))
  
  Rules are then activated or deactivate using a rule message, which has the
  form

  (rule ACTIVATION_LIST)

  ACTIVATION_LIST : ACTIVATION_LIST ACTIVATION_ELEM | ACTIVATION_ELEM

  ACTIVATION_ELEM : ({on|off} ID_LIST)

  For example the following message is valid

  (rule (off all) (on (foo bar)) (off MyRule12345))

  Each activation element should be applied in the order it is listed.  For the
  above example, all the rules should be turned off, then the rules 'foo' 
  and 'bar' should be turned on and finally 'MyRule12345' should be turned off.

  [rcssserver-rel_2]
  * Added new trade-off between dash_power_rate and stamina_inc_max. The
  old trade-offs between dash_power_rate vs. player_size and
  stamina_inc_max vs. player_speed_max are switched off now by
  default. V8 clients get additional info regarding the new trade-off.
  player_speed_max is 1.2 now for all player types by default.

  * Players kicking the ball to themselves after a free kick is no longer
  allowed.  Players may kick the ball several times so long as they do not dash
  in between any of the kicks.  Once another player kicks the ball, the free
  kick taker may proceed to the ball as normal.  If a player does kick the ball
  to themselves after a free kick, a free kick is awarded to the opposing team
  at the point that the second kick occurred.  When this occurs the play mode
  changes to free_kick_fault_[rcssserver-lr], where the l or r is the side of the
  offending player.  After AFTER_FREE_KICK_FAULT_WAIT(30) cycles the playmode
  changes to free_kick_[rcssserver-lr], where l or r is the opposite side of the offending
  player.

  * Fixed bug in the setting of the team side of a ball owner condition in
  CLang.

  * Back passes are no longer allowed.  The server defines a back pass as when
  a player kicks the ball and it is caught by the goalie of the same team,
  without interference of a player from the other team.  If a back pass does
  occur, a free kick is awarded to the other teams in the closest corner of
  the penalty box. When this occurs the play mode changes to back_pass_[rcssserver-lr],
  where the l or r is the side of the offending goalie.  After
  AFTER_BACK_PASS_WAIT(30) cycles the playmode changes to free_kick_[rcssserver-lr],
  where l or r is the opposite side of the offending goalie.
  A pass from a player on team X bouncing of team Y player and then being
  caught by to team X goalie is *not* a back pass. A pass from a player on
  team X bouncing of an team Y player and then being caught by the team Y
  goalie is *not* a back pass.  

  * Audio from players now has the form

  (hear time direction TEAM [rcssserver-UNUM] "message") 
  (hear time TEAM [rcssserver-UNUM])

  where TEAM is 

  opp | our

  and the uniform number is only given for the player's own team (to simulate
  recognition of team-mates' voices).

  The first format is for the first message from each team in each cycle,
  all other messages received that cycle have the second format. 

  * Players can now send say messages with the message enclosed in quotes.
  For instance
  
  (say "message")

  It has the same effect as 

  (say message)

  The only difference is that the later version must be followed by a null,
  whereas the new version may be followed by other commands.  For instance

  (say "message")(dash 100)

  would be interpreted by the server as a say and a dash command, but

  (say message)(dash 100)

  would be interpreted as a single say message only, and the data being said as
  "message)(dash 100)"

  * Fixed a line ordering problem experienced by old clients.  Some of these
  clients rely on the order in which lines are presented (nearest first), so
  now the server sorts lines into nearest first for pre v8 clients. V8 and
  clients should not rely on the order of any of components of messages sent.
  BTW code I wrote for clients I was working on exhibits this reliance on
  ordering :)=

  * Added support for CLang Freeform messages during certain times during
  playon.  Coaches can send Freeform messages for freeform_send_period cycles
  after every freeform_wait_period cycles.  Default values for
  freeform_send_period and freeform_wait_period are 20 and 600 respectively.
  For example, if the playmode changes to playon at cycle 420 and stays in
  playon till the end of this example, the coaches can send freeform messages
  between 1020 and 1040, 1620 and 1640, etc. 

  [rcssserver-rel_1]
  * The CLang lib has changed and is not compatible with the previous version.
  To reflect this the library version has changed from 0.0.0 to 1.0.0.  Some of
  the classes still need a little work before I would say they are fully usable
  in client code, but what is already there should make it a lot easier than
  starting from scratch.  Just remember that the entire simulator is under
  LGPL (except for rcssmonitor which is under GPL), so if you do use modified
  server code in you clients, you *must* release these modifications when you
  release your binary. Earlier and more frequent releases would be more than
  welcome.  Hopefully this way we can start some sort of Standard RoboCup
  Library (SRCLib).

  * Added support for arithmetic on points within CLang messages.  Points can
  now have the form

  (<POINT_LIST>)
  
  where POINT_LIST is

  <POINT_LIST> <ARITH_OP> <POINT_LIST> | <POINT>

  where ARITH_OP is

	* + | - | * | /

  Normal operator precedence and bracket usage applies. As an example the
  following is the point halfway between the ball and the opponent player 5.

  (((pt ball) + (pt opp 5)) / (pt 2 2))

  The clients should interprete all point arithmetic operations are applied to
  the X and Y co-ordinate independently.  For instance,

  ((pt A B) ? (pt C D))
 
  where ? is one of the operators, should be interpreted as

  (pt A?B C?D)

  * Added support for triangular and rectangular regions in CLang.  They have
  the form

  (tri <point> <point> <point>)
  (rec <point> <point>) 

  * Added support for multiple actions in directives.  Players should treat
  directives with multiple actions in the same manner as if each action was
  sent as part of an individual directive.  The grammar for the new directives
  is

  ({do|dont} {our|opp} <UNUM_SET> <ACTION_LIST>)

  * Added ActPassReg, ActPassUNum, ActDribble, ActClear, ActShoot, ActHold,
  ActIntercept and ActTackle to CLang, which have the form

  (pass <REGION>)
  (pass <UNUM_SET>)
  (dribble <REGION>)
  (clear <REGION>)
  (shoot)
  (hold)
  (intercept)
  (tackle <UNUM_SET>)

  * Added CondUNum messages to the CLang, which has the form

  (unum <VAR> <UNUM_SET>)

  This allows coaches to limit the set of uniform numbers that can match a
  variable, such as 

  (info ( 9000 (and (bowner opp {X})(unum X {1 3 5})) (do our {5} (mark {X}))))

  * Added Player var messages to CLang, which allows messages similar to
  
  (info ( 9000 (bowner opp {X}) (do our {5} (mark {X}))))

  Players should evaluate the above message for X set to 1 ~ 11.  For instance
  if the current ball owner happens to be the opponent player 3, the player 5
  should mark opponent 3.

  The variables may be quoted can have the form

  [rcssserver-abe-oqrt-z]+[a-zA-Z0-9_]*

  or

  \"[rcssserver-0-9A-Za-z\(\)\.\+\-\*\/\?\<\>\_ ]+\"

  The format for unquoted variables may look a bit strange.  This is because
  the character p, d, c, and s can not be used to begin an unquoted variable as
  they are ball move tokens.

  Quoted variables do *not* equal unquoted variables -- i.e X is not the same
  as "X".

  * Added comparison messages to CLang. They have the form
  
  (time <COMP> <INT>)
  (opp_goals <COMP> <INT>)
  (own_goals <COMP> <INT>)
  (goal_diff <COMP> <INT>)
  (<INT> <COMP> time)
  (<INT> <COMP> opp_goals)
  (<INT> <COMP> our_goals)
  (<INT> <COMP> goal_diff)
           
  Where COMP is <, <=, ==, !=, >= or > and INT is some integer value that you
  are comparing the current time, or goals to.  Players should evaluate
  comparisons to true is the *current time* or *current goals* compared to the
  int is true.  The players should *not* take the time or goals to mean the
  time the command  was sent or the time the command was received.


[rcssmonitor_classic-8.05]

  [rcssmonitor_classic-rel_6]
  * Added support for new playmodes.


[rcssmonitor-8.05]

  [rcssmonitor-rel_8]
  * Fixed compilation problem on systems without linux/joystick.h.  The
  configure script now checks for this header and only includes the joystick
  code if this header is available.  

  [rcssmonitor-rel_6]
  * Fixed gcc3 compilation problems  

  * supports new play modes (back_pass_l etc.)

  * supports more sophisticated drawing primitives now. You can send messages
  with up to 4096 bytes with drawing information for the rcssmonitor. The
  messages must begin with "_2D_ " (or "_2D_L " or "_2D_R ") and can be
  followed by several drawing commands. 
  For example 
    
    '_2D_ LINE col=ff0000 (0,20,40,20) (0,20,40,0); CIRCLE col=0000ff (0,0,20)
       (0,0,40); STRING (-20,0,"my_pos");' 
    
  will draw 2 red lines, 2 blue circles and a string on top of the soccer
  field.
  
  Look into 
  ascii_processor.C: AsciiProcessor::ins_obj(...)
  smonitor_dev.C:    SMonitorDevice::server_interpret_frameview_msg(...)
  for more details. 


[rcsslogplayer-8.05]

  [rcsslogplayer-rel_6]
  * Added support for new playmodes

[8.04]

  * Added a script called rcsslogplay which may be used to start both the
  logplayer and a monitor.  When the montior exits, the logplayer also
  exits.


[rcssserver-8.04]

  [rcssserver-rel_5]
  * Fixed bug on some platforms in which no data is ever written to rcg files

  * Fixed bug in serialisation on 'clang ver' messages to clients

  * Fixed seg fault when players send 'clang ver' messages before the coach
	has connected.

  * Fixed bug in minimum recovery fix.

  * Added missing ')' to 'ok clang' message.

  [rcssserver-rel_4]
  * Fixed bug in which CLang messages were not sent to players because the side
  in the CLang message was not set correctly

  * Fixed bug that allowed minimum recovery to fall below recovery_min.

  * Added support for full-state messages when server is in synch mode.
  Thank you to Michael Gollin for pointing out the problem and the code
  for fixing it.

  * Fixed bug in automatic generation of server.conf for Tackle parameters

  * Logs are now flush manually to prevent log delays when they build up and
  flush manually

  * Fixed bug for reconnecting clients

  [rcssserver-rel_3]
  * Fixed compilation problems experienced on some machines.

  [rcssserver-rel_1]
  * The server now requires all players that support the Coach Language to
  explicitly advise the server, through the following command
  
  (clang (ver <MIN> <MAX>))

  Where MIN and MAX are unsigned ints indicating the minimum and maximum
  version numbers supported by the player.  Min must be less than or equal to
  max. If no such command is received by the server, it assumes that no CLang
  is supported.  When players hear an unsupported CLang message the get the
  following

  (hear <TIME> online_coach_{left|right} (unsupported_clang))

  instead of the actual clang message sent.  This means that previous clients
  need to be modified to be supported, they should send the following:

  (clang (ver 7 7))

  * Version 8 and above Online Coaches receive the following  

  (clang (ver (<player_name>) <min> <max>))

  to indicate what version of clang players support.

  * Added tackle variables to server.conf.  They still need to be added
  to the server_param messages.

  * Fixed  bugs in compression and decompression.  Thanks go to Hiroki Shimora
  for the patch.
  
  * Fixed error in reported direction of pointto.

  * Changed values of tackle and tackle fault which previously conflicted
  with ball collide and player collide

  * Fixed bug which saw all online coach commands parsed as offline coach
  commands.

  * Fixed bug in serialisation of player audio for pre-version 7 online
  coaches.

  * Fixed bug in penalty area flags being at +- 20.175, instead of +- 20.16

  * Recently the server has logged both messages sent and messages received.
  This sent messages are no longer logged for space reasons.  Later on this
  may be switchable via the server.conf

  * Fixed bug that caused server to sometimes output 
  "../rcssbase/rcssbase/udpsocket.h: 307: Error receiving from client:
  Interrupted system call"

  * Fixed bug when online coach connects

  * Introduced rcssclangparser library for easy use of a clang parser in
  clients

  * Players can now tackle by using the tackle command in the form

  `(tackle <POWER>)'

  This renders the player immobile for 10 cycles.  The tackle success is
  determined randomly with the probability based of the ball's position
  relative to the tackling player using the following formula:

  fail_prob = ( player_2_ball.x / tackle_dist )^6  
              + ( |player_2_ball.y| / 1.25 )^6;

  where tackle_dist is 2.5 if the ball is in front of the player and 0.5
  otherwise. Player_2_ball is a vector from the player to the ball, relative
  to the player's body direction.

  If the tackle is successfull, theball is pushed in the direction of the
  players body.

  When players can see another players team, they can also see if that player 
  is tackling via a `t' flag as follows:

  `((p "<TEAMNAME>" <UNUM>) <DIST> <DIR> <DISTCHG> <DIRCHG>
                            <BDIR> <HDIR> [rcssserver-<POINTDIR>] [t])' 

  `((p "<TEAMNAME>") <DIST> <DIR> [rcssserver-<POINTDIR>] [t])' 

  Players can get information about their tackling in the sense body message,
  where

  `(tackle (expires <EXPIRES>) (count <COUNT>))'
  
  is placed after the arm information.  EXPIRES is the number of cycles the
  current tackle will last for, with 0 indicating that the player isn't
  tackling.  COUNT is the number of times tackle has been executed by that
  player.

  Coach visuals now can indicate if a player is tackling via a `t' flag as
  follows:
  
  `((p "<TEAMNAME>" <UNUM>) <X> <Y> <VEL_X> <VEL_Y> <ANGLE> <NECK_ANGLE>
                            [rcssserver-<ARM_DIR>] [t])'

  * Rcssclient now supports very basic scripting.  The client will read from a
  file specified with the -script option and send one line immediately after
  receiving a sense body message.  Since the first to arguments are used to
  specify the host and port, one must specify these as well as the -script
  option.  For instance the following command:

  rcssclient localhost 6000 -script foobar

  will start the client using the script foobar.

  To send more than one message per cycle, simply put multiple messages on one
  line.  NOTE: When sending multiple messages, the say message must be last.

  * The pointto count is now incremented for both turning it on and turning
  it off.  Before pointto off commands would not affect the pointto count.

  * Players can now hear 1 msg per cycle from each team with a maximum length
  of 10 bytes. 

  * Hear messages for version 8 and above players are now delayed to the
  beginning of the next cycle (after the sensebody message). 

  * Version 8 and above players can now send attentionto commands to focus
  their attention on a particular player.  The command has the form:

  (attentionto <TEAM> <UNUM>) | (attentionto off)

  Where <TEAM> is 

  opp | our | l | r | left | right | <TEAM_NAME>
 
  and <UNUM> is integer identifying a member of the team specified. Players
  can only focus on one player at a time (each attentionto command overrides
  the previous) and cannot focus on themselves.

  If the player focuses on player A from team T (AKA pTA), the player will hear
  one message selected randomly from the say messages issued by pTA in the
  previous cycle.  If pTA did not issue any say commands, the player will hear
  one message selected randomly from all the say messages issued by players in
  team T.  At the same time, the player will hear one message selected randomly
  from the other team.  If attentionto is off (default) the player will hear
  one message from each team selected randomly from the messages available.

  The current state of focus is reported in the sense body message to the
  player, where either of the follwing

  (focus (target none) (count <COUNT>))
  (focus (target {l|r} <UNUM>) (count <COUNT>)

  is added as the last element of the sense body message.


[rcssmonitor_classic-8.04]

  * Fixed bug that would prevent the monitor from connecting to the server or
  the logplayer.  The was because the monitor had no default version number.
  The default is now 2.

  * See  ChangeLog for previous changes

[rcssmonitor-8.04]

  [rcssmonitor-rel_3]
  * Fixed gcc3 compilation problems

  [rcssmonitor-rel_1]
  * Fixed (hopefully) compilation problem on FreeBSD

[rcssbase-8.04]

  * Removed exceptions from UDPSocket, due to their inefficiency.  This has
  resulted in a major change the the UDPSocket interface.

  * Added sendChecked and recvChecked functions that will try to resend if the
  error was EINTR or EWOULDBLOCK and will try to re-receive if the error was
  EINTR.

  * Replaced void* with char* in all UDPSocket methods

[8.03]

  * Fixed bug which prevent automatic log file renaming when using the
  rcsoccersim script

[rcssserver-8.03]

  * Full state messages now are sent without the redundant stamina
  data at the beginning of the message.

  * Landmark reader has been disabled due to problems on Solaris.

  * rcssclient now prints the port and host is is connecting to.

  * Players can now send commands to point to a spot on the field of
  the form:

    `(pointto <DIST> <DIR>)'

  or

    `(pointto off)'

  The first form will cause the arm to point to the spot DIST meters
  from the player in DIR direction, relative to the player's current
  face direction.
  The player will continue to point to the same location on the field
  independent of an motion or rotation of the player for at least
  `point_to_ban' cycles (5), and until another `pointto' command is
  issued or `point_to_duration' cycles (20) pass.
  The second form disables a previous call of `pointto'.

  * Version 8+ players can now see where a player is pointing, if the
  player is pointing, the player is in view and they are close enough
  to determine their team name. In these cases the player part of the
  `see' message has the form (without the newline):

    `(p "<TEAMNAME>" <UNUM>) <DIST> <DIR> <DISTCHG> <DIRCHG>
                             <BDIR> <HDIR> <POINTDIR>)' 
  
  or

    `(p "<TEAMNAME>") <DIST> <DIR> <POINTDIR>)' 
  
  Where `POINTDIR' is the direction the players are is pointing with
  random Gaussian (normal)noise added to the actual direction, with a
  mean of zero and a standard deviation calculated as follows:

    sigma = pow(dist / team_too_far_length, 4) * 178.25 + 1.75

  This means that sigma is a minimum of 1.75 deg and reaches 180 deg
  when the player is observing a pointing arm from a distance of
  team_too_far_length.  Since 95% of values in a normal distribution
  are within two standard deviations, then 95% of the time the noise
  will be in the range +- 2.5 deg when the player is very close and
  in the range +- 360.0 deg when the player is team_too_far_length
  away.  Beware the other 5% of cases ;)

  * Version 8+ coaches (on and offline) can see where a player is
  pointing to if the player is pointing.  The direction the player
  is pointing comes just after the players neck angle. 
  
  * Fullstate messages have both <POINTDIST> and <POINTDIR> included
  between neck angle and stamina.  The players own arm state has the
  same format as in sense body (see below) and can be found between
  the count and score part.

  * sensebody messages for version 8+ clients now contain information
  about the arm actuator.  The following has been inserted into the
  sensebody message, just before the last `)', without the new line:

    `(arm (movable <MOVABLE>) (expires <EXPIRES>)
          (target <DIST> <DIR>) (count <COUNT>))'

  Where:

    - <MOVABLE> is the number of cycles till the arm is movable.
      0 indicates the arm is movable now

    - <EXPIRES> is the number of cycles till the arm stops pointing.
      0 indicates that the arm is no longer pointing,

    - <DIST> and <DIR> are the distance and direction of the point the
      player is pointing to, relative to the players location,
      orientation and neck angle, accurate to 10cm or 0.1 deg.

    - <COUNT> is the number of times the `pointto' command has been
      successfully executed by the player.


  * Server param has two new parameters:
    - `point_to_ban' is the minimum number of cycles between each
      successful `pointto' command.

    - `point_to_duration' is the number of cycles a `pointto' will last
      before expiring.

  * Use of the dedicated sockets is now enforced for version 8+ clients.
  Version 8+clients that send commands to the init sockets get the
  following reply

    (error only_init_allowed_on_init_port)

  and have their command(s) discarded.

  * If the server looses UDP connectivity with a client, the server will
  treat that client as though is sent bye or dispbye.

  * Added missing parameters to server_param. Please see serverparam.C
  for details of the new format.

  * Sensors have been rewritten to make the code cleaner, easier to
  maintain, easier to extend and best of all, faster! :D

  * Created warning message for version 8.0 and above players that send
  commands without null terminators.  This happens usually because
  players specify the length of the message with strlen, which does not
  include the null terminator.  The warning message has the format

    `(warning message_not_null_terminated)'
	
  * Added support for compressed communication with clients. clients can
  now send 

    `(compression <level>)' 
  
  to the server.  If the server is compiled without ZLib, the server
  will respond with 

    `(warning compression_unsupported)'

  else if <level> is not a number between 0 and 9 inclusive, the server
  will respond with 

    `(error illegal_command_form)'
	
  else the server will respond with 

    `(ok compression <level>)'

  and all subsequent messages to that client will be compressed at that
  level, until a new compression command is received.

  If a compression level above zero is selected, then the client is
  expected to compress their commands to the server.  
  
  Specifying a level of zero turns off compression completely (default).

  * The sample client supports the new compression option.  i.e. Compressed
  messages will be uncompressed before they are written to the console and
  commands to the server are compressed before sending.

  * Added a profile option to the server parameters. If profile is on and
  text logging is enabled, then the time take for different parts of the
  simulation cycle is written to the text log.  Default is off

  * Fixed bug in server's command line option parsing.

  * Fixed possible, but rare infinite loop in collision modelling.

See ChangeLog for previous changes.




