#include <DemoBot.hpp>

Inheritance diagram for DemoBot:

Collaboration diagram for DemoBot:

Public Member Functions
Robot_Specs	createRobot (WorldAPI *api, int skill_points, vector< uint8_t > message)

virtual Robot_Specs	createRobot (WorldAPI *api, int skill_points, std::vector< std::uint8_t > message)=0

virtual void	act (WorldAPI &api, Robot_Status status, std::vector< std::vector< std::uint8_t > > received_radio)=0

Private Member Functions
void	act (WorldAPI &api, Robot_Status status, vector< vector< uint8_t >> received_radio)

Static Private Member Functions
static bool	isAdjacent (const GridCell &c1, const GridCell &c2)

static int	searchAndDestroy (GridCell &self, vector< vector< GridCell >> neighbors, WorldAPI &api, int remaining_power)

Private Attributes
Robot_Specs	my_specs

Detailed Description

DemoBot: Demo Robot implementation for OffenseBot

Definition at line 12 of file DemoBot.hpp.

Member Function Documentation

virtual void Robot::act	(	WorldAPI &	api,
		Robot_Status	status,
		std::vector< std::vector< std::uint8_t > >	received_radio
	)

pure virtualinherited

Each turn, this method is called to allow your robot to act.

Parameters

api	a reference to a WorldAPI object you can use to interact with the simulator.
status	a Robot_Status object containing information about your current health and energy level
received_radio	the radio signals you have received this round. Each message is exactly 64 bytes long. You may be able to receive additional radio signals by calling getMessages() with a nonzero power if you are being jammed.

Referenced by RoboSim::executeSingleTimeStep().

Here is the caller graph for this function:

void DemoBot::act	(	WorldAPI &	api,
		Robot_Status	status,
		vector< vector< uint8_t >>	received_radio
	)

inlineprivate

Definition at line 97 of file DemoBot.hpp.

References robot_api::Robot_Status::charge, WorldAPI::getVisibleNeighborhood(), WorldAPI::getWorld(), robot_api::RoboSimExecutionException::msg, robot_api::Robot_Status::power, and robot_api::SELF.

           {
                int remaining_power = status.power;
                int remaining_charge = status.charge;
 
                try
                {
                     auto neighbors = api.getVisibleNeighborhood();
 
                     //What's our position?
                     GridCell self;
                     for(int i=0; i<neighbors.size(); i++)
                          for(int j=0; j<neighbors[0].size(); j++)
                               if(neighbors[i][j].contents==SELF)
                               {
                                    self=neighbors[i][j];
                                    break;
                               }
 
                     //Visible and reachable enemy?  Attack!
                     remaining_power = searchAndDestroy(self,neighbors,api,remaining_power);
                     
                     //Do we still have power?  Then we haven't attacked anything.
                     //Perhaps we couldn't find an enemy...
                     if(remaining_power > 3)
                     {
                          auto world = api.getWorld(3);
                          remaining_power-=3;
                          searchAndDestroy(self,world,api,remaining_power);
                     }
                }
                catch(RoboSimExecutionException e)
                {
                     cerr << e.msg << endl;
                }
           }

Here is the call graph for this function:

Robot_Specs DemoBot::createRobot	(	WorldAPI *	api,
		int	skill_points,
		vector< uint8_t >	message
	)

inline

Definition at line 18 of file DemoBot.hpp.

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

           {
                Robot_Specs to_return;
                to_return.attack = to_return.defense = to_return.power = to_return.charge = skill_points/4;
                //This handles the pathological case where skill_points<4
                if(skill_points<4)
                {
                     to_return.charge = 1;
                     skill_points--;
                     if(skill_points > 0)
                     {
                          to_return.power = 1;
                          skill_points--;
                     }
                     if(skill_points > 0)
                     {
                          to_return.defense = 1;
                          skill_points--;
                     }
                }
                else
                {
                     skill_points-=(skill_points/4)*4;
                     to_return.attack += skill_points;
                }
 
                //Keep track of our specs; simulator won't do it for us!
                my_specs = to_return;
                return to_return;
           }

virtual Robot_Specs Robot::createRobot	(	WorldAPI *	api,
		int	skill_points,
		std::vector< std::uint8_t >	message
	)

pure virtualinherited

Entry point for your robot on its creation

Parameters

api	a pointer to a WorldAPI object you can use to interact with the simulator, if it's not NULL (currently unused and always NULL)
skill_points	the number of skill points your robot is allowed to have.
message	a 64-byte message from the robot who created you. If you were created by the simulator, the first two bytes of the message will contain your ID, which is unique among the IDs of all your team's robots created by the world. Otherwise, the format of the message is unspecified: it's up to you to define it.

Returns: You are to return a Robot_Specs object containing the allocation of skill points you have chosen for yourself.

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

Here is the caller graph for this function:

static bool DemoBot::isAdjacent	(	const GridCell &	c1,
		const GridCell &	c2
	)

inlinestaticprivate

Definition at line 50 of file DemoBot.hpp.

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

           {
                return (abs(c1.x_coord-c2.x_coord)==1 &&
                        c1.y_coord == c2.y_coord ||
                        abs(c1.y_coord-c2.y_coord)==1 &&
                        c1.x_coord == c2.x_coord);
           }

static int DemoBot::searchAndDestroy	(	GridCell &	self,
		vector< vector< GridCell >>	neighbors,
		WorldAPI &	api,
		int	remaining_power
	)

inlinestaticprivate

Definition at line 58 of file DemoBot.hpp.

References robot_api::DOWN, robot_api::ENEMY, robot_api::RobotUtility::findShortestPath(), robot_api::LEFT, WorldAPI::meleeAttack(), WorldAPI::move(), robot_api::RIGHT, and robot_api::UP.

           {
                //cout << "Self: (" << self.x_coord << "," << self.y_coord << ")" << endl;
                for(int i=0; i<neighbors.size(); i++)
                     for(int j=0; j<neighbors[0].size(); j++)
                          if(neighbors[i][j].contents==ENEMY)
                          {
                               auto path = RobotUtility::findShortestPath(self,neighbors[i][j],neighbors);
                               if(path.size())
                               {
                                    auto end_pos = path.end();
                                    end_pos--;
                                    for(auto k=path.begin(); k!=end_pos && remaining_power > 0; k++)
                                    {
                                         //cout << "Move: (" << (*k)->x_coord << "," << (*k)->y_coord << ")";
                                         Direction way;
                                         if((*k)->x_coord < self.x_coord)
                                              way = LEFT;
                                         else if((*k)->x_coord > self.x_coord)
                                              way = RIGHT;
                                         else if((*k)->y_coord < self.y_coord)
                                              way = UP;
                                         else
                                              way = DOWN;
                                         api.move(1,way);
                                         remaining_power--;
                                         self = **k;
                                    }
                               }
                               if(remaining_power > 0 && isAdjacent(self,neighbors[i][j]))
                               {
                                    api.meleeAttack(remaining_power,neighbors[i][j]);
                                    remaining_power = 0;
                               }
                          }
 
                return remaining_power;
           }

Here is the call graph for this function:

Member Data Documentation

Robot_Specs DemoBot::my_specs

private

Definition at line 15 of file DemoBot.hpp.

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

DemoBot.hpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

Member Data Documentation