Robot.java

Go to the documentation of this file.

import java.util.List;
import java.util.LinkedList;
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
public interface Robot
{
     public class Robot_Specs implements Cloneable
     {
          public int attack;

          public int defense;

          public int power;

          public int charge;

          public Object clone() throws CloneNotSupportedException
               { return super.clone(); }
     }

     public class Robot_Status implements Cloneable
     {
          public int power;

          public int charge;

          public int health;

          public int defense_boost;

          public int[] capsules;

          public Robot_Status() { capsules = new int[0]; }

          public Object clone() throws CloneNotSupportedException
               {
                    Robot_Status to_return = (Robot_Status)(super.clone());
                    to_return.capsules = capsules.clone();
                    return to_return;
               }
     };

     public enum GridObject { EMPTY, BLOCKED, SELF, ALLY, ENEMY, WALL, FORT, CAPSULE };

     public enum Direction { UP, DOWN, LEFT, RIGHT };

     public class GridCell implements Cloneable
     {
          public int x_coord;

          public int y_coord;

          public GridObject contents;

          public Direction fort_orientation;

          public int capsule_power;

          public Object clone() throws CloneNotSupportedException
               { return super.clone(); }
     }

     public enum AttackType { MELEE, RANGED, CAPSULE };

     public class AttackNotice
     {
          GridCell origin;

          AttackType form;
          
          int damage;
     }

     public enum AttackResult { MISSED, HIT, DESTROYED_TARGET };

     public class RobotUtility
     {
          public abstract static class FSPPredicate
          {
               public abstract boolean validCell(GridCell cell);
          }

          public static GridCell findNearestAlly(GridCell origin, GridCell[][] grid)
               {
                    GridCell[] path = findShortestPathInternal(origin, new RoboSim.SimGridAllyDeterminant(origin), new FSPPredicate() {
                              public boolean validCell(GridCell cell) { return true; }}, grid);

                    if(path==null)
                         return null;
                    else
                         return path[path.length-1];
               }

          public static GridCell[] findShortestPath(GridCell origin, final GridCell target, GridCell[][] grid)
               {
                    return findShortestPathInternal(origin,new FSPPredicate () {
                              public boolean validCell(GridCell maybeTarget)
                                   {
                                        return maybeTarget==target;
                                   }
                         },
                         new FSPPredicate() {
                              public boolean validCell(GridCell maybePassable)
                                   {
                                        return maybePassable.contents==GridObject.EMPTY;
                                   }
                         },
                         grid);
               }

          private static GridCell[] findShortestPathInternal(GridCell origin, FSPPredicate isTarget, FSPPredicate isPassable, GridCell[][] grid)
               {
                    //Offsets to handle incomplete world map
                    int x_offset = grid[0][0].x_coord;
                    int y_offset = grid[0][0].y_coord;
                    
                    //Structures to efficiently handle accounting
                    TreeMap<Integer,LinkedList<GridCell>> unvisited_nodes = new TreeMap<Integer,LinkedList<GridCell>>(); //this is really a multimap
                    Map<GridCell,LinkedList<GridCell>> current_costs = new HashMap<GridCell,LinkedList<GridCell>>();

                    //Origin's shortest path is simply itself
                    LinkedList<GridCell> origin_path = new LinkedList<GridCell>();
                    origin_path.add(origin);

                    //Initialize graph search with origin
                    current_costs.put(origin,origin_path);
                    unvisited_nodes.put(0,origin_path);

                    while(unvisited_nodes.size()!=0)
                    {
                         Map.Entry<Integer,LinkedList<GridCell>> current_entry = unvisited_nodes.firstEntry();
                         int our_cost = current_entry.getKey();
                         GridCell our_cell = current_entry.getValue().pop();
                         LinkedList<GridCell> current_path = current_costs.get(our_cell);

                         //If we are a destination, algorithm has finished: return our current path
                         if(isTarget.validCell(our_cell))
                              return current_path.toArray(new GridCell[0]);

                         //Erase our cost mapping from unvisited_nodes if necessary
                         if(current_entry.getValue().size()==0)
                              unvisited_nodes.remove(our_cost);

                         /*We are adjacent to up to 4 nodes, with
                           coordinates relative to ours as follows:
                           (-1,0),(1,0),(0,-1),(0,1)*/
                         LinkedList<GridCell> adjacent_nodes = new LinkedList<GridCell>();
                         int gridX_value = our_cell.x_coord - x_offset;
                         int gridY_value = our_cell.y_coord - y_offset;
                         if(gridX_value!=0)
                              adjacent_nodes.add(grid[gridX_value-1][gridY_value]);
                         if(gridX_value!=grid.length-1)
                              adjacent_nodes.add(grid[gridX_value+1][gridY_value]);
                         if(gridY_value!=0)
                              adjacent_nodes.add(grid[gridX_value][gridY_value-1]);
                         if(gridY_value!=grid[0].length-1)
                              adjacent_nodes.add(grid[gridX_value][gridY_value+1]);

                         /*Iterate over adjacent nodes, add to or update
                           entry in unvisited_nodes and current_costs if
                           necessary*/
                         for(GridCell x : adjacent_nodes)
                         {
                              //If we're not passable, we can't be used as an adjacent cell, unless we're a target
                              if(!isPassable.validCell(x) && !isTarget.validCell(x))
                                   continue;

                              //Generate proposed path
                              LinkedList<GridCell> x_proposed_path = (LinkedList<GridCell>)(current_path.clone());
                              x_proposed_path.add(x);

                              //current least cost path
                              List<GridCell> clcp = current_costs.get(x);

                              if(clcp!=null && clcp.size()-1>our_cost+1)
                              {
                                   LinkedList<GridCell> old_unvisited = unvisited_nodes.get(clcp.size()-1);
                                   old_unvisited.removeFirstOccurrence(x);
                                   if(old_unvisited.size()==0)
                                        unvisited_nodes.remove(clcp.size()-1);
                              }
                              else if(clcp!=null && clcp.size()-1<=our_cost+1)
                                   continue;

                              LinkedList<GridCell> new_unvisited = unvisited_nodes.get(our_cost+1);
                              if(new_unvisited==null)
                              {
                                   new_unvisited = new LinkedList<GridCell>();
                                   unvisited_nodes.put(our_cost+1,new_unvisited);
                              }
                              new_unvisited.add(x);
                              current_costs.put(x,x_proposed_path);
                         }
                    }

                    /*Loop is over, and we didn't find a path to the target :(
                      Return null.*/
                    return null;
               }
     }

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

     enum BuildStatus { WALL, FORT, CAPSULE, ROBOT };

     void act(WorldAPI api, Robot_Status status, byte[][] received_radio);
}