readme

uva trilearn的robocup源程序

*****************************************************************
* UvA Trilearn 2002 - University of Amsterdam, The Netherlands  *
* Created by:           Jelle Kok                               *
* Team Coordinator:     Frans Groen                             *
* Research Coordinator: Nikos Vlassis                           * 
* Copyright 2000-2001.  Jelle Kok and Remco de Boer             *
* Copyright 2001-2002.  Jelle Kok                               *
* All rights reserved.                                          *
*****************************************************************

Last update: 02-07-2002


General information
-------------------

This directory contains the source files and configuration files for the UvA
Trilearn 2002 soccer simulation team which reached 4th place at RoboCup-2002.
The released code contains our low-level and intermediate level implementation
(agent-environment synchronization method, world model, player skills), but not
our high-level decision procedure. Instead, we have included a simple high-level
action selection strategy which is the same as that of the Simple Portugal team.
The fastest player to the ball intercepts the ball and shoots it to a random
corner in the opponent goal regardless of his position on the field. The
remaining players move to a strategic position which is determined by their home
position in the formation and by the position of the ball. 

Basically this release equals the source code released in 2001. The main 
differences are some added functionality, bug-fixes and the conversion to work
with the newest soccer server (8.x). 

Documentation
-------------

The source code has been extensively documented using Doxygen (www.doxygen.org).
The created html documentation can be downloaded from our website or generated
using the configuration file `doxygen.cfg' located in the source directory. Here
it is assumed that the program `dot' has been installed to create collaboration
diagrams. If this is not the case then set the variable `HAVE_DOT' in the file
`doxygen.cfg' to `NO'.

Furthermore, our master's thesis explains every aspect of the team in much
detail. This theis can also be downloaded from our website:
http://www.science.uva.nl/~jellekok/
 

Acknowledgements
----------------

The authors have initially built the team from scratch for their master's
graduation project at the University of Amsterdam. Although we have not copied
any code from other teams, we have looked at some of their methods and used this
knowledge for our own implementation. For this we would like to thank the
following teams:

- FC Portugal 2000: for their team formation and Simple Portugal team
- CMUnited-99     : for their interception and message parsing methods
- Cyberoos 2000   : for the description of their synchronization method
- Essex Wizards   : for the description of their multi-threaded architecture


Usage
-----

A binary can be created using the supplied `Makefile'. Its default configuration
is for Linux, but can be easily changed to work under Solaris (see contents of
the Makefile for details). Other platforms have not been tested. After creating
the binaries, they can be started using the start-up script `start.sh' (see
contents of this file for details). It is also possible to control an agent
using the keyboard. To start an agent in this mode one must use the option
`-mode 1' to start a player, i.e. use `trilearn_player -mode 1'. To get
information about the effect of the various key strokes one can type `help'.
Possibilities are, for example, "d 100 10" to send a (dash 100) command in the
next 10 cycles, or "ka 30 0" to kick the ball to position (30,0). To get an
indication of how our code can be used to build your own team, the user can look
at the method `deMeer5()' in the file `Player.C'.


More information
----------------
 
More information can be found at the official UvA Trilearn website:

   http://www.science.uva.nl/~jellekok/robocup/index.html
 
or contact:
 
   Jelle Kok     ([e-mail])
   Remco de Boer ([e-mail])


Global overview of classes
--------------------------

A global overview of the various classes is as shown below. Note that the
SenseHandler, ActHandler and other classes form three different threads that
work independently.


                    Object          Player  -- Formations
                      |               |
                      |               |
                      |               |
                      
                  WorldModel --- BasicPlayer
   
                      |               | 
                      |               |
                      |               |
                      
                SenseHandler      ActHandler
                      |               | 
                      |               |
                      |_______________|
                             |
                         Connection 
                         
                             |
                             |
                             |
                        SOCCERSERVER
                             
Utility classes which are used by the classes listed above but which are not
shown in the diagram are the following:

- PlayerSettings
- Logger, Timing (in Logger.C)
- ServerSettings
- SoccerTypes, SoccerCommand, Time (in SoccerTypes.C)
- Geometry, Line, Circle, Rectangle, VecPosition (all in Geometry.C)
- Parse


Description of classes
----------------------

A description of each of the classes is given below.


Connection
==========

This class makes a connection with a socket and contains methods for sending
messages to and receiving messages from this socket.


SenseHandler
============

This class handles the processing of messages that the agent receives from the
server. It parses these messages and sends the extracted information to the
WorldModel. It also sets a signal to indicate when an action should be sent to
the server; this signal is handled by the ActHandler.


ActHandler
==========

The ActHandler class deals with actuator output. It stores actions into two
different queues:

- m_queueOneCycleCommand: contains commands which can only be executed once
                          during a cycle (kick, dash, etc.); the command which
                          has been received last is sent to the server.
- m_queueMultipleCommands: contains commands which can be executed concurrently
                           with commands in m_queueOneCycleCommand (turn_neck,
                           say, etc.); all commands in this list are sent to the
                           server.

When the ActHandler receives a signal, it converts the soccer commands into
string messages and sends them to the server.


WorldModel
==========

This class contains the current representation of the world as observed by the
agent. This representation includes information about all the objects on the
field such as the positions and velocities of all the players and the ball.
Information concerning the current play mode is also stored, as well as the time
and the score. Furthermore, the WorldModel contains various types of methods
that deal with the world state information in different ways:

- Retrieval methods:  for directly retrieving information about objects in the
                      world model; these methods are defined in the file
                      `WorldModel.C'; this file also contains methods for
                      iterating over a specific set of objects; these methods
                      make it possible to compare information about different
                      objects in the same set (e.g. OBJECT_SET_OPPONENTS).
- Update methods:     for updating the world model based on new sensory
                      information received from the SenseHandler; these methods
                      are defined in the file `WorldModelUpdate.C'.
- Prediction methods: for predicting future states of the world based on past
                      perceptions and for predicting the effect of actions
                      performed by the agent; these methods are defined in the
                      file `WorldModelPredict.C'.
- High-level methods: for deriving high-level conclusions from basic information
                      about the state of the world (e.g. determining the fastest
                      teammate to the ball); these methods are defined in the
                      file `WorldModelHighLevel.C'.


Object
======

This class contains information about all the objects in the simulation. Its
implementation is spread over six separate classes which together form an object
type hierarchy. These classes are the following:

- Object:        abstract superclass that contains estimates (and associated
                 confidence values) for the global positions of all the objects
                 and that defines methods for retrieving an updating this
                 information.
- FixedObject:   subclass of the Object class that contains information about
                 the stationary objects on the field (flags, lines and goals);
                 it adds no additional attributes to those inherited from the
                 Object superclass.
- DynamicObject: subclass of the Object class that contains information about
                 mobile objects; it adds velocity information to the general
                 information provided by the Object class.
- BallObject:    subclass of the DynamicObject class which contains information
                 about the ball; it adds no additional attributes to those
                 inherited from the DynamicObject superclass.
- PlayerObject:  subclass of the DynamicObject class which contains information
                 about a specific player on the field (either a teammate or an
                 opponent); it adds attributes denoting the global neck angle
                 and global body angle of the player to the information provided
                 by the DynamicObject class and it holds a boolean attribute
                 which indicates whether the player is a goalkeeper or not; the