RoboSim::RoboAPIImplementor Class Reference

Inheritance diagram for RoboSim::RoboAPIImplementor:

Collaboration diagram for RoboSim::RoboAPIImplementor:

Public Member Functions
	RoboAPIImplementor (RoboSim &rsim_, RobotData &actingRobot_)
AttackResult	meleeAttack (int power, GridCell &adjacent_cell)
AttackResult	rangedAttack (int power, GridCell &nonadjacent_cell)
AttackResult	capsuleAttack (int power_of_capsule, GridCell &cell)
void	defend (int power)
void	move (int steps, Direction way)
void	pick_up_capsule (GridCell &adjacent_cell)
void	drop_capsule (GridCell &adjacent_cell, int power_of_capsule)
BuildStatus	getBuildStatus ()
GridCell *	getBuildTarget ()
int	getInvestedBuildPower ()
void	setBuildTarget (BuildStatus status, GridCell *location)
void	setBuildTarget (BuildStatus status, GridCell *location, vector< uint8_t > message)
void	build (int power)
void	repair (int power)
void	charge (int power, GridCell &ally)
void	sendMessage (vector< uint8_t > message, int power)
vector< vector< GridCell > >	getVisibleNeighborhood ()
vector< vector< GridCell > >	getWorld (int power)
void	scanEnemy (Robot_Specs &enemySpecs, Robot_Status &enemyStatus, GridCell toScan)

Private Member Functions
bool	isAdjacent (GridCell adjacent_cell)
bool	calculateHit (int attack, int defense)
AttackResult	processAttack (int attack, GridCell &cell_to_attack, int power)
void	finalizeBuilding (vector< uint8_t > creation_message)

Private Attributes
RoboSim &	rsim
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).

Definition at line 93 of file RoboSim.hpp.

Constructor & Destructor Documentation

RoboSim::RoboAPIImplementor::RoboAPIImplementor ( RoboSim &  rsim_, RobotData &  actingRobot_  )

inline

Constructor

Parameters

actingRobot_

data for robot attempting to act in the simulator

Definition at line 104 of file RoboSim.hpp.

Referenced by processAttack().

: rsim(rsim_), actingRobot(actingRobot_) { };

Here is the caller graph for this function:

Member Function Documentation

void RoboSim::RoboAPIImplementor::build ( int  power )

inlinevirtual

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 188 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Status::charge, robot_api::RobotData::investedPower, robot_api::RobotData::player, robot_api::Robot_Status::power, and robot_api::RobotData::status.

               {
                    if(power > actingRobot.status.power || power < 0)
                         throw 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;
               }

bool RoboSim::RoboAPIImplementor::calculateHit ( int  attack, int  defense  )

inlineprivate

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 126 of file RoboSim.hpp.

Referenced by processAttack().

               {
                    int luckOfAttacker = rand()%10;
                    return luckOfAttacker+attack-defense>=5;
               }

Here is the caller graph for this function:

AttackResult RoboSim::RoboAPIImplementor::capsuleAttack ( int  power_of_capsule, GridCell &  cell  )

virtual

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 306 of file RoboSim.cpp.

References robot_api::ALLY, robot_api::BLOCKED, robot_api::CAPSULE, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::RobotUtility::findShortestPath(), robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::SELF, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

{
     //Error checking, *sigh*...

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

     //Cell to attack
     GridCell& cell_to_attack = rsim.worldGrid[cell.x_coord][cell.y_coord];

     //Do we have a capsule of this power rating?
     auto capsule_it = find(actingRobot.status.capsules.begin(),actingRobot.status.capsules.end(),power_of_capsule);

     if(capsule_it==actingRobot.status.capsules.end())
          throw RoboSimExecutionException(string("passed invalid power to capsuleAttack(): doesn't have capsule of power ")+to_string(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 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.
     list<GridCell*> shortest_path = robot_api::RobotUtility::findShortestPath(*actingRobot.assoc_cell,cell_to_attack,rsim.worldGrid);

     if(!shortest_path.size())
          throw RoboSimExecutionException("no clear shot to target",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);

     if(shortest_path.size() > power_of_capsule + actingRobot.specs.defense)
          throw 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 RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case BLOCKED:
          throw RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case SELF:
          if(cell_to_attack.occupant_data->player==actingRobot.player)
               throw RoboSimExecutionException("attempted to attack ally",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
          break;
     case CAPSULE:
          throw RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case ALLY:
          throw RoboSimExecutionException("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.erase(capsule_it);

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

Here is the call graph for this function:

void RoboSim::RoboAPIImplementor::charge ( int  power, GridCell &  ally  )

inlinevirtual

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 210 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Status::charge, robot_api::GridCell::contents, robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::Robot_Status::power, robot_api::SELF, robot_api::RobotData::status, RoboSim::worldGrid, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

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

                    //Are cells adjacent?
                    if(!isAdjacent(ally))
                         throw 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 > rsim.worldGrid.size() || ally.y_coord > rsim.worldGrid[0].size() || ally.x_coord < 0 || ally.y_coord < 0)
                         throw RoboSimExecutionException("passed invalid cell coordinates to charge()",actingRobot.player,*actingRobot.assoc_cell,ally);

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

                    //Is there an ally in that cell?
                    if(allied_cell.contents!=SELF || allied_cell.occupant_data->player!=actingRobot.player)
                         throw 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;
               }

void RoboSim::RoboAPIImplementor::defend ( int  power )

inlinevirtual

Defend: increase defense

Parameters

power

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

Implements WorldAPI.

Definition at line 145 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Status::charge, robot_api::Robot_Specs::defense, robot_api::Robot_Status::defense_boost, robot_api::RobotData::player, robot_api::Robot_Specs::power, robot_api::RobotData::specs, and robot_api::RobotData::status.

               {
                    //Error checking
                    if(power < 0 || power > actingRobot.specs.defense || power > actingRobot.specs.power || power > actingRobot.status.charge)
                         throw RoboSimExecutionException("attempted 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 ( GridCell &  adjacent_cell, int  power_of_capsule  )

virtual

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 469 of file RoboSim.cpp.

References robot_api::CAPSULE, robot_api::GridCell::capsule_power, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

{
     //Error checking, *sigh*...
     //Does cell exist in grid?
     if(adjacent_cell.x_coord > rsim.worldGrid.size() || adjacent_cell.y_coord > rsim.worldGrid[0].size() || adjacent_cell.x_coord < 0 || adjacent_cell.y_coord < 0)
          throw RoboSimExecutionException("passed invalid cell coordinates to pick_up_capsule()",actingRobot.player,*actingRobot.assoc_cell,adjacent_cell);

     //Cell in question
     GridCell& gridCell = rsim.worldGrid[adjacent_cell.x_coord][adjacent_cell.y_coord];

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

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

     //Do we have such a capsule?
     auto it = find(actingRobot.status.capsules.begin(),actingRobot.status.capsules.end(),power_of_capsule);
     if(it==actingRobot.status.capsules.end())
          throw RoboSimExecutionException(string("attempted to drop capsule with power ")+to_string(power_of_capsule)+", having no such capsule",actingRobot.player,*actingRobot.assoc_cell,gridCell);

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

     //Delete it from our inventory
     actingRobot.status.capsules.erase(it);
}

void RoboSim::RoboAPIImplementor::finalizeBuilding ( vector< uint8_t >  creation_message )

private

Definition at line 500 of file RoboSim.cpp.

References robot_api::RobotData::assoc_cell, robot_api::CAPSULE, robot_api::Robot_Status::charge, RoboSim::checkSpecsValid(), Robot::createRobot(), robot_api::EMPTY, robot_api::FORT, robot_api::Robot_Status::health, robot_api::NOTHING, robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::Robot_Specs::power, RBP_CALL_CONSTRUCTOR, robot_api::ROBOT, robot_api::RobotData::robot, robot_api::SELF, robot_api::RobotData::specs, robot_api::RobotData::status, robot_api::WALL, and RoboSim::WALL_HEALTH.

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

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

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

     case CAPSULE:
          if(capsule_power!=0)
          {
               if(actingRobot.status.capsules.size()+1>actingRobot.specs.attack+actingRobot.specs.defense)
                    throw RoboSimExecutionException("attempted to finish building capsule when already at max capsule capacity",actingRobot.player,*actingRobot.assoc_cell);
               actingRobot.status.capsules.push_back(capsule_power);
          }
          break;

     case ROBOT:
          int skill_points = actingRobot.investedPower/20;
          if(skill_points!=0)
          {
               //Check creation message correct size
               if(creation_message.size()!=0 && creation_message.size()!=64)
                    throw 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.size())
               {
                    creation_message.resize(64);
                    creation_message[1] = rsim.turnOrder.size() % 256;
                    creation_message[0] = rsim.turnOrder.size() / 256;
               }

               //Create the robot
               actingRobot.invested_assoc_cell->contents = SELF;
               Robot* robot;
               try
               {
                    robot = RBP_CALL_CONSTRUCTOR(actingRobot.player);
               }
               catch(...)
               {
                    throw RoboSimExecutionException("something went wrong calling student's constructor", actingRobot.player,*actingRobot.assoc_cell, *actingRobot.invested_assoc_cell);
               }
               rsim.turnOrder.emplace_back();
               RobotData& data = *(rsim.turnOrder.rbegin());
               data.robot = robot;
               data.assoc_cell = actingRobot.invested_assoc_cell;
               actingRobot.invested_assoc_cell->occupant_data = &data;
               data.player = actingRobot.player;
               data.specs = checkSpecsValid(data.robot->createRobot(NULL, skill_points, creation_message), actingRobot.player, skill_points);
               data.status.charge = data.status.health = data.specs.power*10;
          }
          else
               actingRobot.invested_assoc_cell->contents = EMPTY;
          break;                              
     }
}

Here is the call graph for this function:

BuildStatus RoboSim::RoboAPIImplementor::getBuildStatus ( )

inlinevirtual

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 160 of file RoboSim.hpp.

References robot_api::RobotData::whatBuilding.

               {
                    return actingRobot.whatBuilding;
               }

GridCell* RoboSim::RoboAPIImplementor::getBuildTarget ( )

inlinevirtual

Returns

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

Implements WorldAPI.

Definition at line 165 of file RoboSim.hpp.

References robot_api::RobotData::invested_assoc_cell.

               {
                    return actingRobot.invested_assoc_cell;
               }

int RoboSim::RoboAPIImplementor::getInvestedBuildPower ( )

inlinevirtual

Returns

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

Implements WorldAPI.

Definition at line 170 of file RoboSim.hpp.

References robot_api::RobotData::investedPower.

               {
                    return actingRobot.investedPower;
               }

vector<vector<GridCell> > RoboSim::RoboAPIImplementor::getVisibleNeighborhood ( )

inlinevirtual

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 266 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Specs::defense, RoboSim::getSanitizedSubGrid(), robot_api::RobotData::player, robot_api::SELF, robot_api::RobotData::specs, RoboSim::worldGrid, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

               {
                    //YAY!  No parameters means NO ERROR CHECKING!  YAY!
                    const int range = actingRobot.specs.defense;
                    const int xloc = actingRobot.assoc_cell->x_coord;
                    const int yloc = actingRobot.assoc_cell->y_coord;
                    const int x_left = (xloc - range < 0) ? 0 : (xloc - range);
                    const int x_right = (xloc + range > rsim.worldGrid.size()-1) ? (rsim.worldGrid.size()-1) : (xloc + range);
                    const int y_up = (yloc - range < 0) ? 0 : (yloc - range);
                    const int y_down = (yloc + range > rsim.worldGrid[0].size() - 1) ? (rsim.worldGrid[0].size()-1) : (yloc + range);
                    vector<vector<GridCell> > to_return = rsim.getSanitizedSubGrid(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=SELF;
                    return to_return;
               }

Here is the call graph for this function:

vector<vector<GridCell> > RoboSim::RoboAPIImplementor::getWorld ( int  power )

inlinevirtual

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 283 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, RoboSim::getSanitizedSubGrid(), robot_api::RobotData::player, robot_api::SELF, RoboSim::worldGrid, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

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

                    vector<vector<GridCell> > to_return = rsim.getSanitizedSubGrid(0,0,rsim.worldGrid.size()-1,rsim.worldGrid[0].size()-1,actingRobot.player);

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

Here is the call graph for this function:

bool RoboSim::RoboAPIImplementor::isAdjacent ( GridCell  adjacent_cell )

inlineprivate

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 112 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

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

AttackResult RoboSim::RoboAPIImplementor::meleeAttack ( int  power, GridCell &  adjacent_cell  )

virtual

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 189 of file RoboSim.cpp.

References robot_api::ALLY, robot_api::BLOCKED, robot_api::CAPSULE, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::SELF, robot_api::GridCell::wallforthealth, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

{
     //Lots of error checking here (as everywhere...)

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

     //Are cells adjacent?
     if(!isAdjacent(adjacent_cell))
          throw 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 > rsim.worldGrid.size() || adjacent_cell.y_coord > rsim.worldGrid[0].size() ||
        adjacent_cell.x_coord < 0 || adjacent_cell.y_coord < 0)
          throw 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
     GridCell& cell_to_attack = rsim.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 RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case BLOCKED:
          throw RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case SELF:
          if(cell_to_attack.occupant_data->player==actingRobot.player)
               throw RoboSimExecutionException("attempted to attack ally",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
          break;
     case CAPSULE:
          throw RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case ALLY:
          throw RoboSimExecutionException("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);
}

void RoboSim::RoboAPIImplementor::move ( int  steps, Direction  way  )

virtual

move: move robot

Parameters

steps	how far to move
way	which way to move

Implements WorldAPI.

Definition at line 362 of file RoboSim.cpp.

References robot_api::DOWN, robot_api::EMPTY, robot_api::FORT, robot_api::LEFT, robot_api::RIGHT, robot_api::SELF, and robot_api::UP.

{
     if(steps<1)
          return;

     int x_coord = actingRobot.assoc_cell->x_coord;
     const int actor_x = x_coord;
     int y_coord = actingRobot.assoc_cell->y_coord;
     const 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 > rsim.worldGrid.size() || y_coord < 0 || y_coord > rsim.worldGrid[0].size())
          throw RoboSimExecutionException("attempted to move out of bounds",actingRobot.player,*actingRobot.assoc_cell);

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

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

     //Okay, now we have to make sure each step is empty
     const bool x_left = x_coord<actor_x;
     const bool 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(rsim.worldGrid[i][y_coord].contents!=EMPTY)
                    throw RoboSimExecutionException("attempted to cross illegal cell",actingRobot.player,*actingRobot.assoc_cell,rsim.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(rsim.worldGrid[x_coord][i].contents!=EMPTY)
                    throw RoboSimExecutionException("attempted to cross illegal cell",actingRobot.player,*actingRobot.assoc_cell,rsim.worldGrid[x_coord][i]);
     }

     //Okay, now: do we have enough power/charge?
     if(steps > actingRobot.status.power)
          throw RoboSimExecutionException("attempted to move too far (not enough power)",actingRobot.player,*actingRobot.assoc_cell,rsim.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 = EMPTY;
     actingRobot.assoc_cell->occupant_data = NULL;
     actingRobot.assoc_cell = &rsim.worldGrid[x_coord][y_coord];
     actingRobot.assoc_cell->contents = SELF;
     actingRobot.assoc_cell->occupant_data = &actingRobot;
}

void RoboSim::RoboAPIImplementor::pick_up_capsule ( GridCell &  adjacent_cell )

virtual

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 431 of file RoboSim.cpp.

References robot_api::CAPSULE, robot_api::GridCell::capsule_power, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

{
     //Error checking, *sigh*...

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

     //Cell in question
     GridCell& gridCell = rsim.worldGrid[adjacent_cell.x_coord][adjacent_cell.y_coord];

     //Cell must be adjacent
     if(!isAdjacent(adjacent_cell))
          throw 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 RoboSimExecutionException("attempted to pick up capsule with no power",actingRobot.player,*actingRobot.assoc_cell,gridCell);

     //Is there actually a capsule there?
     if(gridCell.contents!=CAPSULE)
          throw 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.size()+1>actingRobot.specs.attack+actingRobot.specs.defense)
          throw 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.push_back(gridCell.capsule_power);
     gridCell.contents = EMPTY;
     gridCell.capsule_power = 0;
}

AttackResult RoboSim::RoboAPIImplementor::processAttack ( int  attack, GridCell &  cell_to_attack, int  power  )

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 123 of file RoboSim.cpp.

References calculateHit(), robot_api::GridCell::contents, robot_api::Robot_Specs::defense, robot_api::Robot_Status::defense_boost, robot_api::DESTROYED_TARGET, robot_api::EMPTY, robot_api::FORT, robot_api::Robot_Status::health, robot_api::HIT, robot_api::RobotData::invested_assoc_cell, robot_api::MISSED, robot_api::NOTHING, robot_api::GridCell::occupant_data, RoboAPIImplementor(), rsim, robot_api::SELF, robot_api::RobotData::specs, robot_api::RobotData::status, RoboSim::turnOrder, RoboSim::turnOrder_pos, robot_api::WALL, and robot_api::GridCell::wallforthealth.

{
     //Holds result of attack
     AttackResult to_return = 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 = HIT;

          if(cell_to_attack.occupant_data!=NULL)
          {
               //we're a robot
               for(int i=0; true; i++)
                    if(&rsim.turnOrder[i]==cell_to_attack.occupant_data)
                    {
                         if((cell_to_attack.occupant_data->status.health-=power)<=0)
                         {
                              //We destroyed the opponent!
                              to_return = DESTROYED_TARGET;

                              //Handle in-progress build, reusing setBuildTarget() to handle interruption of build due to death
                              RoboAPIImplementor(rsim,*(cell_to_attack.occupant_data)).setBuildTarget(NOTHING,cell_to_attack.occupant_data->invested_assoc_cell);

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

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

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

     return to_return;
}

Here is the call graph for this function:

AttackResult RoboSim::RoboAPIImplementor::rangedAttack ( int  power, GridCell &  nonadjacent_cell  )

virtual

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 246 of file RoboSim.cpp.

References robot_api::ALLY, robot_api::BLOCKED, robot_api::CAPSULE, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::RobotUtility::findShortestPath(), robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::SELF, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

{
     //Lots of error checking here (as everywhere...)

     //Check that we're using a valid amount of power
     if(power > actingRobot.status.power || power > actingRobot.specs.attack || power < 1)
          throw 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 > rsim.worldGrid.size() || nonadjacent_cell.y_coord > rsim.worldGrid[0].size() ||
        nonadjacent_cell.x_coord < 0 || nonadjacent_cell.y_coord < 0)
          throw RoboSimExecutionException("passed invalid cell coordinates to rangedAttack()",actingRobot.player,*actingRobot.assoc_cell,nonadjacent_cell);

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

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

     //Do we have a "clear shot"?
     list<GridCell*> shortest_path = robot_api::RobotUtility::findShortestPath(*actingRobot.assoc_cell,cell_to_attack,rsim.worldGrid);
     if(!shortest_path.size()) //we don't have a clear shot
          throw RoboSimExecutionException("attempted to range attack cell with no clear path",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     else if(shortest_path.size()>actingRobot.specs.defense) //out of range
          throw 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 RoboSimExecutionException("attempted to attack empty cell",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case BLOCKED:
          throw RoboSimExecutionException("attempted to attack blocked tile",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case SELF:
          if(cell_to_attack.occupant_data->player==actingRobot.player)
               throw RoboSimExecutionException("attempted to attack ally",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
          break;
     case CAPSULE:
          throw RoboSimExecutionException("attempted to attack energy capsule",actingRobot.player,*actingRobot.assoc_cell,cell_to_attack);
     case ALLY:
          throw RoboSimExecutionException("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 )

inlinevirtual

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 197 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Specs::charge, robot_api::Robot_Status::charge, robot_api::Robot_Status::health, robot_api::RobotData::player, robot_api::Robot_Status::power, robot_api::RobotData::specs, and robot_api::RobotData::status.

               {
                    if(power > actingRobot.status.power || power < 0)
                         throw 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_Specs &  enemySpecs, Robot_Status &  enemyStatus, GridCell  toScan  )

inlinevirtual

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 295 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Specs::attack, robot_api::Robot_Status::capsules, robot_api::Robot_Specs::charge, robot_api::Robot_Status::charge, robot_api::GridCell::contents, robot_api::Robot_Specs::defense, robot_api::Robot_Status::defense_boost, robot_api::Robot_Status::health, robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::Robot_Specs::power, robot_api::Robot_Status::power, robot_api::SELF, robot_api::RobotData::specs, robot_api::RobotData::status, RoboSim::worldGrid, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

               {
                    if(toScan.x_coord < 0 || toScan.x_coord >= rsim.worldGrid.size() || toScan.y_coord < 0 || toScan.y_coord >= rsim.worldGrid[0].size() || actingRobot.status.power==0)
                         throw RoboSimExecutionException("Invalid parameters passed to scanEnemy()",actingRobot.player,*actingRobot.assoc_cell);

                    GridCell& cell = rsim.worldGrid[toScan.x_coord][toScan.y_coord];

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

                    //Is there a robot in this cell?
                    if(cell.contents != SELF)
                         throw 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;
               }

void RoboSim::RoboAPIImplementor::sendMessage ( vector< uint8_t >  message, int  power  )

inlinevirtual

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 238 of file RoboSim.hpp.

References robot_api::RobotData::assoc_cell, robot_api::RobotData::buffered_radio, robot_api::RobotUtility::findNearestAlly(), robot_api::GridCell::occupant_data, robot_api::RobotData::player, RoboSim::turnOrder, RoboSim::worldGrid, and a::x.

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

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

                    GridCell* target = NULL;
                    if(power==1)
                    {
                         target = RobotUtility::findNearestAlly(*actingRobot.assoc_cell,rsim.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.*/
                              target->occupant_data->buffered_radio.push_back(message);
                         }
                         return;
                    }
                    else //power==2
                         for(RobotData& x : rsim.turnOrder)
                              if(&x!=&actingRobot && x.player==actingRobot.player)
                                   x.buffered_radio.push_back(message);
               }

Here is the call graph for this function:

void RoboSim::RoboAPIImplementor::setBuildTarget ( BuildStatus  status, GridCell *  location  )

inlinevirtual

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 181 of file RoboSim.hpp.

               {
                    setBuildTarget(status,location,vector<uint8_t>());
               }

void RoboSim::RoboAPIImplementor::setBuildTarget ( BuildStatus  status, GridCell *  location, vector< uint8_t >  message  )

virtual

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 581 of file RoboSim.cpp.

References robot_api::BLOCKED, robot_api::CAPSULE, robot_api::GridCell::contents, robot_api::EMPTY, robot_api::NOTHING, robot_api::GridCell::x_coord, and robot_api::GridCell::y_coord.

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

     //Error checking, *sigh*...

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

     //Cell in question
     GridCell* gridCell = (location!=NULL ? &rsim.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!=NOTHING && actingRobot.whatBuilding!=CAPSULE)
               throw 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 == NOTHING || status == CAPSULE)
          throw 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 RoboSimExecutionException("attempted to set build target to nonadjacent cell",actingRobot.player,*actingRobot.assoc_cell,*gridCell);

     //Is the cell empty?
     if(gridCell->contents!=EMPTY)
          throw 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 = BLOCKED;
}

Member Data Documentation

RobotData& RoboSim::RoboAPIImplementor::actingRobot

private

Definition at line 97 of file RoboSim.hpp.

RoboSim& RoboSim::RoboAPIImplementor::rsim

private

Definition at line 96 of file RoboSim.hpp.

Referenced by processAttack().

---

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

• RoboSim.hpp
• RoboSim.cpp