Collaboration diagram for RoboSim:

Classes
class	RoboAPIImplementor

class	RoboSimExecutionException

class	RobotData

class	SimGridAllyDeterminant

class	SimGridCell

Public Member Functions
Robot.GridCell[][]	getWorldGrid ()

String	getOccupantPlayer (Robot.GridCell to_convert)

	RoboSim (String[] combatants, int initial_robots_per_combatant, int skill_points, int length, int width, int obstacles) throws RoboSimExecutionException

String	executeSingleTimeStep () throws RoboSimExecutionException

Private Member Functions
SimGridCell[][]	getSubGrid (int x_left, int y_up, int x_right, int y_down)

Static Private Member Functions
static Robot.GridCell[][]	sanitizeGrid (SimGridCell[][] simgrid, String player)

static Robot.Robot_Specs	checkSpecsValid (Robot.Robot_Specs proposed, String player, int skill_points) throws RoboSimExecutionException

Private Attributes
final int	WALL_HEALTH = 10

final int	WALL_DEFENSE = 10

SimGridCell[][]	worldGrid

ArrayList< RobotData >	turnOrder

int	turnOrder_pos

SimulatorGUI	gui

Detailed Description

Definition at line 8 of file RoboSim.java.

Constructor & Destructor Documentation

RoboSim.RoboSim	(	String[]	combatants,
		int	initial_robots_per_combatant,
		int	skill_points,
		int	length,
		int	width,
		int	obstacles
	)		throws RoboSimExecutionException

Constructor for RoboSim:

Parameters

combatants	array of String objects containing the names of the Robot classes for each combatant
initial_robots_per_combatant	how many robots each team starts out with
skill_points	skill points per combatant
length	length of arena
width	width of arena
obstacles	number of obstacles on battlefield

Definition at line 185 of file RoboSim.java.

References checkSpecsValid(), Robot.createRobot(), RoboSim.RobotData.robot, turnOrder, turnOrder_pos, WALL_HEALTH, and worldGrid.

           {
                //Create grid
                worldGrid = new SimGridCell[length][];
                for(int i=0; i<length; i++)
                {
                     worldGrid[i] = new SimGridCell[width];
                     for(int j=0; j<width; j++)
                     {
                          worldGrid[i][j] = new SimGridCell();
                          worldGrid[i][j].x_coord = i;
                          worldGrid[i][j].y_coord = j;
                          worldGrid[i][j].contents = Robot.GridObject.EMPTY;
                     }
                }
 
                //Random number generator
                generator = new Random();
 
                //Initialize array to hold turn order
                turnOrder = new ArrayList<RobotData>(combatants.length*initial_robots_per_combatant);
 
                //Position in turnOrder
                turnOrder_pos = 0;
 
                //Add robots for each combatant
                for(String player : combatants)
                {
                     Constructor gen_robot;
                     try
                     {
                         gen_robot = Class.forName(player).getConstructor();
                     }
                     catch(ClassNotFoundException e)
                     {
                         throw new RoboSimExecutionException("robot not found", player);
                     }
                     catch(NoSuchMethodException e)
                     {
                         throw new RoboSimExecutionException("Student's robot doesn't have a default constructor", player);
                     }
                     for(int i=0; i<initial_robots_per_combatant; i++)
                     {
                          int x_pos,y_pos;
                          do
                          {
                               x_pos = generator.nextInt(length);
                               y_pos = generator.nextInt(width);
                          } while(worldGrid[x_pos][y_pos].contents!=Robot.GridObject.EMPTY);
 
                          worldGrid[x_pos][y_pos].contents = Robot.GridObject.SELF;
                          RobotData data = worldGrid[x_pos][y_pos].occupant_data = new RobotData();
                          data.assoc_cell = worldGrid[x_pos][y_pos];
                          try
                          {
                                  data.robot = (Robot)(gen_robot.newInstance());
                          }
                          catch(Exception e)
                          {
                                  throw new RoboSimExecutionException("something went wrong invoking studen'ts constructor", player);
                          }
                          data.player = player;
                          byte[] creation_message = new byte[64];
                          creation_message[1] = (byte)(turnOrder_pos % 256);
                          creation_message[0] = (byte)(turnOrder_pos / 256);
                          data.specs = checkSpecsValid(data.robot.createRobot(null, skill_points, creation_message), player, skill_points);
                          data.status = new Robot.Robot_Status();
                          data.status.charge = data.status.health = data.specs.power*10;
                          data.buffered_radio = new ArrayList<byte[]>();
                          turnOrder.add(data);
                     }
                }
 
                //Add obstacles to battlefield
                for(int i=0; i<obstacles; i++)
                {
                     int x_pos, y_pos;
                     do
                     {
                          x_pos = generator.nextInt(length);
                          y_pos = generator.nextInt(width);
                     } while(worldGrid[x_pos][y_pos].contents!=Robot.GridObject.EMPTY);
                     worldGrid[x_pos][y_pos].contents = Robot.GridObject.WALL;
                     worldGrid[x_pos][y_pos].wallforthealth = WALL_HEALTH;
                }
           }

Here is the call graph for this function:

Member Function Documentation

static Robot.Robot_Specs RoboSim.checkSpecsValid	(	Robot.Robot_Specs	proposed,
		String	player,
		int	skill_points
	)		throws RoboSimExecutionException

staticprivate

Definition at line 167 of file RoboSim.java.

Referenced by RoboSim.RoboAPIImplementor.finalizeBuilding(), and RoboSim().

           {
                if(proposed.attack + proposed.defense + proposed.power + proposed.charge != skill_points)
                     throw new RoboSimExecutionException("attempted to create invalid robot!",player);
                return proposed;
           }

Here is the caller graph for this function:

String RoboSim.executeSingleTimeStep ( ) throws RoboSimExecutionException

Executes one timestep of the simulation.

Returns: the winner, if any, or null

Definition at line 1031 of file RoboSim.java.

References RoboSim.RobotData.status, turnOrder, and turnOrder_pos.

           {
                for(turnOrder_pos=0; turnOrder_pos<turnOrder.size(); turnOrder_pos++)
                {
                     //References to robot's data
                     RobotData data = turnOrder.get(turnOrder_pos);
                     WorldAPI student_api = new RoboAPIImplementor(data);
 
                     //Charge robot an amount of charge equal to charge skill
                     data.status.charge = Math.min(data.status.charge + data.specs.charge, data.specs.charge*10);
 
                     /*We can spend up to status.power power this turn, but
                      *no more than our current charge level*/
                     data.status.power = Math.min(data.specs.power, data.status.charge);
 
                     //Defense boost reset to zero at beginning of turn
                     data.status.defense_boost = 0;
 
                     //Clone status for student
                     Robot.Robot_Status clonedStatus;
                     try
                     {
                         clonedStatus = (Robot.Robot_Status)(data.status.clone());
                     }
                     catch(CloneNotSupportedException e)
                     {
                         throw new RuntimeException("error cloning in executeSingleTimeStep.  This is not the student's fault.");
                     }
 
                     //Run student code
                     data.robot.act(student_api,clonedStatus,data.buffered_radio.toArray(new byte[0][]));
                }
                
                String player = turnOrder.get(0).player;
                for(int i=1; i<turnOrder.size(); i++)
                     if(!turnOrder.get(i).player.equals(player))
                          return null;
                return player;
           }

String RoboSim.getOccupantPlayer ( Robot.GridCell to_convert )

SimulatorGUI needs to see who owns the robots in the cells This is a hack to allow this by downcasting the passed GridCell to SimGridCell and extracting the data.

Definition at line 104 of file RoboSim.java.

           {
                return ((SimGridCell)(to_convert)).occupant_data.player;
           }

SimGridCell [][] RoboSim.getSubGrid	(	int	x_left,
		int	y_up,
		int	x_right,
		int	y_down
	)

private

Helper method to retrieve a subgrid of the world grid

Parameters

x_left	left x coordinate (inclusive)
y_up	smaller y coordinate (inclusive)
x_right	right x coordinate (inclusive)
y_down	larger y coordinate (inclusive)

Returns: subgrid of the world grid (NOT copied or sanitized)

Definition at line 119 of file RoboSim.java.

References worldGrid.

Referenced by RoboSim.RoboAPIImplementor.getVisibleNeighborhood(), and RoboSim.RoboAPIImplementor.getWorld().

           {
                final int x_length = x_right - x_left + 1;
                final int y_height = y_down - y_up + 1;
 
                SimGridCell[][] to_return = new SimGridCell[x_length][y_height];
                for(int i=x_left; i<=x_right; i++)
                     for(int j=y_up; j<=y_down; j++)
                          to_return[i-x_left][j-y_up] = worldGrid[i][j];
                
                return to_return;
           }

Here is the caller graph for this function:

Robot.GridCell [][] RoboSim.getWorldGrid ( )

This is so SimulatorGUI can get a copy of world

Definition at line 99 of file RoboSim.java.

References worldGrid.

99 { return worldGrid; }

RoboSim.worldGrid

SimGridCell[][] worldGrid

Definition: RoboSim.java:93

static Robot.GridCell [][] RoboSim.sanitizeGrid	(	SimGridCell	simgrid[][],
		String	player
	)

staticprivate

Sanitizer to create a GridCell[][] 2D array to give to client.

Parameters

simgrid	SimGridCell 2D array with cells to sanitize
player	String containing player's name. Used to create sanitized grid as it would be seen from player's perspective.

Returns: sanitized grid or subgrid from player's perspective

Definition at line 139 of file RoboSim.java.

References Robot.GridCell.contents, RoboSim.SimGridCell.occupant_data, RoboSim.RobotData.player, and RoboSim.SimGridCell.wallforthealth.

Referenced by RoboSim.RoboAPIImplementor.getVisibleNeighborhood(), and RoboSim.RoboAPIImplementor.getWorld().

           {
                Robot.GridCell[][] to_return = new Robot.GridCell[simgrid.length][simgrid[0].length];
                for(int i=0; i<simgrid.length; i++)
                     for(int j=0; j<simgrid[0].length; j++)
                     {
                         SimGridCell sanitized;
                         try
                         {
                                 sanitized = (SimGridCell)(simgrid[i][j].clone());
                         }
                         catch(CloneNotSupportedException e)
                         {
                                 throw new RuntimeException("Problem in sanitizeGrid() clone attempt.  This is not the student's fault.");
                         }
                          if(sanitized.contents==Robot.GridObject.SELF)
                               if(sanitized.occupant_data.player.equals(player))
                                    sanitized.contents=Robot.GridObject.ALLY;
                               else
                                    sanitized.contents=Robot.GridObject.ENEMY;
                          sanitized.occupant_data=null;
                          sanitized.wallforthealth=0;
                          to_return[i][j] = sanitized;
                     }
 
                return to_return;
           }