Navigation: Table of Contents, Index, next: BBDB Elisp Code, prev: Emacs Games

pRobot: Robots for Python

by Christian Rusche

Overview:

• Introduction
• Tournaments
• Commands
  • move
  • make
• Bits and Bytes
  • Files
  • Making a pRobot
  • The API
  • Sample Implementation
• Finally...

Introduction

pRobot is based on eRobot by Alexander Schröder. The original eRobot is written in Lisp. I liked the concept, but it was easier for me to transfer the code to Python than to learn Lisp. Some rules were changed, but I tried to maintain the main idea.

pRobot is something like Pokémon for computer scientists. Each player creates a computer program, a so-called pRobot. Then all the pRobots are thrown into a virtual arena, the war-ground. Within that arena they can walk, reproduce, and fight. All actions are computed by the pRobots without communication with the player. The pRobot that stays alive is the winner of the game.

Tournaments

Up to 10 players can enter the contest. Each player starts with one pRobot. The war-ground is a rectangle with some obstacles. The pRobots are placed at random on the war-ground. Then one Robot after the other can perform its action. After 1000 such turns, or when the pRobots of only one player remain, the round ends and points are distributed:

• If only the pRobots of one player remain, the player obtains 3 points.
• If the pRobots of two players remain, both players obtain 2 points.
• In all other cases, the owner of the remaining pRobots obtain 1 point.

After 10 rounds, the player with the most points is the winner. If a pRobot tries to change some variables of the war-ground or uses other methods not described in this document, the player is banned.

Commands

Each pRobot can perform three different commands: move, make and nothing. The commands move and make need a direction parameter, i. e. up, down, left or right. Combined directions like upper left are not allowed.

move

This command allows the pRobot to move on the war-ground. The result depends on the target field:

• If the target field is empty (i. e. no other pRobot and no wall) the pRobot moves to the new position.
• If the target field is a wall, nothing happens.
• If the target field is an enemy, the enemy is removed and the pRobot moves into the target field, if the neighborhood of the target field contains less pRobots of the belonging to the enemy team than there are pRobots belonging to the attacking team. The neighborhood of a field is the field itself, the upper left, upper, upper right, right field and so on (eight neighboring fields). When the attacker is not strong enough to beat the enemy, nothing happens.
• If the target field is occupied by a pRobot belonging to the same team, a new target field is chosen: It is the field in the same direction as the first one, but one field farther. This procedure is repeated until one of the three previous conditions is met.

make

This command builds a pRobot on the target field. The 'memory' (instance variables) of the pRobot are not copied. The result depends on the target field:

• If the target field is empty (i. e. no other pRobot and no wall) a new pRobot is produced in the target field. The new pRobot will do his first action in the same turn.
• If the target field is a wall or occupied by an enemy, nothing happens.
• If the target field is occupied by a pRobot of the same team, a new target field is chosen: It is the field in the same direction as the first one, but one field farther. This procedure is repeated until one of the three previous conditions is met.

Only 10 pRobots (including the first one) can be made in one round.

Bits and Bytes

The following chapters should show what is needed to program a pRobot, and which functionality is already provided by the pRobot environment.

Files

To play pRobot for Python you need pRobot and Python. There are three pRobot files:

• warground.py contains the visual and logical parts of the pRobot environment.
• robot_api.py is actually not necessary, but provides some useful functions.
• sample.py shows how to make a simple pRobot and how to start a tournament. Run this file for a demo.

The best way to get Python is www.python.org, where you can also download Tcl/Tk, which is needed to run pRobot. For Windows users the IDE PythonWin is recommended. I use version 1.5.2 of Python and version 8.0 of Tk.

Making a pRobot

To make a pRobot, you only have to program a class derived from the base class robot. The only class function that you are allowed to override is compute. This function is called by the warground. compute has to return 2 string values. The first return value can be 'move', 'make' or 'pass'. The second can be 'up', 'down', 'right', 'left' or 'pass'. Therefore the easiest pRobot is:

class stupid(robot):
    def compute(self):
        return "pass", "pass"

The robot class has some variables and functions that can be used by the pRobot:

• clan is the clan of the pRobot. All pRobots by the same player have the same clan.
• x and y are the coordinates of the pRobot.
• id is a string from 00 to 99. The first digit is always the id of the clan.
• look(x,y) returns None, a Wall or a pRobot, depending on what element is located on the field x,y. To check if a wall is returned, use the command isinstance(self.look(), wall).
• get_robots() returns a list of all pRobots.

The class clan has also some variables:

• id is a string from 0 to 9
• count is a number from 1 to 10 that shows how much pRobots were already built by this clan.

All these variables are private: no changes are allowed.

The API

The variables and functions shown in the chapter 'pRobot' would theoretically be sufficient to program a pRobot. The class robot has some functions that makes it easier to make an pRobot, however. These functions are all based only on the variables and functions already mentioned. Three types of functions are available.

Clan functions:

• get_clan() returns the number of the clan.
• get_clan_members() returns all pRobots that are members of a clan. So self.get_clan_members() returns all pRobots of the own clan.
• can_make() returns the number of pRobots, that can still be made.
• clan_counter() adds 1 to an internal counter and returns this value. The first value is 1.
• set_clan_info(name, value) sets the value of the parameter name.
• get_clan_info(name) returns the value of the parameter name. If the parameter was not already defined with the function set_clan_info(), None is returned.
• set_clan_target(pRobot) declares a pRobot as a target of the clan.
• get_clan_target() returns the pRobot that is the target of the clan.
• get_clan_dir() returns the direction that a pRobot has to take to reach the target of the clan.

pRobot functions:

• get_robot_id() returns the number of the pRobot.
• get_closest_friend() returns the closest pRobot from the same clan.
• get_closest _enemy() returns the closest pRobot from another clan.
• robot_counter() adds 1 to an internal counter and returns this value. The first value is 1.
• set_robot_info(name, value) sets the value of the parameter name.
• get_robot_info(name) returns the value of the parameter name. If the Parameter was not already defined with the function set_robot_info(), None is returned.
• distance(pRobot) returns the distance to an pRobot, e. g. self.distance(self.get_closest _enemy()) returns the distance between the current pRobot and the closest enemy.
• direction(pRobot) returns "up", "down", "right" or "left", the direction not blocked by walls and other pRobots towards the given pRobot.

Other functions

• cmd_random() returns a random command.
• dir_random() returns a random direction.
• dir_opposite(dir) returns the opposite direction of the given, self.dir_opposite(self.direction(self.get_closest_enemy()) flees from the closest enemy.

All listed functions are members of the class robot.

Sample Implementation

The following sample shows a possible function:

class wolf(robot):
    def compute(self):
        if self.can_make() > 0:
            return "make",self.dir_random()
        else:
            if self.get_clan_target() not in self.get_robots():
                self.set_clan_target(self.get_closest_enemy())
            if self.get_clan_target() == None:
                return "pass", "pass"
            else: 
                return "move", self.get_clan_dir()

This wolf uses the 'make' command until the function self.can_make() returns 0, that is when make limit is reached. Then it checks if the clan target still exists. If there is a possible target, the wolf goes in this direction, if not - normally at the end of the game - it stands still.

Finally...

If you would like to play a round pRobot or if you have comments to make please, mail me (c.rusche@bsiag.com). Good API functions and samples for this page are always welcomed.

I would like to thank Alex for the inspiration and the support he gave me during the development of pRobot.

Navigation: Top, Table of Contents, Index, next: BBDB Elisp Code, prev: Emacs Games