readme

uva trilearn的robocup源程序

                 agent himself is not a member of this class.
- AgentObject:   subclass of the PlayerObject class which contains information
                 about the agent himself. It adds attributes denoting the
                 stamina, view angle and view quality of the agent to the
                 information provided by the PlayerObject class.


BasicPlayer
===========

This class defines the various skills than an agent can perform. The way in
which these skills are executed depends on the current state of the world model.


PlayerSettings
==============

This class contains parameters which are used in the BasicPlayer class. An
example of such a parameter is `dPassEndSpeed' which denotes the desired end
speed of the ball when it is passed to a teammate. By changing the values of the
parameters in this class it is possible to adapt the behavior of the
BasicPlayer.


Player
======

This class is a subclass of the BasicPlayer class that contains methods for
reasoning about the best possible action in a given situation. Action selection
is based on the most recent information about the state of the world as obtained
from the WorldModel and on the role of the agent in the current team formation.
For making the final decision on whether a particular type of action should be
performed, the agent uses the parameter values which are specified in the
PlayerSettings class.


Formations
==========

This class contains information about possible team formations as well as a
method for determining a strategic position on the field. Formations are read
from a configuration file (formations.conf) and are based on those used by the
Simple Portugal team. The implementation is spread over three separate classes:

- PlayerTypeInfo:    contains information about a player type in a formation.
- FormationTypeInfo: contains information about one specific formation.
- Formations:        contains information about all the possible team formations
                     and stores the currently used formation. This class is
                     accessible from the WorldModel class.


GenericValues
=============

This class is a superclass for all classes that contain settings from the
PlayerSettings and ServerSettings classes. Using this class it is possible to
link variables to (text) names. When these names with their associated values
are read from (or written to) a file, the corresponding variables can be easily
set.

  
Logger
======

This class is used by all the other classes to log various kinds of information
for debugging purposes. It allows the programmer to specify the level of
abstraction (`loglevel') from which he desires debugging information and
contains an output stream for writing (usually a file). All log information that
is sent to the Logger has a number which is compared to the specified log level
(or range of log levels) to determine whether the information should be printed
or discarded. It is also possible to log the information together with a time
stamp. This time stamp corresponds to the time that has elapsed since a timer
was last restarted. This timer is represented by an object from the Timing class
which is also defined in the file `Logger.C'.


Timing
======

This class contains a timer and methods for restarting this timer and for
determining the amount of wall clock time that has elapsed since the timer was
started. It is mainly used for the timing of incoming messages from the server
and for debugging purposes.


Parse
=====

This class contains several static methods for parsing string messages. These
methods can skip characters up to a specified point and convert parts of a
string to integer or double values. They are mainly used by the SenseHandler
that handles the processing of messages from the soccer server.


ServerSettings
==============

This class contains all the server parameters which are used for the current
version of the soccer server (8.x). Examples are the maximum speed of a player
(player_speed_max) and the stamina increase per cycle (stamina_inc_max). When
the agent is initialized, the server sends him a message containing the values
for these parameters. This message is then parsed using the methods from the
Parse class and the resulting values are stored in ServerSettings.

  
SoccerTypes
===========

This class contains enumerations for different soccer types that are used in the
simulation. It creates an abstraction for using soccer-related concepts
(playmodes, referee messages, etc.) in a clean and consistent way throughout the
code. Furthermore, this class contains methods for converting parts of string
messages received from the server to the corresponding soccer types (e.g.
`(g l)' to `GOAL_LEFT').


SoccerCommands
==============

This class holds all the necessary information for creating a soccer command
that can be sent to the server. It contains variables denoting the possible
arguments (angle, power, etc.) of the different soccer commands and stores the
type of the current command. Only those variables which are related to the
current type will get a legal value. Furthermore, the class contains a method
for converting the command into a string message that will be accepted by the
soccer server. The definition of this class can be found in the file
`SoccerTypes.C'.


Time
====

This class holds the server time in the form of an ordered pair (t,s) where t
denotes the current server cycle and s is the number of cycles since the clock
has stopped. Here the value of t equals that of the time stamp contained in the
last message received from the server, whereas the value for s will always be 0
while the game is in progress. It is only during dead ball situations (e.g. free
kicks) that this value will be different, since in these cases the server time
will stop while cycles continue to pass (i.e. actions can still be performed).
Representing the time in this way has the advantage that it allows the players
to reason about the number of cycles between events in a meaningful way. The
definition of this class can be found in the file `SoccerTypes.C'.


Geometry
========

This class contains several static methods for performing geometrical
calculations and is mainly used by the BasicPlayer for working out action
details. Methods have been defined for dealing with (possibly infinite)
geometric series and for working with the abc-formula. Note that the
`Geometry.C' file also contains several goniometric functions which enable one
to specify angles in degrees rather than in radians.


VecPosition
===========

This class contains the representation of a position (x,y) and defines several
methods which operate on this position in different ways. Methods are defined
for relatively comparing positions (e.g. `isBehind', `isBetween', etc.) and for
converting relative positions to global positions and vice versa. This class
also allows you to specify positions in polar coordinates (r,phi) and contains
a method for converting polar coordinates (r,phi) to Cartesian coordinates
(x,y). Furthermore, the standard arithmetic operators have been overloaded for
positions. The definition of this class can be found in the file
`SoccerTypes.C'.


Line
====

This class contains the representation of a line: ax + by + c = 0. It allows one
to specify a line in different ways: by providing three values (a, b and c), by
giving two points on the line, or by specifying a single point on the line
together with an angle. Furthermore, this class contains methods for determining
the intersection point of two lines and for determining a line perpendicular to
the current line that goes through a given point. The definition of this class
can be found in the file `SoccerTypes.C'.


Circle
======

This class contains the representation of a circle and contains methods that
deal with circles. A circle is specified by a VecPosition object which denotes
its center and by a value denoting its radius. Methods have been defined for
computing the area and circumference of the circle and for determining the
intersection points of two circles as well as the size of their intersection
area. The definition of this class can be found in the file `SoccerTypes.C'.


Rectangle
=========

This class contains the representation of a rectangle and contains methods that
deal with rectangles. A rectangle is specified by two VecPosition objects
denoting the upper left corner and bottom right corner respectively. The most
important method in this class determines whether a given point lies inside the
current rectangle. The definition of this class can be found in the file
`SoccerTypes.C'.


The main file
=============
  
In the file `main.C' all the different classes are initialized and linked after
which the player mainloop is called. A single execution of this loop is as
follows:

- block until new sensory information is received
- tell the WorldModel to update all the information using the latest message
  from the server
- determine the best possible action in the form of a skill from the BasicPlayer
  class
- send an action command which is part of this skill to the ActHandler

This loop is called in each cycle after a sense_body or see message is received.
After a sense_body message a new action is determined based on a prediction of
the current world state, whereas after a see message a new action is chosen
based on the new visual information. In each case the action is put in the
ActHandler queue. In this way the ActHandler will always contain an action even
when no visual information arrived during a cycle. When visual information does
arrive the action determined after the sense message arrival can be optimized
based on the new information, but this is not necessary.