#include <RoboSim.hpp>

Collaboration diagram for RoboSim:

Classes
class	RoboAPIImplementor

class	SimGridAllyDeterminant

Public Member Functions
vector< vector< GridCell > > &	getWorldGrid ()

int	getOccupantPlayer (const GridCell &cell) const

	RoboSim (int initial_robots_per_combatant, int skill_points, int length, int width, int obstacles)

int	executeSingleTimeStep ()

Private Member Functions
vector< vector< GridCell > >	getSanitizedSubGrid (int x_left, int y_up, int x_right, int y_down, int player) const

Static Private Member Functions
static Robot_Specs	checkSpecsValid (Robot_Specs proposed, int player, int skill_points)

Private Attributes
vector< vector< GridCell > >	worldGrid

vector< RobotData >	turnOrder

int	turnOrder_pos

Static Private Attributes
static const int	WALL_HEALTH = 10

static const int	WALL_DEFENSE = 10

Detailed Description

Definition at line 21 of file RoboSim.hpp.

Constructor & Destructor Documentation

RoboSim::RoboSim	(	int	initial_robots_per_combatant,
		int	skill_points,
		int	length,
		int	width,
		int	obstacles
	)

Constructor for RoboSim:

Parameters

initial_robots_per_combatant	how many robots each team starts out with
skill_points	skill points per combatant
length	length of arena
width	width of arena
obstacles	number of obstacles on battlefield

Definition at line 66 of file RoboSim.cpp.

References robot_api::RobotData::assoc_cell, robot_api::Robot_Specs::charge, robot_api::Robot_Status::charge, checkSpecsValid(), Robot::createRobot(), robot_api::Robot_Status::defense_boost, robot_api::EMPTY, robot_api::Robot_Status::health, robot_api::RobotData::invested_assoc_cell, robot_api::RobotData::investedPower, robot_api::NOTHING, robot_api::RobotData::player, RBP_CALL_CONSTRUCTOR, RBP_NUM_PLAYERS, robot_api::RobotData::robot, robot_api::SELF, robot_api::RobotData::specs, robot_api::RobotData::status, turnOrder, turnOrder_pos, robot_api::WALL, WALL_HEALTH, robot_api::RobotData::whatBuilding, and worldGrid.

                                                                                                          :
      worldGrid(length,vector<GridCell>(width)), turnOrder(RBP_NUM_PLAYERS*initial_robots_per_combatant),
      turnOrder_pos(0)
 {
      for(int i=0; i<length; i++)
           for(int j=0; j<width; j++)
           {
                worldGrid[i][j].x_coord = i;
                worldGrid[i][j].y_coord = j;
                worldGrid[i][j].contents = EMPTY;
           }
 
      //Add robots for each combatant
      for(int player=1; player<=RBP_NUM_PLAYERS; player++)
      {
           for(int i=0; i<initial_robots_per_combatant; i++)
           {
                int x_pos,y_pos;
                do
                {
                     x_pos = rand()%length;
                     y_pos = rand()%width;
                } while(worldGrid[x_pos][y_pos].contents!=EMPTY);
 
                worldGrid[x_pos][y_pos].contents = SELF;
                RobotData& data = turnOrder[(player-1)*initial_robots_per_combatant+i];
                worldGrid[x_pos][y_pos].occupant_data = &data;
                data.assoc_cell = &worldGrid[x_pos][y_pos];
                data.robot = RBP_CALL_CONSTRUCTOR(player);
                data.player = player;
                vector<uint8_t> creation_message(64);
                creation_message[1] = turnOrder_pos % 256;
                creation_message[0] = turnOrder_pos / 256;
                data.specs = checkSpecsValid(data.robot->createRobot(NULL, skill_points, creation_message), player, skill_points);
                data.status.charge = data.status.health = data.specs.charge*10;
 
                data.status.defense_boost = 0;
                data.whatBuilding = NOTHING;
                data.investedPower = 0;
                data.invested_assoc_cell = NULL;
           }
      }
 
      //Add obstacles to battlefield
      for(int i=0; i<obstacles; i++)
      {
           int x_pos, y_pos;
           do
           {
                x_pos = rand()%length;
                y_pos = rand()%width;
           } while(worldGrid[x_pos][y_pos].contents!=EMPTY);
           worldGrid[x_pos][y_pos].contents = WALL;
           worldGrid[x_pos][y_pos].wallforthealth = WALL_HEALTH;
      }
 }

Here is the call graph for this function:

Member Function Documentation

Robot_Specs RoboSim::checkSpecsValid	(	Robot_Specs	proposed,
		int	player,
		int	skill_points
	)

staticprivate

Definition at line 58 of file RoboSim.cpp.

References robot_api::Robot_Specs::attack, robot_api::Robot_Specs::charge, robot_api::Robot_Specs::defense, and robot_api::Robot_Specs::power.

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

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

Here is the caller graph for this function:

int RoboSim::executeSingleTimeStep ( )

inline

Executes one timestep of the simulation.

Returns: the winner, if any, or -1

Definition at line 332 of file RoboSim.hpp.

References Robot::act(), robot_api::RobotData::buffered_radio, robot_api::Robot_Specs::charge, robot_api::Robot_Status::charge, robot_api::Robot_Status::defense_boost, robot_api::Robot_Specs::power, robot_api::Robot_Status::power, robot_api::RobotData::robot, robot_api::RobotData::specs, and robot_api::RobotData::status.

           {
                for(turnOrder_pos=0; turnOrder_pos<turnOrder.size(); turnOrder_pos++)
                {
                     //References to robot's data
                     RobotData& data = turnOrder[turnOrder_pos];
                     RoboAPIImplementor student_api(*this,data);
 
                     //Charge robot an amount of charge equal to charge skill
                     data.status.charge = min(data.status.charge + data.specs.charge, data.specs.charge*10);
 
                     /*We can spend up to status.power power this turn, but
                      *no more than our current charge level*/
                     data.status.power = min(data.specs.power, data.status.charge);
 
                     //Defense boost reset to zero at beginning of turn
                     data.status.defense_boost = 0;
 
                     //Clone status for student
                     Robot_Status clonedStatus = data.status;
 
                     //Run student code
                     data.robot->act(student_api,clonedStatus,data.buffered_radio);
                     data.buffered_radio.clear();
                }
                
                int player = turnOrder[0].player;
                for(int i=1; i<turnOrder.size(); i++)
                     if(turnOrder[i].player!=player)
                          return -1;
                return player;
           }

Here is the call graph for this function:

int RoboSim::getOccupantPlayer ( const GridCell & cell ) const

inline

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

Definition at line 54 of file RoboSim.hpp.

References robot_api::GridCell::occupant_data, and robot_api::RobotData::player.

Referenced by SimulatorGUI::do_timestep().

           {
                return cell.occupant_data->player;
           }

Here is the caller graph for this function:

vector< vector< GridCell > > RoboSim::getSanitizedSubGrid	(	int	x_left,
		int	y_up,
		int	x_right,
		int	y_down,
		int	player
	)		const

private

Helper method to retrieve a sanitized subgrid of the world grid

Parameters

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

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

Definition at line 34 of file RoboSim.cpp.

References robot_api::ALLY, robot_api::GridCell::contents, robot_api::ENEMY, robot_api::GridCell::has_private_members, robot_api::GridCell::occupant_data, robot_api::RobotData::player, robot_api::SELF, and robot_api::GridCell::wallforthealth.

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

 {
      const int x_length = x_right - x_left + 1;
      const int y_height = y_down - y_up + 1;
      
      vector<vector<GridCell> > to_return(x_length,vector<GridCell>(y_height));
      for(int i=x_left; i<=x_right; i++)
           for(int j=y_up; j<=y_down; j++)
           {
                GridCell& sanitized = to_return[i-x_left][j-y_up];
                sanitized = worldGrid[i][j];
                if(sanitized.contents==SELF)
                     if(sanitized.occupant_data->player==player)
                          sanitized.contents = ALLY;
                     else
                          sanitized.contents = ENEMY;
                sanitized.has_private_members = false;
                sanitized.occupant_data = NULL;
                sanitized.wallforthealth = 0;
           }
      
      return to_return;
 }