DemoBot Class Reference

Inheritance diagram for DemoBot:

Collaboration diagram for DemoBot:

Public Member Functions
Robot_Specs	createRobot (WorldAPI api, int skill_points, byte[] message)
void	act (WorldAPI api, Robot_Status status, byte[][] received_radio)

Static Private Member Functions
static boolean	isAdjacent (GridCell c1, GridCell c2)
static int	searchAndDestroy (GridCell self, GridCell[][] neighbors, WorldAPI api, int remaining_power) throws RoboSim.RoboSimExecutionException

Private Attributes
Robot_Specs	my_specs

Detailed Description

DemoBot: Demo Robot implementation for OffenseBot

Definition at line 5 of file DemoBot.java.

Member Function Documentation

void DemoBot.act	(	WorldAPI	api,
		Robot_Status	status,
		byte	received_radio[][]
	)

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 reference to 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.

Implements Robot.

Definition at line 82 of file DemoBot.java.

References searchAndDestroy(), and Robot.GridObject.SELF.

          {
               int remaining_power = status.power;
               int remaining_charge = status.charge;

               try
               {
                    GridCell[][] neighbors = api.getVisibleNeighborhood();

                    //What's our position?
                    GridCell self=null;
                    for(int i=0; i<neighbors.length; i++)
                         for(int j=0; j<neighbors[0].length; j++)
                              if(neighbors[i][j].contents==GridObject.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)
                    {
                         GridCell[][] world = api.getWorld(3);
                         remaining_power-=3;
                         searchAndDestroy(self,world,api,remaining_power);
                    }
               }
               catch(RoboSim.RoboSimExecutionException e)
               {
                    System.err.println(e.getMessage());
               }
          }

Here is the call graph for this function:

Robot_Specs DemoBot.createRobot	(	WorldAPI	api,
		int	skill_points,
		byte[]	message
	)

Entry point for your robot on its creation

Parameters

api	a reference to a WorldAPI object you can use to interact with the simulator (currently unused)
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.

Implements Robot.

Definition at line 9 of file DemoBot.java.

References my_specs.

          {
               Robot_Specs to_return = new Robot_Specs();
               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;
          }

static boolean DemoBot.isAdjacent ( GridCell  c1, GridCell  c2  )

staticprivate

Definition at line 40 of file DemoBot.java.

References Robot.GridCell.x_coord.

Referenced by searchAndDestroy().

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

Here is the caller graph for this function:

static int DemoBot.searchAndDestroy ( GridCell  self, GridCell  neighbors[][], WorldAPI  api, int  remaining_power  ) throws RoboSim.RoboSimExecutionException

staticprivate

Definition at line 48 of file DemoBot.java.

References Robot.Direction.DOWN, Robot.GridObject.ENEMY, isAdjacent(), Robot.Direction.LEFT, Robot.Direction.RIGHT, and Robot.Direction.UP.

Referenced by act().

          {
               for(int i=0; i<neighbors.length; i++)
                    for(int j=0; j<neighbors[0].length; j++)
                         if(neighbors[i][j].contents==GridObject.ENEMY)
                         {
                              GridCell[] path = RobotUtility.findShortestPath(self,neighbors[i][j],neighbors);
                              if(path!=null)
                                   for(int k=0; k<path.length-1 && remaining_power > 0; k++)
                                   {
                                        Direction way = null;
                                        if(path[k].x_coord < self.x_coord)
                                             way = Direction.LEFT;
                                        else if(path[k].x_coord > self.x_coord)
                                             way = Direction.RIGHT;
                                        else if(path[k].y_coord < self.y_coord)
                                             way = Direction.UP;
                                        else
                                             way = Direction.DOWN;
                                        api.move(1,way);
                                        remaining_power--;
                                        self = path[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:

Here is the caller graph for this function:

Member Data Documentation

Robot_Specs DemoBot.my_specs

private

Definition at line 7 of file DemoBot.java.

Referenced by createRobot().

---

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

• DemoBot.java