Merge branch 'master' into client-release

Author: xqlcn

client/src/components/sidebar/map-editor/MapGenerator.ts

@@ -147,13 +147,27 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
     // Validate initial bodies
     for (const body of bodies.bodies.values()) {
         // Check distance from cat to other cats and cheese mines
+        let body_type = undefined
+        switch (body.robotType) {
+            case RobotType.CAT:
+                body_type = 'Cat'
+                break
+            case RobotType.RAT:
+                body_type = 'Rat'
+                break
+            case RobotType.RAT_KING:
+                body_type = 'Rat King'
+                break
+            default:
+                body_type = 'Unknown'
+        }
 
         for (const checkCheeseMine of map.staticMap.cheeseMines) {
-            if (squareIntersects(checkCheeseMine, body.pos, 4)) {
+            if (squareIntersects(checkCheeseMine, body.pos, 2)) {
                 return (
-                    `Cheese mine at (${checkCheeseMine.x}, ${checkCheeseMine.y}) is too close to cheese mine ` +
+                    `Cheese mine at (${checkCheeseMine.x}, ${checkCheeseMine.y}) is too close to ${body_type} ` +
                     `at (${body.pos.x}, ${body.pos.y}), must be ` +
-                    `>= 5 away`
+                    `>= 3 away`
                 )
             }
         }
@@ -162,7 +176,7 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
             if (checkBody === body) continue
             if (squareIntersects(checkBody.pos, body.pos, 0)) {
                 return (
-                    `Cat at (${body.pos.x}, ${body.pos.y}) is too close to cat ` +
+                    `${body_type} at (${body.pos.x}, ${body.pos.y}) is too close to cat ` +
                     `at (${checkBody.pos.x}, ${checkBody.pos.y}), must be ` +
                     `>= 1 away`
                 )
@@ -175,7 +189,7 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
         if (wall !== -1) {
             const pos = map.indexToLocation(wall)
             return (
-                `Cat at (${body.pos.x}, ${body.pos.y}) is too close to wall ` +
+                `${body_type} at (${body.pos.x}, ${body.pos.y}) is too close to wall ` +
                 `at (${pos.x}, ${pos.y}), must be ` +
                 `>= 3 away`
             )

client/src/playback/Actions.ts

@@ -46,8 +46,8 @@ export default class Actions {
                 //this.actions.splice(i, 1)
 
                 // Otherwise, this is faster
-                this.actions[i] = this.actions[this.actions.length - 1]
-                this.actions[i].finish(round)
+                [this.actions[i], this.actions[this.actions.length-1]] = [this.actions[this.actions.length - 1], this.actions[i]]
+                this.actions[this.actions.length-1].finish(round)
                 this.actions.pop()
 
                 i--
@@ -109,22 +109,23 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const random2 = ((src.pos.x * 259 + src.pos.y * 429 + match.currentRound.roundNumber * 224) / 100) % 1
             const interpolationFactor = match.getInterpolationFactor()
 
-            ctx.save()
-            ctx.globalAlpha = 0.5 - 0.5 * interpolationFactor * interpolationFactor
-            ctx.fillStyle = '#000000'
-            ctx.font = '0.4px Arial'
-            // parabolic trajectory.
-            const fontX = coords.x + (4 * random1 - 2) * interpolationFactor - 0.5
-            const fontY =
-                coords.y - (2 + 4 * random2) * interpolationFactor + 8 * interpolationFactor * interpolationFactor - 0.5
-            ctx.fillText('nom', fontX, fontY)
+            // ctx.save()
+            // ctx.globalAlpha = 0.5 - 0.5 * interpolationFactor * interpolationFactor
+            // ctx.fillStyle = '#000000'
+            // ctx.font = '0.4px Arial'
+            // // parabolic trajectory.
+            // const fontX = coords.x + (4 * random1 - 2) * interpolationFactor - 0.5
+            // const fontY =
+            //     coords.y - (2 + 4 * random2) * interpolationFactor + 8 * interpolationFactor * interpolationFactor - 0.5
+            // ctx.fillText('nom', fontX, fontY)
+            src.textureOverride = true
             src.imgPath = `robots/cat/cat_feed_${src.direction}.png`// is reset in `finish`.
-            ctx.restore()
+            // ctx.restore()
         }
 
         finish(round: Round): void {
             const src = round.bodies.getById(this.robotId)
-            src.imgPath = 'robots/cat/cat.png'
+            src.textureOverride = false
         }
     },
     [schema.Action.RatAttack]: class AttackAction extends Action<schema.RatAttack> {
@@ -183,18 +184,30 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
         }
     },
     [schema.Action.RatNap]: class RatNapAction extends Action<schema.RatNap> {
-        private static readonly OFFSET = { x: -0.35, y: 0 }
+        // private static readonly OFFSET = { x: -0.35, y: 0 }
         apply(round: Round): void {
             // move the target onto the source adjust target's size using scale factor
             const src = round.bodies.getById(this.robotId)
             const target = round.bodies.getById(this.actionData.id()) // rat getting napped
 
-            target.carriedRobot = undefined
-            src.carriedRobot = target.id
-
-            target.lastPos = { ...target.pos }
-            target.pos = { x: src.pos.x + RatNapAction.OFFSET.x, y: src.pos.y + RatNapAction.OFFSET.y }
-            target.size = 0.6
+            if (target.beingCarried) {
+                // drop the target
+                const carrier = round.bodies.getById(target.carrierRobot!)
+                carrier.carriedRobot = undefined
+                target.size = 1
+                target.beingCarried = false
+                target.carrierRobot = undefined
+            } else {
+                // pick up the target
+                src.carriedRobot = target.id
+                target.carrierRobot = src.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.size = 0.6
+            }
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             //target rat moves onto src rat, circle around carried group thing
@@ -219,7 +232,6 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             ctx.arcTo(srcCoords.x - half, srcCoords.y - half, srcCoords.x + half, srcCoords.y - half, radius)
             ctx.stroke()
             ctx.restore()
-            ctx.restore() 
         }
     },
     [schema.Action.RatCollision]: class RatCollisionAction extends Action<schema.RatCollision> {
@@ -377,10 +389,14 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
     [schema.Action.CatScratch]: class CatScratchAction extends Action<schema.CatScratch> {
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             // cat scratching animation
-
             const body = match.currentRound.bodies.getById(this.robotId)
             const pos = match.map.indexToLocation(this.actionData.loc())
             const coords = renderUtils.getRenderCoords(pos.x, pos.y, match.map.dimension, true)
+            
+            const dir = body.direction
+            body.textureOverride = true
+            body.imgPath = `robots/cat/cat_scratch_${dir}.png`
+            
             const reflected = body.pos.x < pos.x
 
             const interpolationFactor = match.getInterpolationFactor()
@@ -399,12 +415,11 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             }
             ctx.stroke()
             ctx.globalAlpha = 1
-            body.imgPath = `robots/cat/cat_scratch_${body.direction}.png`
         }
 
         finish(round: Round): void {
             const body = round.bodies.getById(this.robotId)
-            body.imgPath = 'robots/cat/cat.png'
+            body.textureOverride = false
         }
     },
     [schema.Action.CatPounce]: class CatPounceAction extends Action<schema.CatPounce> {
@@ -413,6 +428,7 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const body = round.bodies.getById(this.robotId)
             const startPos = round.map.indexToLocation(this.actionData.startLoc())
             const endPos = round.map.indexToLocation(this.actionData.endLoc())
+            console.log('pounce from', startPos, 'to', endPos)
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             // cat pouncing animation
@@ -423,6 +439,7 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const endCoords = renderUtils.getRenderCoords(endPos.x, endPos.y, match.map.dimension, true)
             const angle = Math.atan2(endPos.y - startPos.y, endPos.x - startPos.x)
 
+            body.textureOverride = true
             let texture: string
             if (angle >= (7 * Math.PI) / 4 || angle <= Math.PI / 4) {
                 texture = 'robots/cat/cat_pounce_5.png'
@@ -446,7 +463,7 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
         }
         finish(round: Round): void {
             const body = round.bodies.getById(this.robotId)
-            body.imgPath = 'robots/cat/cat.png'
+            body.textureOverride = false
         }
     },
     [schema.Action.PlaceTrap]: class PlaceTrapAction extends Action<schema.PlaceTrap> {
@@ -500,7 +517,8 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             // trap triggering animation
             const body = match.currentRound.bodies.getById(this.robotId)
-            const pos = match.map.indexToLocation(this.actionData.loc())
+            // const pos = match.map.indexToLocation(this.actionData.loc())
+            const pos = body.getInterpolatedCoords(match)
             const coords = renderUtils.getRenderCoords(pos.x, pos.y, match.map.dimension, true)
 
             const size = body.size - 1
@@ -546,6 +564,14 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             // maybe move rat to target loc
             const body = round.bodies.getById(this.robotId)
             const endLoc = round.map.indexToLocation(this.actionData.loc())
+            if( body.carriedRobot !== undefined ) {
+                const carrier = round.bodies.getById(body.carriedRobot)
+                carrier.carriedRobot = undefined
+            }
+            body.carrierRobot = undefined
+            body.beingCarried = false
+            body.size = 1
+            body.pos = { ...endLoc }
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const body = match.currentRound.bodies.getById(this.robotId)
@@ -555,15 +581,15 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
 
             const from = pos
             const to = match.currentRound.map.indexToLocation(this.actionData.loc())
-
+            console.log('throw from', from, 'to', to)
             const dx = to.x - from.x
             const dy = to.y - from.y
             const mag = Math.hypot(dx, dy)
             if (mag < 1e-3) return
 
             const ux = dx / mag
             const uy = dy / mag
-            const px = -uy
+            const px = uy
             const py = ux
 
             // deterministic jitter
@@ -583,10 +609,10 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
                 const offset = i * spacing
                 const jitter = (r - 0.5) * 0.15
 
-                const endX = coords.x - ux * 0.3 + px * offset + px * jitter
+                const endX = coords.x + ux * 0.3 + px * offset + px * jitter
                 const endY = coords.y - uy * 0.3 + py * offset + py * jitter
 
-                const startX = endX - ux * baseLength
+                const startX = endX + ux * baseLength
                 const startY = endY - uy * baseLength
 
                 ctx.beginPath()
@@ -655,16 +681,15 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const body = match.currentRound.bodies.getById(this.robotId)
             const renderCoords = renderUtils.getRenderCoords(
-                body.pos.x - 1 + body.size / 2,
-                body.pos.y + body.size / 2,
+                body.pos.x,
+                body.pos.y,
                 match.map.dimension,
-                true
             )
             renderUtils.renderCenteredImageOrLoadingIndicator(
                 ctx,
                 getImageIfLoaded('robots/squeak.png'),
                 renderCoords,
-                1
+                body.size
             )
         }
     },

client/src/playback/Bodies.ts

@@ -364,8 +364,11 @@ export class Body {
     public actionCooldown: number = 0
     public turningCooldown: number = 0
     public carriedRobot: number | undefined = undefined  // id of carried robot
+    public carrierRobot: number | undefined = undefined  // id of robot carrying this robot
+    public beingCarried: boolean = false
     public bytecodesUsed: number = 0
     public cheese: number = 0
+    public textureOverride: boolean = false
 
     constructor(
         private game: Game,
@@ -428,7 +431,13 @@ export class Body {
     }
 
     public draw(match: Match, ctx: CanvasRenderingContext2D): void {
+        const OFFSET = { x: .35, y: 0 } // to center the rat on the tile
+        const ratnapped = this.robotType === schema.RobotType.RAT && this.beingCarried
+
+        if(ratnapped) this.pos.x += OFFSET.x
         const pos = this.getInterpolatedCoords(match)
+        if(ratnapped) this.pos.x -= OFFSET.x
+
         const renderCoords = renderUtils.getRenderCoords(pos.x, pos.y, match.currentRound.map.staticMap.dimension)
 
         if (this.robotType == schema.RobotType.CAT) {
@@ -792,7 +801,7 @@ export const BODY_DEFINITIONS: Record<schema.RobotType, typeof Body> = {
 
         public draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const dir = this.direction
-            this.imgPath = `robots/${this.team.colorName.toLowerCase()}/rat_${dir}_64x64.png`
+            if (!this.textureOverride) this.imgPath = `robots/${this.team.colorName.toLowerCase()}/rat_${dir}_64x64.png`
             super.draw(match, ctx)
         }
     },
@@ -810,7 +819,7 @@ export const BODY_DEFINITIONS: Record<schema.RobotType, typeof Body> = {
 
         public draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const dir = this.direction
-            this.imgPath = `robots/${this.team.colorName.toLowerCase()}/rat_king_64x64.png`
+            if (!this.textureOverride) this.imgPath = `robots/${this.team.colorName.toLowerCase()}/rat_king_64x64.png`
             super.draw(match, ctx)
         }
     },
@@ -828,7 +837,7 @@ export const BODY_DEFINITIONS: Record<schema.RobotType, typeof Body> = {
 
         public draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const dir = this.direction
-            this.imgPath = `robots/cat/cat_${dir}.png`
+            if (!this.textureOverride) this.imgPath = `robots/cat/cat_${dir}.png`
             super.draw(match, ctx)
         }
     }

client/src/playback/Map.ts

@@ -318,7 +318,7 @@ export class CurrentMap {
         if (ratTrap) {
             info.push('Rat Trap')
         }
-        if (ratTrap) {
+        if (catTrap) {
             info.push('Cat Trap')
         }
         if (cheese) {

client/src/static/img/robots/cat/cat_feed_0.png

@@ -89,7 +89,7 @@ public class GameConstants {
     public static final double CHEESE_COOLDOWN_PENALTY = 0.01;
 
     /** The amount of cheese the rat king consumes each round. */
-    public static final int RAT_KING_CHEESE_CONSUMPTION = 3;
+    public static final int RAT_KING_CHEESE_CONSUMPTION = 2;
 
     /** The amount of health the rat king loses by not eating cheese. */
     public static final int RAT_KING_HEALTH_LOSS = 10;
@@ -101,16 +101,16 @@ public class GameConstants {
     public static final int SQ_CHEESE_SPAWN_RADIUS = 4;
 
     /** How much cheese each mine spawns at once */
-    public static final int CHEESE_SPAWN_AMOUNT = 5;
+    public static final int CHEESE_SPAWN_AMOUNT = 20;
 
     /** 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;

client/src/static/img/robots/cat/cat_scratch_0.png

@@ -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/GameConstants.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
+     * and not {@link Direction#CENTER}.
+     * 
+     * @param d the direction to turn to
+     */
+    boolean canTurn(Direction d);
+
     /**
      * Turns to the specified direction 
      *