Merge branch 'schema' of https://github.com/battlecode/battlecode26 into schema

Author: saltyquackerd

client/src/playback/Actions.ts

@@ -118,7 +118,7 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const fontY =
                 coords.y - (2 + 4 * random2) * interpolationFactor + 8 * interpolationFactor * interpolationFactor - 0.5
             ctx.fillText('nom', fontX, fontY)
-            src.imgPath = 'robots/cat/cat_feed.png' // is reset in `finish`.
+            src.imgPath = `robots/cat/cat_feed_${src.direction}.png`// is reset in `finish`.
             ctx.restore()
         }
 
@@ -344,6 +344,12 @@ 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'
         }
     },
     [schema.Action.CatPounce]: class CatPounceAction extends Action<schema.CatPounce> {

client/src/playback/Brushes.ts

@@ -317,6 +317,15 @@ export class WallsBrush extends SymmetricMapEditorBrush<StaticMap> {
             const cheeseMine = this.map.cheeseMines.findIndex((l) => squareIntersects(l, pos, 2))
             const dirt = this.map.initialDirt[idx]
 
+            for (const waypoints of this.map.catWaypoints.values()) {
+                for (const waypoint of waypoints) {
+                    if (waypoint.x === pos.x && waypoint.y === pos.y) return true
+                    for (let nei of this.map.getNeighbors(waypoint.x, waypoint.y)) {
+                        if (nei.x === pos.x && nei.y === pos.y) return true
+                    }
+                }
+            }
+
             if (cheeseMine !== -1 || dirt) return true
 
             this.map.walls[idx] = 1
@@ -551,23 +560,27 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
             if (!body) return null
 
             const team = body.team
+            const pos = body.pos
             this.bodies.removeBody(body.id)
             const waypoints = this.map.catWaypoints.get(body.id)
             this.map.catWaypoints.delete(body.id)
 
-            return { team, waypoints }
+            return { team, waypoints, pos }
         }
-
         if (isCat) {
             // shouldnt matter which team we add to since cats are neutral
             const id = add(x, y, this.bodies.game.teams[0])
             if (id) return () => this.bodies.removeBody(id)
             return null
         } else {
-            const { team, waypoints } = remove(x, y)!
+            const removed = remove(x, y)
+            if (!removed) return null
+
+            const { team, waypoints, pos } = removed
             if (!team) return null
+
             return () => {
-                add(x, y, team)
+                add(pos.x, pos.y, team)
                 if (waypoints) {
                     this.map.catWaypoints.set(this.bodies.getBodyAtLocation(x, y)!.id, waypoints)
                 }
@@ -578,6 +591,10 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
     // Override default symmetric apply behavior because cats occupy a 2x2 footprint
     public apply(x: number, y: number, fields: Record<string, MapEditorBrushField>, robotOne: boolean): UndoFunction {
         const undoFunctions: UndoFunction[] = []
+
+        const body = this.bodies.getBodyAtLocation(x, y)
+        const anchor = body?.pos
+
         const undo0 = this.symmetricApply(x, y, fields, robotOne)
 
         // Return early if brush could not be applied
@@ -589,7 +606,7 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
         if (fields.catOrWaypointMode.value === 1) {
             symmetryPoint = this.map.applySymmetry({ x: x, y: y })
         } else {
-            symmetryPoint = this.map.applySymmetryCat({ x: x, y: y })
+            symmetryPoint = !anchor ? this.map.applySymmetryCat({ x: x, y: y }) : this.map.applySymmetryCat(anchor)
         }
         if (symmetryPoint.x != x || symmetryPoint.y != y) {
             const undo1 = this.symmetricApply(symmetryPoint.x, symmetryPoint.y, fields, !robotOne)