Tik-79.230 Foundations of Agent-Based Computing
Project assignments
- are instructed by
Tomi Janhunen
- Office Hours: February 23, March 30 and April 6, 20 and 27
(14.15-15.00).
- Deadline: May 13 (see submission instructions for details)
- Grading: rejected, accepted
and accepted with distinction
(the last increases the course grade by one).
[Assignment]
[Software & Documents]
[Tests]
[Project Report]
[Submission/Results]
The assignment is to implement a soccer playing agent in C or C++
using the
RoboCup
software platform which allows playing soccer in a simulated environment.
Minimum requirements to be met: the agent should be capable of
operating in two playing roles with the following basic functionality:
- Forward: run to the ball
and kick it towards the other team's goal
- Defender/Goalkeeper: try to keep between
the ball and the goal
In each role, the player should keep a reasonable position in
the field, e.g. the goalkeeper should not run too far away from the
goal. The soccer server (or the user) provides a number (1-11) for a
player and that number is to determine the playing role as well as the
initial position of the player in the field. The agent should also
respect the play modes of the server as specified in the manual
(see Appendix A.6).
The following subtasks can be identified for the project:
- interpreting the sensor information (to a reasonable extent)
to build an internal representation of the world state
(such as positions of ball, goals and other players),
- determining the operation strategy of the agent and
- performing actions on the basis of the world state
and the strategy of the agent.
The environment is unreliable in (at least) two respects.
First of all, the soccer server adds "noise" to the sensor
information, e.g. the positional information obtained by the agent is
not quite accurate. Secondly, it is quite possible that messages are
lost, since UDP-protocol is used in the architecture. These factors
should be taken into account in the implementations.
The client can be developed in any environment but it should use the
primitives of the above libraries and compile in a Unix/Linux environment
(and thus gcc and g++ are recommended
compilers). The agent is to be invoked by the following command and
arguments:
agent <server> <port> <team> [<number>]
where <server> is the server host name,
<port> is the server UDP port number (defaults to 6000),
<team> is the team name and <number> is the
number of the player which is to determine the playing role of the
agent. If <number> is omitted, the agent adopts the
number provided by the server (see init and
reconnect primitives of the protocol in
Appendix A.1 of the manual).
A test installation is available on Computing centre's alphas
(viulu.hut.fi, huilu.hut.fi, etc.). The required software
has been installed under directory /p/edu/tik-79.230/.
A simple demo can be set up as follows:
- Start the soccer server in the subdirectory sserver-3.28/
by running the appropriate script sserver-<your-shell>.tmpl
- Start the clients e.g. in the subdirectory humboldt/ using
scripts like spawn and spawn1 (you propably have to copy
these scripts into your home directory, since they write
useful kill commands into files named "pids" and "pids1").
The clients agent and agent1 are identical except
they send different team names to the server.
- Other interesting clients reside in the directories
sserver-3.28/sampleclient/ and sclient-0.31/
You should be prepared for the following tests on agents:
Basic test: two agents (one acting as a forward and the other
acting as a goalkeeper/defender) should exhibit a reasonable action
(as specified above).
Advanced (optional) test: a whole team is tested against
another (e.g. one obtained from the web). This requires that all
play roles have been properly implemented.
A short (10 pages maximum) description of the implementation is
required. The report should address the solutions of the three
subtasks given above (including links to the source code).
You should prepare a directory named "agent" with
the following contents:
- file README which contains general information
including your name and student id
- directory src which contains all the required
the source code (excluding the above mentioned libraries if unchanged)
and a makefile including compilation instructions in English.
- directory doc which contains your project
report (in ascii or PostScript format)
- directory test which contains
scripts to invoke a demo of your agents/team in action
Then you should make a compressed tar-archive of the directory and let
Tomi Janhunen know
where (machine, directory) this archive is available for a
ftp-transfer (machines at Niksula or Computing Centre will do).
You should prepare a short talk and a demo of your
implementation to be presented on the 13th of May at 2 o'clock in the
afternoon, presumably in Digital Systems Laboratory, room Y429A.
If you cannot attend, you should make an appointment with
Tomi Janhunen.
Submissions have now been evaluated. Click
here
for the results.
Latest update: April 27, 1998 by
Tomi Janhunen