Due date: Midnight Mon Dec 7.

In this project you will use classes to implement behavior of various robots as they war with each other. The project is similar to the code from Day 26 and Day 27 (in particular Day 27), so you should start by understanding the design of the code from Day 27. The war proceeds as follows.

• The world is a 20 unit by 20 unit grid and at most one robot can be at each grid location. The grid locations are labeled with (0,0) the lower-left corner.
• Each robot has 50 life points, and when the life points are depleted the robot dies. Since we are computer scientists and we start counting at zero, a health total of zero is perfectly acceptable! The robot will only die if its health is negative.
• The robots are divided into two teams and a team wins when all the robots on the other team are dead.
• Each robot has a location in the grid and a direction the robot is facing. Robots cannot face diagonals, they must face one of the four grid directions.
• The robot war proceeds in turns: each robot preforms one action per turn. The possible actions are:
  • move forward
  • turn 90 degrees right
  • turn 90 degrees left
  • turn 180 degrees
  • do nothing
  • attack
• There are two kinds of robots:
  • A random attack robot. Each turn the attack robot works as follows.
    • If there is an enemy robot directly in front, the robot attacks and deals a random amount of between 1 and 6 damage with each amount of damage equally likely (like a 6 sided die). After attacking, the turn is over. To calculate the amount of damage, use random.randrange(1,7).
    • If there is a teammate directly in front of the robot, the robot does nothing this turn.
    • If there is no robot directly in front, but there is an enemy robot to the right or left, the attack robot turns towards the enemy robot (and then the turn is over). If there are enemies to both the left and right, the robot prefers to turn right.
    • If the above does not occur (no enemies to the left, right, or straight ahead), the attack robot moves randomly. With a 50% chance it moves forward and with a 25% chance it turns left and with a 25% chance it turns right. After one of these three actions, the turn is over. Note that the robot can't see behind itself so still moves randomly if there is an enemy directly behind it. If the random choice is to move forward but there is a teammate directly forward, the robot just waits instead. In addition, if the random choice is to move forward but the robot is facing a wall, it turns 180 degrees instead. The random choice should be made using random.choice(["F", "F", "L", "R"]).
  • A medic robot. The medic robot works as follows.
    • Each turn, the medic robot heals all teammates that are to the left, right, or straight ahead of the medic. The medic heals a random amount of between 0 and 3 health with each amount equally likely. A robot cannot go above 50 health. Note that a medic robot could potentially heal three teammates in a single turn. Each teammate should have its own random check for healing amount using random.randrange(0,4). The teamates should be healed in order from right, center, then left. (This is important so that your test code matches our test code.)
    • After potentially healing, the medic robot moves one step according to a list of movement commands that are read out of a file (see below for the format). If the medic movement command is move forward and another robot is in the way, the medic does not move and the move forward command is retried the next turn. If the medic movement command is move forward and the medic is facing a wall, it turns 180 degrees instead.

Implementation

For the implementation, you will be required to create four classes. The grading is such that you should first work on getting the attack robots to work and then attempt the medic robot. The code should be in two files, world.py and robots.py.

World class

You must create a class called World which stores the grid and the robots at each location. This class must be in a file called world.py. The only property should be the 20x20 grid: an array of arrays where each element in the array is either None or a robot object. It must have the following methods. You can create additional methods to help your implementation.

• move_robot: this method takes four parameters: oldx, oldy, newx, newy and moves the robot object from (oldx,oldy) to (newx,newy). The method can assume there exists a robot at (oldx, oldy) and the position (newx, newy) is empty.
• kill_robot: this method takes two parameters x and y and removes the robot at the position.
• test_position: this method must accept two parameters x and y and return as follows.
  • None if there is no robot at this position.
  • The object for a robot at this position if the location is occupied.
• add_attack_robot: this method must accept parameters team, x, y, and direction, where team is 1 or 2, x and y are the initial location, and direction is one of "N", "E", "S", or "W" for the four directions. For example, world.add_attack_robot(1, 3, 5, "N") must succeed to add an attack robot for team one at location (3, 5) facing north. You may assume that a robot will not be added to a currently occupied location.
• add_medic_robot accepts the parameters: team, x, y, direction, and filename. The team, x, y, and direction parameters are just like for an attack robot, and the filename is a string containing a path to file (see the format below).
• run_turn: this method takes no parameters and iterates all robots and runs their turns. Individual robot turns must be run in the order (0,0), (0, 1), (0, 2), ..., (0, 19), (1,0), (1,1), ... that is an outer loop over x and an inner loop over y. This is called x-major-order. Be careful to make sure that a robot only gets one turn even when the robot is moving east or north.
• game_over: this method takes no parameters and returns 1 if the war is over and team 1 has won, returns 2 if the war is over and team 2 has won, and returns None if the game is not yet over.

Robot class

You must create a generic Robot class which implements the shared actions and properties between the two types of robots. This Robot class should be in a file robots.py. The properties should be the team, current location, direction, and hit points. Your Robot class must have (at least) the following methods:

• get_team: no parameters and returns either 1 or 2 depending on the team.
• get_health: no parameters and returns the current health.
• get_direction: no parameters and returns a string "N", "S", "E", "W" for the current direction.
• left90 and right90: no parameters and no return value, but turn the robot.
• healthchange: accepts two parameters: the world object and a positive or negative integer specifying how much to change the health. If the health goes negative, the robot should kill itself by calling the method on the world object. Remember a robot cannot exceed 50 health.
• forward method:
  • one parameter which is the world object
  • This method first checks if the robot is facing a wall and if so rotates 180 degrees.
  • Next the method uses the world to check if there is a robot in the way and if so does nothing.
  • If neither of the above two are true (the position in front of the robot is open), the world.move_robot method is called and also the internal position properties on the Robot class are updated.
  • The method returns True if the robot turned 180 degrees or moved forward, and returns False if there is a robot in the way.
• You can add more methods at your discretion that you feel are needed. For example, I added a method called board_position_in_direction which returns the x,y location in a given direction.

As a hint on the direction, I suggest you keep the current direction the robot is facing as a string "N", "E", "S", "W". You can then use dictionaries with keys "N", "E", "S", "W" to implement the turning and moving. (For example, left90 should use {"N":"W", "W":"S", "S":"E", "E":"N"}.)

AttackRobot

You must create a AttackRobot class which inherits from the generic Robot class. The AttackRobot class must implement a run_turn method with one parameter which is the world object. The run_turn method must implement the attack robot behavior by using the world object to check the neighboring robots and attack or move. The class must also be in robots.py. You should consider some helper methods to implement to make run_turn easier to implement, such as a function to attempt an attack or check for a turn. These are just examples, you can use whatever helper methods you like. (When coming up with a helper method, you might think about if it should appear on the Robot base class or inside AttackRobot.)

MedicRobot

You must create a MedicRobot class which inherits from the generic Robot class. The MedicRobot class must implement a run_turn method with one parameter which is the world object. The run_turn method must implement the medic robot behavior. It should also be in robots.py. The grading is such that we will test your code with no medics first, so you should not work on the medic until you have the attack robot working correctly. Each medic reads movement commands from a file and this should be done inside the __init__ method; during __init__ the entire file contents should be read in as commands into a list, so that run_turn does not have any file access. Again you should consider writing helper methods such as a method to read the commands from the file or interpret a command.

The format is as follows:

• Each line in the file is one movement command and one movement command is executed each turn.
• The first movement command is the first line in the file and successive lines are successive movement commands.
• Once the final command (on the last line) is executed, the medic must restart at the beginning of the commands with the command from the first line. The medic will just continuously loop through commands.
• Each line is one of four strings:
  • Forward
  • Left90
  • Right90
  • Turn180
• If the command is Forward and the medic is facing a wall, the medic should turn 180 degrees instead.
• If the command is Forward and there is a robot directly in front, no movement command is executed this turn and the Forward command is retried next turn.

Here is an example file contents with three commands (that causes the medic to move in a box as long as it is not near a wall).

Forward
Forward
Left90

Testing

First, while you are writing each class you should write a few tests which call the various methods you are writing. None of this test code should be submitted, but it is helpful to test small pieces of code before testing if all the code works.

For testing the entire program, here is some sample test code you can stick in a file called test.py.

from world import *
from robots import *

def print_board(w):
    print("-" * 60)
    for y in range(19,-1,-1):
        line = ""
        for x in range(0,20):
            r = w.test_position(x, y)
            if r == None:
                line += ".... "
            else:
                if isinstance(r, AttackRobot):
                    rtype = "A"
                elif isinstance(r, MedicRobot):
                    rtype = "M"
                else:
                    rtype = "!"
                if r.get_team() == 1:
                    line += "%s%02i%s " % (rtype, r.get_health(), r.get_direction())
                else:
                    line += "%s%02i%s " % (rtype.lower(), r.get_health(), r.get_direction())
        print(line)
    print("-" * 60)

world = World()
# Add a few robots (try different values)
world.add_attack_robot(1, 5, 5, "N")
world.add_attack_robot(....)

print_board(world)

# Run a turn and see the result
world.run_turn()
print_board(world)

world.run_turn()
print_board(world)

And check that the board positions are correct.

Some Test Samples

this directory has some test code I have written. Each test comes with a python file which imports test.py (which I provide) and the world and robot code you have written. Some of the tests also come with an instruction file for the medics. Each test also comes with an output file which was generated by running the test code. You should be checking that your output matches the expected output.

I have run these tests on Python 3.4.0 64 bit Linux.

Grading

Our grading will work by first specifying a random seed using seed, adding robots to your world class, calling run_turn on the board several times, then calling test_position to determine if the world is correct.

See Also

This project was partly inspired by pyrobotwar.