RoboSim.RoboAPIImplementor Class Reference

Inheritance diagram for RoboSim.RoboAPIImplementor:

Collaboration diagram for RoboSim.RoboAPIImplementor:

Public Member Functions
Robot.AttackResult	meleeAttack (int power, Robot.GridCell adjacent_cell) throws RoboSimExecutionException
Robot.AttackResult	rangedAttack (int power, Robot.GridCell nonadjacent_cell) throws RoboSimExecutionException
Robot.AttackResult	capsuleAttack (int power_of_capsule, Robot.GridCell cell) throws RoboSimExecutionException
void	defend (int power) throws RoboSimExecutionException
void	move (int steps, Robot.Direction way) throws RoboSimExecutionException
void	pick_up_capsule (Robot.GridCell adjacent_cell) throws RoboSimExecutionException
void	drop_capsule (Robot.GridCell adjacent_cell, int power_of_capsule) throws RoboSimExecutionException
Robot.BuildStatus	getBuildStatus ()
Robot.GridCell	getBuildTarget ()
int	getInvestedBuildPower ()
void	setBuildTarget (Robot.BuildStatus status, Robot.GridCell location) throws RoboSimExecutionException
void	setBuildTarget (Robot.BuildStatus status, Robot.GridCell location, byte[] message) throws RoboSimExecutionException
void	build (int power) throws RoboSimExecutionException
void	repair (int power) throws RoboSimExecutionException
void	charge (int power, Robot.GridCell ally) throws RoboSimExecutionException
void	sendMessage (byte[] message, int power) throws RoboSimExecutionException
Robot.GridCell[][]	getVisibleNeighborhood ()
Robot.GridCell[][]	getWorld (int power) throws RoboSimExecutionException
void	scanEnemy (Robot.Robot_Specs enemySpecs, Robot.Robot_Status enemyStatus, Robot.GridCell toScan) throws RoboSimExecutionException

Private Member Functions
	RoboAPIImplementor (RobotData actingRobot_)
boolean	isAdjacent (Robot.GridCell adjacent_cell)
boolean	calculateHit (int attack, int defense)
Robot.AttackResult	processAttack (int attack, SimGridCell cell_to_attack, int power) throws RoboSimExecutionException
void	finalizeBuilding (byte[] creation_message) throws RoboSimExecutionException

Private Attributes
RobotData	actingRobot

Detailed Description

The implementing class for the WorldAPI reference. We can't just use ourselves for this because students could downcast us to our real type and manipulate the simulator in untoward ways (not that any of you would do that, and I would catch it when I reviewed your code anyway, but still).

NOTE: THIS IS A NON-STATIC INNER CLASS!

Definition at line 282 of file RoboSim.java.

Constructor & Destructor Documentation

RoboSim.RoboAPIImplementor.RoboAPIImplementor ( RobotData  actingRobot_ )

private

Private constructor

Parameters

actingRobot_

data for robot attempting to act in the simulator

Definition at line 290 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot.

Referenced by RoboSim.RoboAPIImplementor.processAttack().

{ actingRobot = actingRobot_; }

Here is the caller graph for this function:

Member Function Documentation

void RoboSim.RoboAPIImplementor.build

(

int

power

)

throws RoboSimExecutionException

Parameters

power

how much power to apply to building the current target. Must not be more than remaining power needed to finish building target.

Implements WorldAPI.

Definition at line 883 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, and RoboSim.RobotData.status.

               {
                    if(power > actingRobot.status.power || power < 0)
                         throw new RoboSimExecutionException("attempted to apply invalid power to build task",actingRobot.player,actingRobot.assoc_cell);
                    actingRobot.status.charge-=power;
                    actingRobot.status.power-=power;
                    actingRobot.investedPower+=power;
               }

boolean RoboSim.RoboAPIImplementor.calculateHit ( int  attack, int  defense  )

private

Did the attacker hit the defender?

Parameters

attack	attack skill of attacker (including bonuses/penalties)
defense	defense skill of defender (including bonuses)

Returns

whether the attacker hit

Definition at line 311 of file RoboSim.java.

Referenced by RoboSim.RoboAPIImplementor.processAttack().

               {
                    int luckOfAttacker = generator.nextInt(10);
                    return luckOfAttacker+attack-defense>=5;
               }

Here is the caller graph for this function:

Robot.AttackResult RoboSim.RoboAPIImplementor.capsuleAttack	(	int	power_of_capsule,
		Robot.GridCell	cell
	)		throws RoboSimExecutionException

Capsule attack: attack with a capsule

Parameters

power_of_capsule	power of the capsule to use in the attack
cell	GridCell (may be adjacent or nonadjacent) to attack

Implements WorldAPI.

Definition at line 511 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, RoboSim.RoboAPIImplementor.processAttack(), RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Error checking, *sigh*...
                    if(cell==null)
                         throw new RoboSimExecutionException("passed null to capsuleAttack()",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    if(cell.x_coord > worldGrid.length || cell.y_coord > worldGrid[0].length || cell.x_coord < 0 || cell.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to capsuleAttack()",actingRobot.player,actingRobot.assoc_cell,cell);

                    //Cell to attack
                    SimGridCell cell_to_attack = worldGrid[cell.x_coord][cell.y_coord];

                    //Do we have a capsule of this power rating?
                    int capsule_index = ArrayUtility.linearSearch(actingRobot.status.capsules,power_of_capsule);

                    if(capsule_index==-1)
                         throw new RoboSimExecutionException("passed invalid power to capsuleAttack(): doesn't have capsule of power "+power_of_capsule,actingRobot.player,actingRobot.assoc_cell);

                    //Can we use this capsule? (attack + defense >= power)
                    if(actingRobot.specs.attack + actingRobot.specs.defense < power_of_capsule)
                         throw new RoboSimExecutionException("attempted to use capsule of greater power than attack+defense",actingRobot.player,actingRobot.assoc_cell);

                    //Can we hit the target?  Range is power of capsule + defense.
                    Robot.GridCell[] shortest_path = Robot.RobotUtility.findShortestPath(actingRobot.assoc_cell,cell_to_attack,worldGrid);

                    if(shortest_path==null)
                         throw new RoboSimExecutionException("no clear shot to target",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);

                    if(shortest_path.length > power_of_capsule + actingRobot.specs.defense)
                         throw new RoboSimExecutionException("target not in range",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);

                    //Is there an enemy, fort, or wall at the cell's location?
                    switch(cell_to_attack.contents)
                    {
                    case EMPTY:
                         throw new RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case BLOCKED:
                         throw new RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case SELF:
                         if(cell_to_attack.occupant_data.player.equals(actingRobot.player))
                              throw new RoboSimExecutionException("attempted to attack ally",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                         break;
                    case CAPSULE:
                         throw new RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case ALLY:
                         throw new RuntimeException("ERROR in RoboSim.RoboAPIImplementor.capsuleAttack().  This is probably not the student's fault.  Contact Patrick Simmons about this message.  (Not the Doobie Brother...)");
                    }

                    /*Okay, if we're still here, we can use the capsule.
                      Need to delete capsule from robot status structure.
                    */
                    actingRobot.status.capsules = ArrayUtility.deleteElement(actingRobot.status.capsules,capsule_index);

                    int[] newCapsules = new int[actingRobot.status.capsules.length-1];
                    boolean deleted_capsule = false;
                    for(int i=0,j=0; i<actingRobot.status.capsules.length; i++,j++)
                    {
                         if(!deleted_capsule && actingRobot.status.capsules[i]==power_of_capsule)
                         {
                              deleted_capsule=true;
                              j--;
                              continue;
                         }
                         newCapsules[j]=actingRobot.status.capsules[i];
                    }

                    //Process attack
                    return processAttack(actingRobot.specs.attack + power_of_capsule,cell_to_attack,(int)(Math.ceil(0.1 * power_of_capsule * actingRobot.specs.attack)));
               }

Here is the call graph for this function:

void RoboSim.RoboAPIImplementor.charge	(	int	power,
		Robot.GridCell	ally
	)		throws RoboSimExecutionException

Spend power to charge an adjacent ally robot. 1-for-1 efficiency.

Parameters

power	amount of power to use for charging ally
ally	cell containing ally to charge. Must be adjacent.

Implements WorldAPI.

Definition at line 905 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.SimGridCell.occupant_data, RoboSim.RobotData.player, RoboSim.RobotData.status, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Lots of error checking here (as everywhere...)
                    if(ally==null)
                         throw new RoboSimExecutionException("passed null as argument to charge()",actingRobot.player);

                    //Check that we're using a valid amount of power
                    if(power > actingRobot.status.power || power < 1)
                         throw new RoboSimExecutionException("attempted charge with illegal power level",actingRobot.player,actingRobot.assoc_cell);

                    //Are cells adjacent?
                    if(!isAdjacent(ally))
                         throw new RoboSimExecutionException("attempted to charge nonadjacent cell",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    //(could put this in isAdjacent() method but want to give students more useful error messages)
                    if(ally.x_coord > worldGrid.length || ally.y_coord > worldGrid[0].length || ally.x_coord < 0 || ally.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to charge()",actingRobot.player,actingRobot.assoc_cell,ally);

                    //Safe to use this now, checked for oob condition from student
                    SimGridCell allied_cell = worldGrid[ally.x_coord][ally.y_coord];

                    //Is there an ally in that cell?
                    if(allied_cell.contents!=Robot.GridObject.SELF || !allied_cell.occupant_data.player.equals(actingRobot.player))
                         throw new RoboSimExecutionException("attempted to charge non-ally, or cell with no robot in it",actingRobot.player,actingRobot.assoc_cell,allied_cell);

                    //Perform the charge
                    actingRobot.status.power-=power;
                    actingRobot.status.charge-=power;
                    allied_cell.occupant_data.status.charge+=power;
               }

Here is the call graph for this function:

void RoboSim.RoboAPIImplementor.defend

(

int

power

)

throws RoboSimExecutionException

Defend: increase defense

Parameters

power

power to use for defense (may not exceed defense skill)

Implements WorldAPI.

Definition at line 582 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, RoboSim.RobotData.specs, and RoboSim.RobotData.status.

               {
                    //Error checking
                    if(power < 0 || power > actingRobot.specs.defense || power > actingRobot.specs.power || power > actingRobot.status.charge)
                         throw new RoboSimExecutionException("attemped to defend with negative power",actingRobot.player, actingRobot.assoc_cell);

                    //This one's easy
                    actingRobot.status.charge-=power;
                    actingRobot.status.defense_boost+=power;
               }

void RoboSim.RoboAPIImplementor.drop_capsule	(	Robot.GridCell	adjacent_cell,
		int	power_of_capsule
	)		throws RoboSimExecutionException

drop_capsule: drop a capsule (for an ally to pick up, presumably)

Parameters

adjacent_cell	where to drop capsule (must be adjacent)
power_of_capsule	how powerful a capsule to drop

Implements WorldAPI.

Definition at line 703 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.RobotData.player, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Error checking, *sigh*...
                    //Can't pass us null
                    if(adjacent_cell==null)
                         throw new RoboSimExecutionException("passed null to pick_up_capsule()",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    if(adjacent_cell.x_coord > worldGrid.length || adjacent_cell.y_coord > worldGrid[0].length || adjacent_cell.x_coord < 0 || adjacent_cell.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to pick_up_capsule()",actingRobot.player,actingRobot.assoc_cell,adjacent_cell);

                    //Cell in question
                    SimGridCell gridCell = worldGrid[adjacent_cell.x_coord][adjacent_cell.y_coord];

                    //Cell must be adjacent
                    if(!isAdjacent(adjacent_cell))
                         throw new RoboSimExecutionException("attempted to pick up capsule in nonadjacent cell",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Is the cell empty?
                    if(gridCell.contents!=Robot.GridObject.EMPTY)
                         throw new RoboSimExecutionException("attempted to place capsule in nonempty cell",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Do we have such a capsule?
                    int index = ArrayUtility.linearSearch(actingRobot.status.capsules,power_of_capsule);
                    if(index==-1)
                         throw new RoboSimExecutionException("attempted to drop capsule with power "+power_of_capsule+", having no such capsule",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Okay.  We're good.  Drop the capsule
                    gridCell.contents = Robot.GridObject.CAPSULE;
                    gridCell.capsule_power = power_of_capsule;

                    //Delete it from our inventory
                    ArrayUtility.deleteElement(actingRobot.status.capsules,index);
               }

Here is the call graph for this function:

void RoboSim.RoboAPIImplementor.finalizeBuilding ( byte[]  creation_message ) throws RoboSimExecutionException

private

Definition at line 753 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.checkSpecsValid(), Robot.createRobot(), RoboSim.RobotData.invested_assoc_cell, RoboSim.RobotData.investedPower, RoboSim.RobotData.player, RoboSim.RobotData.robot, RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.turnOrder, RoboSim.WALL_HEALTH, and RoboSim.RobotData.whatBuilding.

Referenced by RoboSim.RoboAPIImplementor.setBuildTarget().

               {
                    //Nothing to finalize if not building anything
                    if(actingRobot.whatBuilding==null)
                         return;

                    //What do we have to finalize?
                    switch(actingRobot.whatBuilding)
                    {
                    case WALL:
                         if(actingRobot.investedPower >= 50)
                         {
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.WALL;
                              actingRobot.invested_assoc_cell.wallforthealth = WALL_HEALTH;
                         }
                         else
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.EMPTY;
                         break;

                    case FORT:
                         if(actingRobot.investedPower >= 75)
                         {
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.FORT;
                              actingRobot.invested_assoc_cell.wallforthealth = WALL_HEALTH;
                         }
                         else
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.EMPTY;
                         break;

                    case CAPSULE:
                         int capsule_power = actingRobot.investedPower/10;
                         if(capsule_power!=0)
                         {
                              if(actingRobot.status.capsules.length+1>actingRobot.specs.attack+actingRobot.specs.defense)
                                   throw new RoboSimExecutionException("attempted to finish building capsule when already at max capsule capacity",actingRobot.player,actingRobot.assoc_cell);
                              actingRobot.status.capsules = ArrayUtility.addElement(actingRobot.status.capsules,capsule_power);
                         }
                         break;

                    case ROBOT:
                         int skill_points = actingRobot.investedPower/20;
                         if(skill_points!=0)
                         {
                              //Check creation message correct size
                              if(creation_message!=null && creation_message.length!=64)
                                   throw new RoboSimExecutionException("passed incorrect sized creation message to setBuildTarget()",actingRobot.player,actingRobot.assoc_cell,actingRobot.invested_assoc_cell);

                              //Set default creation message if we don't have one
                              if(creation_message==null)
                              {
                                   creation_message = new byte[64];
                                   creation_message[1] = (byte)(turnOrder.size() % 256);
                                   creation_message[0] = (byte)(turnOrder.size() / 256);
                              }

                              //Create the robot
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.SELF;
                              RobotData data = actingRobot.invested_assoc_cell.occupant_data = new RobotData();
                              data.assoc_cell = actingRobot.invested_assoc_cell;
                              try
                              {
                                  data.robot = (Robot)(Class.forName(actingRobot.player).getConstructor().newInstance());
                              }
                              catch(Exception e)
                              {
                                  throw new RoboSimExecutionException("something went wrong calling student's constructor", actingRobot.player,actingRobot.assoc_cell, actingRobot.invested_assoc_cell);
                              }
                              data.player = actingRobot.player;
                              data.specs = checkSpecsValid(data.robot.createRobot(null, skill_points, creation_message), actingRobot.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);
                         }
                         else
                              actingRobot.invested_assoc_cell.contents = Robot.GridObject.EMPTY;
                         break;                              
                    }
               }

Here is the call graph for this function:

Here is the caller graph for this function:

Robot.BuildStatus RoboSim.RoboAPIImplementor.getBuildStatus

(

)

Tells us what we're in the middle of building.

Returns

BuildStatus object indicating what we're building. Is null if we're not building anything.

Implements WorldAPI.

Definition at line 738 of file RoboSim.java.

               {
                    return actingRobot.whatBuilding;
               }

Robot.GridCell RoboSim.RoboAPIImplementor.getBuildTarget

(

)

Returns

GridCell indicating the target of our building efforts. Is null if we're not building anything.

Implements WorldAPI.

Definition at line 743 of file RoboSim.java.

               {
                    return actingRobot.invested_assoc_cell;
               }

int RoboSim.RoboAPIImplementor.getInvestedBuildPower

(

)

Returns

how much we've invested in our current build target.

Implements WorldAPI.

Definition at line 748 of file RoboSim.java.

               {
                    return actingRobot.investedPower;
               }

Robot.GridCell [][] RoboSim.RoboAPIImplementor.getVisibleNeighborhood

(

)

Gets a copy of the portion of the world visible to the robot. Range is equal to defense skill. Does not cost any power.

Returns

a 2-dimensional array containing a GridCell for each cell visible to the robot.

Implements WorldAPI.

Definition at line 965 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.getSubGrid(), RoboSim.RobotData.player, RoboSim.sanitizeGrid(), and RoboSim.worldGrid.

               {
                    //YAY!  No parameters means NO ERROR CHECKING!  YAY!
                    final int range = actingRobot.specs.defense;
                    final int xloc = actingRobot.assoc_cell.x_coord;
                    final int yloc = actingRobot.assoc_cell.y_coord;
                    final int x_left = (xloc - range < 0) ? 0 : (xloc - range);
                    final int x_right = (xloc + range > worldGrid.length-1) ? (worldGrid.length-1) : (xloc + range);
                    final int y_up = (yloc - range < 0) ? 0 : (yloc - range);
                    final int y_down = (yloc + range > worldGrid[0].length - 1) ? (worldGrid[0].length-1) : (yloc + range);
                    Robot.GridCell[][] to_return = sanitizeGrid(getSubGrid(x_left,y_up,x_right,y_down),actingRobot.player);

                    //Set associated cell to SELF instead of ALLY
                    to_return[xloc - x_left][yloc - y_up].contents=Robot.GridObject.SELF;
                    return to_return;
               }

Here is the call graph for this function:

Robot.GridCell [][] RoboSim.RoboAPIImplementor.getWorld

(

int

power

)

throws RoboSimExecutionException

Gets a copy of the entire world. Takes 3 power, plus additional if jamming is taking place (which won't be; jamming is not implemented).

Parameters

power

to spend attempting to get the world

Returns

a 2-dimensional array containing a GridCell for each cell in the world. Will be null if jamming has prevented the world from being retrieved.

Implements WorldAPI.

Definition at line 982 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.getSubGrid(), RoboSim.RobotData.player, RoboSim.sanitizeGrid(), and RoboSim.worldGrid.

               {
                    if(power!=3)
                         throw new RoboSimExecutionException("tried to get world with invalid power (not equal to 3)",actingRobot.player,actingRobot.assoc_cell);

                    Robot.GridCell[][] to_return = sanitizeGrid(getSubGrid(0,0,worldGrid.length-1,worldGrid[0].length-1),actingRobot.player);

                    //Set self to self instead of ally
                    to_return[actingRobot.assoc_cell.x_coord][actingRobot.assoc_cell.y_coord].contents=Robot.GridObject.SELF;
                    return to_return;
               }

Here is the call graph for this function:

boolean RoboSim.RoboAPIImplementor.isAdjacent ( Robot.GridCell  adjacent_cell )

private

Utility method to check whether student's robot is adjacent to cell it is attacking. Note: diagonal cells are not adjacent.

Parameters

adjacent_cell

cell to compare with student's robot's position

Definition at line 297 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, and Robot.GridCell.x_coord.

Referenced by RoboSim.RoboAPIImplementor.charge(), RoboSim.RoboAPIImplementor.drop_capsule(), RoboSim.RoboAPIImplementor.meleeAttack(), RoboSim.RoboAPIImplementor.pick_up_capsule(), RoboSim.RoboAPIImplementor.rangedAttack(), and RoboSim.RoboAPIImplementor.setBuildTarget().

               {
                    return (Math.abs(actingRobot.assoc_cell.x_coord-adjacent_cell.x_coord)==1 &&
                              actingRobot.assoc_cell.y_coord == adjacent_cell.y_coord ||
                            Math.abs(actingRobot.assoc_cell.y_coord-adjacent_cell.y_coord)==1 &&
                              actingRobot.assoc_cell.x_coord == adjacent_cell.x_coord);
               }

Here is the caller graph for this function:

Robot.AttackResult RoboSim.RoboAPIImplementor.meleeAttack	(	int	power,
		Robot.GridCell	adjacent_cell
	)		throws RoboSimExecutionException

Melee attack: attack an adjacent grid cell

Parameters

power	Power to use for attack (may not exceed attack skill)
adjacent_cell	Adjacent GridCell to attack

Returns

AttackResult indicating whether attack succeeded and/or destroyed target of attack.

Implements WorldAPI.

Definition at line 389 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.SimGridCell.occupant_data, RoboSim.RobotData.player, RoboSim.RoboAPIImplementor.processAttack(), RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.SimGridCell.wallforthealth, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Lots of error checking here (as everywhere...)
                    if(adjacent_cell==null)
                         throw new RoboSimExecutionException("passed null as argument to meleeAttack()",actingRobot.player);

                    //Check that we're using a valid amount of power
                    if(power > actingRobot.status.power || power > actingRobot.specs.attack || power < 1)
                         throw new RoboSimExecutionException("attempted melee attack with illegal power level",actingRobot.player,actingRobot.assoc_cell);

                    //Are cells adjacent?
                    if(!isAdjacent(adjacent_cell))
                         throw new RoboSimExecutionException("attempted to melee attack nonadjacent cell",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    //(could put this in isAdjacent() method but want to give students more useful error messages)
                    if(adjacent_cell.x_coord > worldGrid.length || adjacent_cell.y_coord > worldGrid[0].length ||
                       adjacent_cell.x_coord < 0 || adjacent_cell.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to meleeAttack()",actingRobot.player,actingRobot.assoc_cell,adjacent_cell);

                    //Safe to use this now, checked for oob condition from student
                    SimGridCell cell_to_attack = worldGrid[adjacent_cell.x_coord][adjacent_cell.y_coord];

                    //Is there an enemy, fort, or wall at the cell's location?
                    switch(cell_to_attack.contents)
                    {
                    case EMPTY:
                         throw new RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case BLOCKED:
                         throw new RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case SELF:
                         if(cell_to_attack.occupant_data.player.equals(actingRobot.player))
                              throw new RoboSimExecutionException("attempted to attack ally",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                         break;
                    case CAPSULE:
                         throw new RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case ALLY:
                         throw new RuntimeException("ERROR in RoboSim.RoboAPIImplementor.meleeAttack().  This is probably not the student's fault.  Contact Patrick Simmons about this message.  (Not the Doobie Brother...)");
                    }
                    
                    //Okay, if we haven't thrown an exception, the cell is valid to attack.  Perform the attack.
                    //Update this robot's charge status and power status.
                    actingRobot.status.charge-=power;
                    actingRobot.status.power-=power;

                    //Begin calculation of our attack power
                    int raw_attack = actingRobot.specs.attack;

                    //If we're outside a fort attacking someone in the fort, range penalty applies
                    if(cell_to_attack.wallforthealth > 0 && cell_to_attack.occupant_data!=null)
                         raw_attack/=2;

                    //Attack adds power of attack to raw skill
                    int attack = raw_attack + power;

                    //Process attack
                    return processAttack(attack,cell_to_attack,power);
               }

Here is the call graph for this function:

void RoboSim.RoboAPIImplementor.move	(	int	steps,
		Robot.Direction	way
	)		throws RoboSimExecutionException

move: move robot

Parameters

steps	how far to move
way	which way to move

Implements WorldAPI.

Definition at line 593 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, RoboSim.RobotData.status, and RoboSim.worldGrid.

               {
                    if(steps<1)
                         return;

                    int x_coord = actingRobot.assoc_cell.x_coord;
                    final int actor_x = x_coord;
                    int y_coord = actingRobot.assoc_cell.y_coord;
                    final int actor_y = y_coord;
                    switch(way)
                    {
                    case UP:
                         y_coord-=steps;
                         break;
                    case DOWN:
                         y_coord+=steps;
                         break;
                    case LEFT:
                         x_coord-=steps;
                         break;
                    case RIGHT:
                         x_coord+=steps;
                         break;
                    }

                    //Is our destination in the map?
                    if(x_coord < 0 || x_coord > worldGrid.length || y_coord < 0 || y_coord > worldGrid[0].length)
                         throw new RoboSimExecutionException("attempted to move out of bounds",actingRobot.player,actingRobot.assoc_cell);

                    //Is our destination empty?
                    if(worldGrid[x_coord][y_coord].contents!=Robot.GridObject.EMPTY && worldGrid[x_coord][y_coord].contents!=Robot.GridObject.FORT)
                         throw new RoboSimExecutionException("attempted to move onto illegal cell",actingRobot.player,actingRobot.assoc_cell,worldGrid[x_coord][y_coord]);

                    //Are we approaching the fort from the right angle?
                    if(worldGrid[x_coord][y_coord].contents==Robot.GridObject.FORT && worldGrid[x_coord][y_coord].fort_orientation!=way)
                         throw new RoboSimExecutionException("attempted to move onto a fort from an illegal direction",actingRobot.player,actingRobot.assoc_cell,worldGrid[x_coord][y_coord]);

                    //Okay, now we have to make sure each step is empty
                    final boolean x_left = x_coord<actor_x;
                    final boolean y_left = y_coord<actor_y;
                    if(x_coord!=actor_x)
                    {
                         for(int i=(x_left ? actor_x-1 : actor_x+1); i!=x_coord; i=(x_left ? i-1 : i+1))
                              if(worldGrid[i][y_coord].contents!=Robot.GridObject.EMPTY)
                                   throw new RoboSimExecutionException("attempted to cross illegal cell",actingRobot.player,actingRobot.assoc_cell,worldGrid[i][y_coord]);
                    }
                    else
                    {
                         for(int i=(y_left ? actor_y-1 : actor_y+1); i!=y_coord; i=(y_left ? i-1 : i+1))
                              if(worldGrid[x_coord][i].contents!=Robot.GridObject.EMPTY)
                                   throw new RoboSimExecutionException("attempted to cross illegal cell",actingRobot.player,actingRobot.assoc_cell,worldGrid[x_coord][i]);
                    }

                    //Okay, now: do we have enough power/charge?
                    if(steps > actingRobot.status.power)
                         throw new RoboSimExecutionException("attempted to move too far (not enough power)",actingRobot.player,actingRobot.assoc_cell,worldGrid[x_coord][y_coord]);

                    //Account for power cost
                    actingRobot.status.power-=steps;
                    actingRobot.status.charge-=steps;

                    //Change position of robot.
                    actingRobot.assoc_cell.contents = Robot.GridObject.EMPTY;
                    actingRobot.assoc_cell.occupant_data = null;
                    actingRobot.assoc_cell = worldGrid[x_coord][y_coord];
                    actingRobot.assoc_cell.contents = Robot.GridObject.SELF;
                    actingRobot.assoc_cell.occupant_data = actingRobot;
               }

void RoboSim.RoboAPIImplementor.pick_up_capsule

(

Robot.GridCell

adjacent_cell

)

throws RoboSimExecutionException

pick_up_capsule: pick up a capsule

Parameters

adjacent_cell

GridCell where capsule is that you want to pick up (must be adjacent)

Implements WorldAPI.

Definition at line 662 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.RobotData.player, RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Error checking, *sigh*...
                    //Can't pass us null
                    if(adjacent_cell==null)
                         throw new RoboSimExecutionException("passed null to pick_up_capsule()",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    if(adjacent_cell.x_coord > worldGrid.length || adjacent_cell.y_coord > worldGrid[0].length || adjacent_cell.x_coord < 0 || adjacent_cell.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to pick_up_capsule()",actingRobot.player,actingRobot.assoc_cell,adjacent_cell);

                    //Cell in question
                    SimGridCell gridCell = worldGrid[adjacent_cell.x_coord][adjacent_cell.y_coord];

                    //Cell must be adjacent
                    if(!isAdjacent(adjacent_cell))
                         throw new RoboSimExecutionException("attempted to pick up capsule in nonadjacent cell",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //We need at least one power.
                    if(actingRobot.status.power==0)
                         throw new RoboSimExecutionException("attempted to pick up capsule with no power",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Is there actually a capsule there?
                    if(gridCell.contents!=Robot.GridObject.CAPSULE)
                         throw new RoboSimExecutionException("attempted to pick up capsule from cell with no capsule",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Do we have "room" for this capsule?
                    if(actingRobot.status.capsules.length+1>actingRobot.specs.attack+actingRobot.specs.defense)
                         throw new RoboSimExecutionException("attempted to pick up too many capsules",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //If still here, yes.

                    //Decrement our power
                    actingRobot.status.power--;

                    //Put capsule in our inventory, delete it from world
                    actingRobot.status.capsules = ArrayUtility.addElement(actingRobot.status.capsules,gridCell.capsule_power);
                    gridCell.contents = Robot.GridObject.EMPTY;
                    gridCell.capsule_power = 0;
               }

Here is the call graph for this function:

Robot.AttackResult RoboSim.RoboAPIImplementor.processAttack ( int  attack, SimGridCell  cell_to_attack, int  power  ) throws RoboSimExecutionException

private

Process attack, assigning damage and deleting destroyed objects if necessary.

Parameters

attack	attack skill of attacker (including bonuses/penalties)
cell_to_attack	cell attacker is attacking containing enemy or obstacle
damage	damage if attack hits

Definition at line 323 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.calculateHit(), RoboSim.RoboAPIImplementor.RoboAPIImplementor(), RoboSim.RoboAPIImplementor.setBuildTarget(), RoboSim.turnOrder, and RoboSim.turnOrder_pos.

Referenced by RoboSim.RoboAPIImplementor.capsuleAttack(), RoboSim.RoboAPIImplementor.meleeAttack(), and RoboSim.RoboAPIImplementor.rangedAttack().

               {
                    //Holds result of attack
                    Robot.AttackResult to_return = Robot.AttackResult.MISSED;

                    //Calculate defense skill of opponent
                    int defense = 0;
                    switch(cell_to_attack.contents)
                    {
                    case SELF:
                         defense = cell_to_attack.occupant_data.specs.defense + cell_to_attack.occupant_data.status.defense_boost;
                         break;

                    case FORT:
                    case WALL:
                         defense = 10;
                         break;
                    }


                    //If we hit, damage the opponent
                    if(calculateHit(attack,defense))
                    {
                         //We hit
                         to_return = Robot.AttackResult.HIT;

                         if(cell_to_attack.occupant_data!=null)
                         {
                              //we're a robot
                              for(int i=0; true; i++)
                                        if(turnOrder.get(i)==cell_to_attack.occupant_data)
                                        {
                                             if((cell_to_attack.occupant_data.status.health-=power)<=0)
                                             {
                                                  //We destroyed the opponent!
                                                  to_return = Robot.AttackResult.DESTROYED_TARGET;

                                                  //Handle in-progress build, reusing setBuildTarget() to handle interruption of build due to death
                                                  (new RoboAPIImplementor(cell_to_attack.occupant_data)).setBuildTarget(null,null);

                                                  //Handle cell
                                                  cell_to_attack.occupant_data = null;
                                                  cell_to_attack.contents = cell_to_attack.wallforthealth>0 ? Robot.GridObject.FORT : Robot.GridObject.EMPTY;

                                                  //Handle turnOrder position
                                                  turnOrder.remove(i);
                                                  if(i<turnOrder_pos)
                                                       turnOrder_pos--;
                                             }
                                             break;
                                        }
                         }
                         else
                              if((cell_to_attack.wallforthealth-=power)<=0)
                              {
                                   //We destroyed the target!
                                   to_return = Robot.AttackResult.DESTROYED_TARGET;

                                   cell_to_attack.wallforthealth = 0;
                                   cell_to_attack.contents = Robot.GridObject.EMPTY;
                              }
                    }

                    return to_return;
               }

Here is the call graph for this function:

Here is the caller graph for this function:

Robot.AttackResult RoboSim.RoboAPIImplementor.rangedAttack	(	int	power,
		Robot.GridCell	nonadjacent_cell
	)		throws RoboSimExecutionException

Ranged attack: attack nonadjacent grid cell within certain range

Parameters

power	Power to use for attack (may not exceed attack skill)
nonadjacent_cell	non-adjacent GridCell to attack

Returns

AttackResult indicating whether attack succeeded and/or destroyed target of attack.

Implements WorldAPI.

Definition at line 448 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.RobotData.player, RoboSim.RoboAPIImplementor.processAttack(), RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //Lots of error checking here (as everywhere...)
                    if(nonadjacent_cell==null)
                         throw new RoboSimExecutionException("passed null as argument to rangedAttack()",actingRobot.player,actingRobot.assoc_cell);


                    //Check that we're using a valid amount of power
                    if(power > actingRobot.status.power || power > actingRobot.specs.attack || power < 1)
                         throw new RoboSimExecutionException("attempted ranged attack with illegal power level",actingRobot.player,actingRobot.assoc_cell);

                    //Does cell exist in grid?
                    //(could put this in isAdjacent() method but want to give students more useful error messages)
                    if(nonadjacent_cell.x_coord > worldGrid.length || nonadjacent_cell.y_coord > worldGrid[0].length ||
                       nonadjacent_cell.x_coord < 0 || nonadjacent_cell.y_coord < 0)
                         throw new RoboSimExecutionException("passed invalid cell coordinates to rangedAttack()",actingRobot.player,actingRobot.assoc_cell,nonadjacent_cell);

                    //Are cells nonadjacent?
                    if(isAdjacent(nonadjacent_cell))
                         throw new RoboSimExecutionException("attempted to range attack adjacent cell",actingRobot.player,actingRobot.assoc_cell);

                    //Safe to use this now, checked for oob condition from student
                    SimGridCell cell_to_attack = worldGrid[nonadjacent_cell.x_coord][nonadjacent_cell.y_coord];

                    //Do we have a "clear shot"?
                    Robot.GridCell[] shortest_path = Robot.RobotUtility.findShortestPath(actingRobot.assoc_cell,cell_to_attack,worldGrid);
                    if(shortest_path==null) //we don't have a clear shot
                         throw new RoboSimExecutionException("attempted to range attack cell with no clear path",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    else if(shortest_path.length>actingRobot.specs.defense) //out of range
                         throw new RoboSimExecutionException("attempted to range attack cell more than (defense) tiles away",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);

                    //Is there an enemy, fort, or wall at the cell's location?
                    switch(cell_to_attack.contents)
                    {
                    case EMPTY:
                         throw new RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case BLOCKED:
                         throw new RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case SELF:
                         if(cell_to_attack.occupant_data.player.equals(actingRobot.player))
                              throw new RoboSimExecutionException("attempted to attack ally",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                         break;
                    case CAPSULE:
                         throw new RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,actingRobot.assoc_cell,cell_to_attack);
                    case ALLY:
                         throw new RuntimeException("ERROR in RoboSim.RoboAPIImplementor.rangedAttack().  This is probably not the student's fault.  Contact Patrick Simmons about this message.  (Not the Doobie Brother...)");
                    }

                    //Okay, if we haven't thrown an exception, the cell is valid to attack.  Perform the attack.
                    //Update this robot's charge status.
                    actingRobot.status.charge-=power;
                    actingRobot.status.power-=power;

                    //Begin calculation of our attack power
                    int raw_attack = actingRobot.specs.attack/2;

                    //Attack adds power of attack to raw skill
                    int attack = raw_attack + power;

                    //Process attack
                    return processAttack(attack,cell_to_attack,power);
               }

Here is the call graph for this function:

void RoboSim.RoboAPIImplementor.repair

(

int

power

)

throws RoboSimExecutionException

Spend power to repair yourself. 2 power restores 1 health.

Parameters

power

amount of power to spend on repairs. Should be even.

Implements WorldAPI.

Definition at line 892 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, RoboSim.RobotData.specs, and RoboSim.RobotData.status.

               {
                    if(power > actingRobot.status.power || power < 0)
                         throw new RoboSimExecutionException("attempted to apply invalid power to repair task",actingRobot.player,actingRobot.assoc_cell);
                    actingRobot.status.charge-=power;
                    actingRobot.status.power-=power;
                    actingRobot.status.health+=power/2;

                    //Can't have more health than charge skill*10
                    if(actingRobot.status.health > actingRobot.specs.charge*10)
                         actingRobot.status.health = actingRobot.specs.charge*10;
               }

void RoboSim.RoboAPIImplementor.scanEnemy	(	Robot.Robot_Specs	enemySpecs,
		Robot.Robot_Status	enemyStatus,
		Robot.GridCell	toScan
	)		throws RoboSimExecutionException

Scans an enemy (or ally), retrieving information about the robot. The cell scanned must be visible (within defense cells from us).
Takes 1 power.

Parameters

enemySpecs	empty Robot_Specs object to be filled in
enemyStatus	empty Robot_Status object to be filled in
toScan	cell containing robot we want to scan

Implements WorldAPI.

Definition at line 994 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RobotData.player, RoboSim.RobotData.specs, RoboSim.RobotData.status, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    if(enemySpecs==null || enemyStatus==null || toScan==null
                       || toScan.x_coord < 0 || toScan.x_coord >= worldGrid.length || toScan.y_coord < 0 || toScan.y_coord >= worldGrid[0].length || actingRobot.status.power==0)
                         throw new RoboSimExecutionException("Invalid parameters passed to scanEnemy()",actingRobot.player,actingRobot.assoc_cell);

                    SimGridCell cell = worldGrid[toScan.x_coord][toScan.y_coord];

                    //Are we within range?
                    if(Math.abs(actingRobot.assoc_cell.x_coord - cell.x_coord) > actingRobot.specs.defense || Math.abs(actingRobot.assoc_cell.y_coord - cell.y_coord) > actingRobot.specs.defense)
                         throw new RoboSimExecutionException("attempted to scan farther than range", actingRobot.player, actingRobot.assoc_cell);

                    //Is there a robot in this cell?
                    if(cell.contents != Robot.GridObject.SELF)
                         throw new RoboSimExecutionException("attempted to scan invalid cell (no robot in cell)", actingRobot.player, actingRobot.assoc_cell, cell);

                    //Register cost
                    actingRobot.status.power--;
                    actingRobot.status.charge--;

                    //Okay, we're good.  Fill in the data.
                    enemySpecs.attack = cell.occupant_data.specs.attack;
                    enemySpecs.defense = cell.occupant_data.specs.defense;
                    enemySpecs.power = cell.occupant_data.specs.power;
                    enemySpecs.charge = cell.occupant_data.specs.charge;
                    enemyStatus.power = cell.occupant_data.status.power;
                    enemyStatus.charge = cell.occupant_data.status.charge;
                    enemyStatus.health = cell.occupant_data.status.health;
                    enemyStatus.defense_boost = cell.occupant_data.status.defense_boost;
                    enemyStatus.capsules = cell.occupant_data.status.capsules.clone();
               }

void RoboSim.RoboAPIImplementor.sendMessage	(	byte[]	message,
		int	power
	)		throws RoboSimExecutionException

Spend additional power to get radio messages unavailable because of jamming.

Parameters

power

amount of power to spend to attempt to overcome jamming

Returns

messages received after additional power spent. Will include all messages included in simulator's call to act(). May be null if no messages were received. Sends a message to an ally or allies.

Parameters

message	64-byte array containing message to transmit
power	amount of power to use for sending message

Implements WorldAPI.

Definition at line 937 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, RoboSim.RobotData.player, RoboSim.turnOrder, and RoboSim.worldGrid.

               {
                    if(power < 1 || power > 2)
                         throw new RoboSimExecutionException("attempted to send message with invalid power", actingRobot.player,actingRobot.assoc_cell);

                    if(message.length!=64)
                         throw new RoboSimExecutionException("attempted to send message byte array of incorrect length", actingRobot.player,actingRobot.assoc_cell);

                    Robot.GridCell target = null;
                    if(power==1)
                    {
                         target = Robot.RobotUtility.findNearestAlly(actingRobot.assoc_cell,worldGrid);
                         if(target!=null)
                         {
                              /*There's a way to "cheat" here and set up a power-free comm channel
                               *between two allied robots.  If you can find it ... let me know, and
                               *you'll get extra credit :).  Additional credit for a bugfix.*/
                              ((SimGridCell)(target)).occupant_data.buffered_radio.add(message);
                         }
                         return;
                    }
                    else //power==2
                         for(RobotData x : turnOrder)
                              if(x!=actingRobot && x.player.equals(actingRobot.player))
                                   x.buffered_radio.add(message);
               }

void RoboSim.RoboAPIImplementor.setBuildTarget	(	Robot.BuildStatus	status,
		Robot.GridCell	location
	)		throws RoboSimExecutionException

Tells the simulator the robot is beginning to build something in an adjacent cell (or, for capsules, inside itself).
In order to mark a capsule or robot as "done", call this method with both parameters null. This will destroy any in-progress build.

Note that you must not move from your current cell while in the process of building anything other than a capsule. If you do, you will lose any in-progress work on a wall or fort, and a robot will be automatically finalized with however many skill points you've invested up to that point.

Parameters

status	what we're going to start building (or, in the case of an energy capsule, resume building)
location	where to direct our building efforts. Must be an adjacent, empty location, or null if status=capsule.

Implements WorldAPI.

Definition at line 833 of file RoboSim.java.

Referenced by RoboSim.RoboAPIImplementor.processAttack().

               {
                    setBuildTarget(status,location,null);
               }

Here is the caller graph for this function:

void RoboSim.RoboAPIImplementor.setBuildTarget	(	Robot.BuildStatus	status,
		Robot.GridCell	location,
		byte[]	creation_message
	)		throws RoboSimExecutionException

Tells the simulator the robot is beginning to build something in an adjacent cell (or, for capsules, inside itself).
In order to mark a capsule or robot as "done", call this method with both parameters null. This will destroy any in-progress build.

Note that you must not move from your current cell while in the process of building anything other than a capsule. If you do, you will lose any in-progress work on a wall or fort, and a robot will be automatically finalized with however many skill points you've invested up to that point.

Parameters

status	what we're going to start building (or, in the case of an energy capsule, resume building)
location	where to direct our building efforts. Must be an adjacent, empty location, or null if status=capsule.
creation_message	message to send to newly created robot (if we're finalizing one)

Implements WorldAPI.

Definition at line 838 of file RoboSim.java.

References RoboSim.RoboAPIImplementor.actingRobot, RoboSim.RobotData.assoc_cell, Robot.GridCell.contents, RoboSim.RoboAPIImplementor.finalizeBuilding(), RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.RobotData.player, RoboSim.RobotData.whatBuilding, RoboSim.worldGrid, Robot.GridCell.x_coord, and Robot.GridCell.y_coord.

               {
                    //If we're in the middle of building something, finalize it.
                    if(actingRobot.whatBuilding!=null)
                         finalizeBuilding(message);

                    //Error checking, *sigh*...

                    //Does cell exist in grid?
                    if(location!=null && (location.x_coord > worldGrid.length || location.y_coord > worldGrid[0].length || location.x_coord < 0 || location.y_coord < 0))
                         throw new RoboSimExecutionException("passed invalid cell coordinates to setBuildTarget()",actingRobot.player,actingRobot.assoc_cell,location);

                    //Cell in question
                    SimGridCell gridCell = (location!=null ? worldGrid[location.x_coord][location.y_coord] : null);

                    //Update status
                    actingRobot.whatBuilding = status;
                    actingRobot.investedPower = 0;                    
                    actingRobot.invested_assoc_cell = gridCell;

                    //CAN pass us null, so special-case it
                    if(location==null)
                    {
                         //We must be building capsule, then.
                         if(actingRobot.whatBuilding!=null && actingRobot.whatBuilding!=Robot.BuildStatus.CAPSULE)
                              throw new RoboSimExecutionException("passed null to setBuildTarget() location with non-null and non-capsule build target",actingRobot.player,actingRobot.assoc_cell);
                         return;
                    }

                    //If location NOT null, must not be building capsule
                    if(status == null || status == Robot.BuildStatus.CAPSULE)
                         throw new RoboSimExecutionException("attempted to target capsule or null building on non-null adjacent cell",actingRobot.player,actingRobot.assoc_cell,location);

                    //Cell must be adjacent
                    if(!isAdjacent(location))
                         throw new RoboSimExecutionException("attempted to set build target to nonadjacent cell",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Is the cell empty?
                    if(gridCell.contents!=Robot.GridObject.EMPTY)
                         throw new RoboSimExecutionException("attempted to set build target to nonempty cell",actingRobot.player,actingRobot.assoc_cell,gridCell);

                    //Okay, block off cell since we're building there now.
                    gridCell.contents = Robot.GridObject.BLOCKED;
               }

Here is the call graph for this function:

Member Data Documentation

RobotData RoboSim.RoboAPIImplementor.actingRobot

private

Definition at line 284 of file RoboSim.java.

Referenced by RoboSim.RoboAPIImplementor.build(), RoboSim.RoboAPIImplementor.capsuleAttack(), RoboSim.RoboAPIImplementor.charge(), RoboSim.RoboAPIImplementor.defend(), RoboSim.RoboAPIImplementor.drop_capsule(), RoboSim.RoboAPIImplementor.finalizeBuilding(), RoboSim.RoboAPIImplementor.getVisibleNeighborhood(), RoboSim.RoboAPIImplementor.getWorld(), RoboSim.RoboAPIImplementor.isAdjacent(), RoboSim.RoboAPIImplementor.meleeAttack(), RoboSim.RoboAPIImplementor.move(), RoboSim.RoboAPIImplementor.pick_up_capsule(), RoboSim.RoboAPIImplementor.rangedAttack(), RoboSim.RoboAPIImplementor.repair(), RoboSim.RoboAPIImplementor.RoboAPIImplementor(), RoboSim.RoboAPIImplementor.scanEnemy(), RoboSim.RoboAPIImplementor.sendMessage(), and RoboSim.RoboAPIImplementor.setBuildTarget().

---

The documentation for this class was generated from the following file:

• RoboSim.java