Merge pull request #45 from battlecode/new-sensing-functions

Add overloads for sensing functions

Author: wflms20110333

engine/src/main/battlecode/common/RobotController.java

@@ -340,13 +340,21 @@ public strictfp interface RobotController {
      */
     int senseGold(MapLocation loc) throws GameActionException;
 
+    /**
+     * Return all locations that contain a nonzero amount of lead.
+     *
+     * @return all locations within vision radius that contain a nonzero amount of lead
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithLead();
+
     /**
      * Return all locations that contain a nonzero amount of lead, within a
      * specified radius of your robot location.
      * If radiusSquared is larger than the robot's vision radius, uses the robot's
-     * vision radius instead.
-     *
-     * Checks that radiusSquared is non-negative.
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
      *
      * @param radiusSquared the squared radius of all locations to be returned
      * @return all locations that contain a nonzero amount of lead within the radius
@@ -357,12 +365,69 @@ public strictfp interface RobotController {
     MapLocation[] senseNearbyLocationsWithLead(int radiusSquared) throws GameActionException;
 
     /**
-     * Return all locations that contain a nonzero amount of gold, within a
+     * Return all locations that contain a nonzero amount of lead, within a
+     * specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
+     *
+     * @param center the center of the search area
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @return all locations that contain a nonzero amount of lead within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithLead(MapLocation center, int radiusSquared) throws GameActionException;
+
+    /**
+     * Return all locations that contain at least a certain amount of lead, within a
      * specified radius of your robot location.
      * If radiusSquared is larger than the robot's vision radius, uses the robot's
-     * vision radius instead.
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
      *
-     * Checks that radiusSquared is non-negative.
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @param minLead the minimum amount of lead
+     * @return all locations that contain at least minLead lead within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithLead(int radiusSquared, int minLead) throws GameActionException;
+
+    /**
+     * Return all locations that contain at least a certain amount of lead, within a
+     * specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
+     *
+     * @param center the center of the search area
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @param minLead the minimum amount of lead
+     * @return all locations that contain at least minLead lead within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithLead(MapLocation center, int radiusSquared, int minLead) throws GameActionException;
+
+    /**
+     * Return all locations that contain a nonzero amount of gold.
+     *
+     * @return all locations within vision radius that contain a nonzero amount of gold
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithGold();
+
+    /**
+     * Return all locations that contain a nonzero amount of gold, within a
+     * specified radius of your robot location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
      *
      * @param radiusSquared the squared radius of all locations to be returned
      * @return all locations that contain a nonzero amount of gold within the radius
@@ -372,6 +437,55 @@ public strictfp interface RobotController {
      */
     MapLocation[] senseNearbyLocationsWithGold(int radiusSquared) throws GameActionException;
 
+    /**
+     * Return all locations that contain a nonzero amount of gold, within a
+     * specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
+     *
+     * @param center the center of the search area
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @return all locations that contain a nonzero amount of gold within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithGold(MapLocation center, int radiusSquared) throws GameActionException;
+
+    /**
+     * Return all locations that contain at least a certain amount of gold, within a
+     * specified radius of your robot location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
+     *
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @param minGold the minimum amount of gold
+     * @return all locations that contain at least minGold gold within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithGold(int radiusSquared, int minGold) throws GameActionException;
+
+    /**
+     * Return all locations that contain at least a certain amount of gold, within a
+     * specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations with vision radius
+     * are returned.
+     *
+     * @param center the center of the search area
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @param minGold the minimum amount of gold
+     * @return all locations that contain at least minGold gold within the radius
+     * @throws GameActionException if the radius is negative
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyLocationsWithGold(MapLocation center, int radiusSquared, int minGold) throws GameActionException;
+
     /**
      * Returns the location adjacent to current location in the given direction.
      *

engine/src/main/battlecode/world/RobotControllerImpl.java

@@ -290,31 +290,79 @@ public int senseGold(MapLocation loc) throws GameActionException {
         return this.gameWorld.getGold(loc);
     }
 
+    @Override
+    public MapLocation[] senseNearbyLocationsWithLead() {
+        try {
+            return senseNearbyLocationsWithLead(getLocation(), -1, 1);
+        } catch (GameActionException willNeverHappen) {
+            throw new RuntimeException("impossible", willNeverHappen);
+        }
+    }
+
     @Override
     public MapLocation[] senseNearbyLocationsWithLead(int radiusSquared) throws GameActionException {
+        return senseNearbyLocationsWithLead(getLocation(), radiusSquared, 1);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithLead(MapLocation center, int radiusSquared) throws GameActionException {
+        return senseNearbyLocationsWithLead(center, radiusSquared, 1);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithLead(int radiusSquared, int minLead) throws GameActionException {
+        return senseNearbyLocationsWithLead(getLocation(), radiusSquared, minLead);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithLead(MapLocation center, int radiusSquared, int minLead) throws GameActionException {
+        radiusSquared = (radiusSquared == -1) ? getType().visionRadiusSquared : Math.min(radiusSquared, getType().visionRadiusSquared);
         if (radiusSquared < 0)
             throw new GameActionException(CANT_DO_THAT,
                     "Radius squared must be non-negative.");
-        radiusSquared = Math.min(radiusSquared, getType().visionRadiusSquared);
         ArrayList<MapLocation> locations = new ArrayList<>();
-        for (MapLocation m : this.gameWorld.getAllLocationsWithinRadiusSquared(getLocation(), radiusSquared)) {
-            if (this.gameWorld.getLead(m) > 0) {
+        for (MapLocation m : this.gameWorld.getAllLocationsWithinRadiusSquared(center, radiusSquared)) {
+            if (this.gameWorld.getLead(m) >= minLead) {
                 locations.add(m);
             }
         }
         MapLocation[] result = new MapLocation[locations.size()];
         return locations.toArray(result);
     }
 
+    @Override
+    public MapLocation[] senseNearbyLocationsWithGold() {
+        try {
+            return senseNearbyLocationsWithGold(getLocation(), -1, 1);
+        } catch (GameActionException willNeverHappen) {
+            throw new RuntimeException("impossible", willNeverHappen);
+        }
+    }
+
     @Override
     public MapLocation[] senseNearbyLocationsWithGold(int radiusSquared) throws GameActionException {
+        return senseNearbyLocationsWithGold(getLocation(), radiusSquared, 1);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithGold(MapLocation center, int radiusSquared) throws GameActionException {
+        return senseNearbyLocationsWithGold(center, radiusSquared, 1);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithGold(int radiusSquared, int minGold) throws GameActionException {
+        return senseNearbyLocationsWithGold(getLocation(), radiusSquared, minGold);
+    }
+
+    @Override
+    public MapLocation[] senseNearbyLocationsWithGold(MapLocation center, int radiusSquared, int minGold) throws GameActionException {
+        radiusSquared = (radiusSquared == -1) ? getType().visionRadiusSquared : Math.min(radiusSquared, getType().visionRadiusSquared);
         if (radiusSquared < 0)
             throw new GameActionException(CANT_DO_THAT,
                     "Radius squared must be non-negative.");
-        radiusSquared = Math.min(radiusSquared, getType().visionRadiusSquared);
         ArrayList<MapLocation> locations = new ArrayList<>();
-        for (MapLocation m : this.gameWorld.getAllLocationsWithinRadiusSquared(getLocation(), radiusSquared)) {
-            if (this.gameWorld.getGold(m) > 0) {
+        for (MapLocation m : this.gameWorld.getAllLocationsWithinRadiusSquared(center, radiusSquared)) {
+            if (this.gameWorld.getGold(m) >= minGold) {
                 locations.add(m);
             }
         }