Merge branch 'master' into engine-release

Author: compiler64

client/src/playback/Actions.ts

@@ -189,17 +189,18 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const src = round.bodies.getById(this.robotId)
             const target = round.bodies.getById(this.actionData.id()) // rat getting napped
 
-            if(src.carriedRobot === target.id) {
+            if (target.beingCarried) {
                 // drop the target
-                src.carriedRobot = undefined
                 target.size = 1
+                target.beingCarried = false
             } else {
                 // pick up the target
                 src.carriedRobot = target.id
                 target.carriedRobot = undefined
+                target.beingCarried = true
 
-                target.lastPos = { ...target.pos }
-                target.pos = { x: src.pos.x + RatNapAction.OFFSET.x, y: src.pos.y + RatNapAction.OFFSET.y }
+                // target.lastPos = { ...target.pos }
+                // target.pos = { x: src.pos.x + RatNapAction.OFFSET.x, y: src.pos.y + RatNapAction.OFFSET.y }
                 target.size = 0.6
             }
         }

client/src/playback/Bodies.ts

@@ -364,6 +364,7 @@ export class Body {
     public actionCooldown: number = 0
     public turningCooldown: number = 0
     public carriedRobot: number | undefined = undefined  // id of carried robot
+    public beingCarried: boolean = false
     public bytecodesUsed: number = 0
     public cheese: number = 0
 

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

@@ -106,11 +106,11 @@ public class GameConstants {
     /** The number of rat kings a player starts with. */
     public static final int NUMBER_INITIAL_RAT_KINGS = 1;
 
-    /**
-     * The maximum distance for transferring cheese to an allied rat king or
-     * dropping it on the ground
-     */
-    public static final int CHEESE_DROP_RADIUS_SQUARED = 9;
+    /** The maximum distance for transferring cheese to an allied rat king */
+    public static final int CHEESE_TRANSFER_RADIUS_SQUARED = 9;
+
+    /** The maximum distance for picking up cheese on the map */
+    public static final int CHEESE_PICK_UP_RADIUS_SQUARED = 2;
 
     /** The maximum distance from a rat king for building robots */
     public static final int BUILD_ROBOT_RADIUS_SQUARED = 4;

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

@@ -50,9 +50,9 @@ public boolean isWall() {
     }
 
     /**
-     * Returns if this square is a wall.
+     * Returns if this square is a dirt.
      * 
-     * @return whether this square is a wall
+     * @return whether this square is dirt
      * 
      * @battlecode.doc.costlymethod
      */

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

@@ -586,6 +586,15 @@ public interface RobotController {
      */
     boolean canTurn();
 
+    /**
+     * Checks whether this robot can turn to the specified direction.
+     * Effectively just canTurn() with an extra check that d is not null.
+     * 
+     * @param d the direction to turn to
+     * @throws GameActionException
+     */
+    boolean canTurn(Direction d);
+
     /**
      * Turns to the specified direction 
      * 

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

@@ -616,6 +616,7 @@ public void scratch(MapLocation loc) {
 
     public void grabRobot(MapLocation loc) {
         this.robotBeingCarried = this.gameWorld.getRobot(loc);
+        System.out.println("Robot " + this.ID + " grabbed robot " + this.robotBeingCarried);
         this.robotBeingCarried.getGrabbed(this); // Notify the grabbed robot that it has been picked up
         this.gameWorld.getMatchMaker().addRatNapAction(this.robotBeingCarried.getID());
 

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

@@ -426,7 +426,7 @@ public void removeDirt(MapLocation loc) throws GameActionException {
 
     private void assertCanPickUpCheese(MapLocation loc) throws GameActionException {
         assertIsRobotType(this.robot.getType());
-        assertCanActLocation(loc, GameConstants.BUILD_DISTANCE_SQUARED);
+        assertCanActLocation(loc, GameConstants.CHEESE_PICK_UP_RADIUS_SQUARED);
 
         if (this.gameWorld.getCheeseAmount(loc) <= 0)
             throw new GameActionException(CANT_DO_THAT, "No cheese at this location!");
@@ -840,13 +840,24 @@ public void move(Direction d) throws GameActionException {
         }
 
         this.robot.addMovementCooldownTurns(d);
-
     }
 
     private void assertCanTurn() throws GameActionException {
         assertIsTurningReady();
     }
 
+    private void assertCanTurn(Direction d) throws GameActionException {
+        assertIsTurningReady();
+
+        if (d == null) {
+            throw new GameActionException(CANT_DO_THAT, "Direction to turn to is null!");
+        }
+
+        if (d == Direction.CENTER) {
+            throw new GameActionException(CANT_DO_THAT, "Cannot turn to CENTER direction!");
+        }
+    }
+
     @Override
     public boolean canTurn() {
         try {
@@ -858,13 +869,21 @@ public boolean canTurn() {
     }
 
     @Override
-    public void turn(Direction d) throws GameActionException {
-        assertCanTurn();
-        if (d != Direction.CENTER) {
-            this.robot.setDirection(d);
-            this.robot.addTurningCooldownTurns();
+    public boolean canTurn(Direction d) {
+        try {
+            assertCanTurn(d);
+            return true;
+        } catch (GameActionException e) {
+            return false;
         }
+    }
 
+    @Override
+    public void turn(Direction d) throws GameActionException {
+        assertCanTurn(d);
+
+        this.robot.setDirection(d);
+        this.robot.addTurningCooldownTurns();
     }
 
     // ***********************************
@@ -1205,7 +1224,7 @@ public int readPersistentArray(int index) throws GameActionException {
 
     private void assertCanTransferCheese(MapLocation loc, int amount) throws GameActionException {
         assertNotNull(loc);
-        assertCanActLocation(loc, GameConstants.CHEESE_DROP_RADIUS_SQUARED);
+        assertCanActLocation(loc, GameConstants.CHEESE_TRANSFER_RADIUS_SQUARED);
         assertIsActionReady();
         InternalRobot robot = this.gameWorld.getRobot(loc);
         if (robot == null)
@@ -1354,6 +1373,7 @@ public void assertCanCarryRat(MapLocation loc) throws GameActionException {
         }
 
         InternalRobot targetRobot = this.gameWorld.getRobot(loc);
+
         if (targetRobot == null) {
             throw new GameActionException(CANT_DO_THAT, "No robot at target location");
         }
@@ -1367,10 +1387,15 @@ public void assertCanCarryRat(MapLocation loc) throws GameActionException {
             throw new GameActionException(CANT_DO_THAT, "Target robot is currently being thrown");
         }
 
+        if (targetRobot == this.robot) {
+            throw new GameActionException(CANT_DO_THAT, "Robots cannot grab themselves");
+        }
+
         // Allow grabbing if the target is facing away (cannot sense this robot), or
         // the target is allied, or the target is weaker (health comparison w/
         // threshold)
         boolean canGrab = false;
+
         if (!targetRobot.canSenseLocation(this.getLocation())) {
             canGrab = true;
         } else if (this.robot.getTeam() == targetRobot.getTeam()) {