news

在LINUX下运行的仿真机器人服务器源代码

  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

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

  or

  \"[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.

[8.04]
  [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.

  [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

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

  [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, the燽all 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> [<POINTDIR>] [t])' 

  `((p "<TEAMNAME>") <DIST> <DIR> [<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>
                            [<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.

[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