readme

这是一支完整的uva球队

*****************************************************************
* UvA_Trilearn 2003 - University of Amsterdam, The Netherlands  *
* Base code version of the RoboCup-2003 World Champion          *
* Created by:           Jelle Kok                               *
* Research Coordinator: Nikos Vlassis                           * 
* Team Coordinator:     Frans Groen                             *
* Copyright 2000-2001.  Jelle Kok and Remco de Boer             *
* Copyright 2001-2002.  Jelle Kok                               *
* Copyright 2002-2003.  Jelle Kok                               *
* All rights reserved.                                          *
*****************************************************************

Last update: 30-10-2003

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

 This directory contains parts of the source files and configuration
 files for the UvA Trilearn 2003 soccer simulation team which won the
 RoboCup-2003 Simulation League in Padova.  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.

 Furthermore, we deliberately have removed some specific aspects of
 our (low-level) code, i.e. the learned dribble skill and the opponent
 modeling in the intercept skill. Our intention was to make sure this
 base code would be a good starting point, but not too good, since
 that would be unfair for teams that have been working on their basic
 for the past years and would be immediately surpassed by new teams
 that use our code as a basis.

Usage
-----

 Autoconf and automake are used in order to create this package. A
 simple

        ./configure
        ./make

 should compile the sources. The sources have been developed under
 Linux, which is the recommened platform. However, Alexey Vasilyev
 (Riga Technical University, Latvia) has provided a windows port for
 the free Borland C++ compiler. See the ./windows directory for the
 necessary Makefile and Borland configuration files.

 After the binaries are compiled, they can be started using the
 start-up script `start.sh' (see contents of this file for details).

 To extend the high-level strategy of this team, look at the method
 `deMeer5()' in the file `PlayerTeams.cpp' which defines the
 high-level strategy of the team. The other most important areas for
 improvement are:

 - the goalie behavior 
 - intercept method that takes opponents into account 
 - dribble skill 

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 command

        make doc 

 in the directory of this README. The html files will be placed in the
 directory ./doc/html/. 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 `doc/doxygen.cfg'
 to `NO'.
 
Changes
-------

 The basic code has changed with respect to the previous base release
 in 2002 (and not only with the file names ending in .cpp now). Except
 for the improvements in the low-level methods (e.g., intercept, kick)
 and the creation of the world model, the code also supports the
 functionality of the 9.xx protocol (tackle, attentionto, etc) and the
 synchronization mode.

 We tried to keep the code backward-compatibility with the previous
 release, but we won't make any promises. Please report when you
 encounter any major problems.


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

 The team has initially been built from scratch in 2001 for the
 master's graduation project of Jelle Kok and Remco de Boer at the
 University of Amsterdam. Thereafter, Jelle Kok continued the work
 under supervision of Nikos Vlassis.

 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


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])


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