An Introduction to RoboCup

Document Sample
An Introduction to RoboCup Powered By Docstoc
					An Introduction to
     February 24, 2004

         by Kevin Lam
   Portions by Paul Marlow
Overview of RoboCup
Demonstration Game
Simulator Mechanics
Simulator Communications Protocol
Some Existing Clients
Other Developments/Tools
Overview of RoboCup
 The Robot World Cup Initiative
 “By the year 2050, develop a team
 of fully autonomous humanoid
 robots that can win against the
 human world soccer champion
 A standard problem for AI research
Overview of RoboCup
 Started in 1992 as the Robot J-
 League (Japan)
 First games and conferences in
 Workshops, conferences and yearly
RoboCup Leagues

        small size

       middle size

World Championships
       RoboCup 2004 - Lisbon
       RoboCup 2003 - Padua
    RoboCup 2002 - Fukuoka/Busan
       RoboCup 2001 - Seattle

      RoboCup 2000 - Melbourne
      RoboCup 1999 - Stockholm
        RoboCup 1998 - Paris
       RoboCup 1997 - Nagoya
RoboCup Simulator

Monitor clients
Player clients (i.e. agents!)
Coach clients

         QuickTime™ an d a
    MPEG-4 Video decompressor
   are need ed to see this p icture .
Simulator Mechanics
   Clients and Server

                  Server                 Client
 Client                                 Client
  Client                              Client
    Client                           Client
     Client                        Client
       Client                     Client

   One server
   Up to 11 clients per team (plus coach)
   Clients/server communicate via UDP/IP
                   Server                  Client
 Client                                   Client
  Client                                Client
    Client                             Client
     Client                          Client
       Client                       Client

   Can be written in any language (C++,
   Java, Smalltalk, ...)
   Can be run on same machine or a
   Clients may talk only to the server... not
   to each other!
                  Server                  Client
 Client                                  Client
  Client                               Client
    Client                            Client
     Client                         Client
       Client                      Client

    Coach                            Coach
                 Soccer Monitor

   Monitor(s) used to visualize the action
   and/or interrupt the game
   Coaches (optional) to give guidance to
 RoboCup Clients
Autonomous agents
The “brains” of the players
Sensory information received from
server, decision made, action command
sent back to server
One agent represents one player
One agent designates itself as the goalie
             RoboCup Clients

       time                               dash
   play mode                              turn
    my body             Player         turn head
   landmarks            Agent             kick
  other players                          catch
     speech                              speak
coach instructions   decision-making

Sensory Input                          Outputs
 RoboCup Server
Keeps time (typically 6000 simulator
cycles, 10 cycles per second)
Receives client messages, updates
“world model”, sends back new status
“Automated Referee” tracks current play
Play Modes
         kick off

        game on


       out of field


 half time and game over
   Starting a Game
Download and install applications
(running the configure and make scripts
for the Unix / Linux systems)
Run the Server (default host is localhost
and default port is 6000)
Run the Monitor, connecting to the host
and port of the Server
Connect the players to the Server host
and port
Start the kick-off!
Connection Protocols
• From client to server:
  – (init TeamName [(version VerNum)]
  – (reconnect TeamName Unum)
  – (bye)
• From server to client:
  – (init Side Unum PlayMode) as a
    response for both client init and
    reconnect messages
    • Side = l | r; Unum = 1 ~ 11
         An Example
• send 6000 : (init MyTeam)
• recv 1067 : (init l 1 before_kick_off)
• recv 1067 : (see 0 ((goal r) 66.7 33)
  ((flag r t) 2 55.73)((flag p r t) 42.5 23)
  ((flag p r c) 53.5 43))
• recv 1067 : (see 0 ((goal r) 66.7 33)
  ((flag r t) 55.7 3) ((flag p r t) 42.5 23)
  ((flag p r c) 53.5 43))
• send 1067 : (move 0 0)
Client Commands
     Client Command           Once per Cycle
     (catch Direction)             Yes
(change_view Width Quality)        No
       (dash Power)                Yes
   (kick Power Direction)          Yes
        (move X Y)                 Yes
      (say Message)                No
       (sense_body)                No
          (score)                  No
      (turn Moment)                Yes
     (turn_neck Angle)             Yes
    Client Sensor
Three main message types:
Noise models for each
    Hear Messages

Can hear one message per team per
(hear Time Sender “Message”)
– Sender = online_coach_left/right,
  referee, self, Direction
– Direction = -180 – 180 degrees
       Hear Example

•(hear 18 self FCPortugal ETV 18
world_status r 2 0.98 -10.95 16.64 1 0.95
•0.00 0.00 1 0.95 0.00 0.00 3 0 OtGL- -
fGXtZ 3F.- /sdhAl 1p.- 0 40.0 0.0 0 2 )
        See Messages
(see Time ObjInfo)
–  ObjInfo:
    •(ObjName Distance Direction
     DistChange DirChange
     BodyFacingDir HeadFacingDir) or
    •(ObjName Distance Direction
     DistChange DirChange) or
    •(ObjName Distance Direction) or
    •(ObjName Direction)
     See Messages
 – (p [TeamName [UniformNum [goalie]]]) or
 – (b) or
 – (g [l|r]) or
 – (f c); (f [l|c|r] [t|b]); (f p [l|r] [t|c|b]);
 • (f g [l|r] [t|b]); (f [l|r|t|b] 0);
 • (f [t|b] [l|r] [10|20|30|40|50]);
 • (f [l|r] [t|b] [10|20|30]);
 – (l [l|r|t|b])
 – (B); (F); (G); (P)
Flags and Lines
          See Example
•(see 18 ((f r t) 44.7 -22) ((f g r b) 47.9 30) ((f
g r t) 42.5 13) ((f p r c) 30.3 34 -0 0) ((f p r t)
25.3 -7 0 0) ((f t r 40) 36.2 -37) ((f t r 50) 44.7
-29) ((f r 0) 49.4 20) ((f r t 10) 47 8) ((f r t 20)
46.5 -3) ((f r t 30) 48.4 -15) ((f r b 10) 53.5 30)
((f r b 20) 59.1 38) ((f r t) 44.7 -22) ((f g r b)
47.9 30) ((g r) 44.7 22) ((f g r t) 42.5 13) ((f p r
c) 30.3 34) ((f p r t) 25.3 -7 0 0) ((f t r 40) 36.2
-37) ((f t r 50) 44.7 -29) ((f r 0) 49.4 20) ((f r t
10) 47 8) ((f r t 20) 46.5 -3) ((f r t 30) 48.4 -15)
((f r b 10) 53.5 30) ((f r b 20) 59.1 38) ((p
"FCPortugal") 36.6 28) ((l r) 41.7 -89))
    (sense_body Time
•            (view_mode {high | low} {narrow | normal |
•            (stamina StaminaEffort)
•            (speed AmountOfSpeed DirectionOfSpeed)
•            (head_angle HeadAngle)
•            (kick KickCount)
•            (dash DashCount)
•            (turn TurnCount)
•            (say SayCount)
•            (turn_neck TurnNeckCount)
•            (catch CatchCount)
•            (move MoveCount)
•            (change_view ChangeViewCount))

•(sense_body 19 (view_mode high normal)
(stamina 4000 1) (speed 0 0) (head_angle 0)
(kick 0) (dash 0) (turn 0) (say 98)
(turn_neck 0))
Privileged clients used to provide
Receives noise-free view of the whole
Can only send occasional messages to
players (info, advice, freeform, etc.)
Used for opponent modelling, game
analysis, giving strategic tips to
RoboCup Clients
  Some RoboCup
UvA Trilearn (Amsterdam) (2003
CMUnited (Carnegie Mellon)
Everest (China)
FC Portugal 2003 (Portugal)
HELIOS (Japan)
Magma Furtwangen (Germany)
Typical Approaches
Hard-coded behaviour
Scripted behaviour (e.g. planning)
Neural Networks
Opponent Modelling
Layered Learning
Behaviour Networks
    Example: UvA
Coordination Graphs for passing,
anticipating passes
Layered skills hierarchy (pass, intercept)
Behaviour modelling of opponents
Example: FC Portugal

 Strategic, ball possession, ball recovery
 “Situation Based Strategic Positioning”
 Given game situation, calculated best
 position and go there
  Example: Krislet

Only one strategy: run to the ball and try
to kick it!
Surprisingly effective
Written in Java, easy to extend
 Example: Stripslet

STRIPS style linear planning
Written by Aloke Wiki
Based off of Krislet
A Stripslet implementation is made up of
four main concepts: Actors, Sensors,
Actions, and a GoalList
These are designed to implement a
specific action, such as run-to-ball or
Contains two main elements, an execute
method – providing the functionality, and
a name – which is used as a key into a
hash table.
To add a new Actor
  Add a new class to the, implementing the
  Actor Interface
  Add the new Actor to the ActorTable hash in
These consist of objects which include a
sense method, as well as a name for a
hash table key.
Each is designed to determine the
boolean outcome of a specific predicate,
such as can-see-goal.
To add a new Sensor:
  Add a new class to, implementing the
  Sensor Interface
  Add the new Sensor to the SensorTable hash in
Actions consist of four members: name, precoditionList,
addList, deleteList.
name corresponds directly to that of the Actor name
property (e.g. “score-goal”)
precoditionList is a list of predicates which must be true
before execution of the action (e.g. “have-ball can-see-
addList is a list of predicates that will be true upon
execution of the action (e.g. “ball-in-net”)
deleteList is a list of predicates that will be false upon
execution of the action (e.g. “have-ball”)
To add an Action:
    StripsBrain maintains a list of actions, so any new
    actions must be added to this list
    Note that multiple predicates in a list are
    separated by spaces

  • actionList.add(new Action("score-goal", // name
  •                         "have-ball can-see-goal",
    // pre
  •                         "ball-in-net", // add
  •                         "have-ball")); // delete
Contains a list of goals for which the
agents try to achieve
Currently the default list consists of only
one predicate: “ball-in-net”
Interesting possibilities include
   Adding multiple goals
   Re-evaluating the goal list each cycle
   depending on the environment
Developing Clients
Soccer Server Manual
Start with Krislet and Stripslet
  Older server versions required (v 5.xx)
    Other Projects
Soccer Server 3D
3D Soccer Monitor (Robologvis)
Tools to convert logs into Flash
Log analyzers (eg. Team Assistant, Paul
Marlow’s Classifier)
        My Project
“Scene” Learning and Recognition
Could an agent learn from observing
Could a team observe another and as a
result start playing “similar to” what it
As little human intervention as possible!
    Project Goals
Scene Generation
  Extract data from game logs
  Create scenes - “snapshots”
Scene Learning (Reasoning)
  Associate key scenes, patterns of
  scenes, with action taken
    Project Goals
Scene Recognition
  Build a RoboCup client
  Searches from a stored library of key
  scenes and actions
  Evaluate performance
            Scene Descriptions
                                          An idea by Prof.
                                          Size of “slices” impacts
                                          complexity, accuracy
            Extreme                              Extreme
                      Left   Center    Right
              Left                                Right

Immediate             Ball


 Distant                     Goal     Opponent

• Most of the information about RoboCup
    itself was taken using from the RoboCup
    Soccer Server manual.
•   For the latest manuals and code, visit the
    RoboCup project website at: