Merge remote-tracking branch 'origin/schema' into crossplay

Author: TheApplePieGod

client/src/colors.ts

@@ -116,9 +116,9 @@ export const Colors = {
     ),
     LIGHT_CARD: new Color('LIGHT_CARD', '#f7f7f722', '--color-light-card', 'Light Card', Sections.INTERFACE),
 
-    WALLS_COLOR: new Color('WALLS_COLOR', '#547f31', '--color-walls', 'Walls', Sections.GENERAL),
-    DIRT_COLOR: new Color('DIRT_COLOR', '#991111', '--color-dirt', 'Dirt', Sections.GENERAL),
-    TILES_COLOR: new Color('TILES_COLOR', '#4c301e', '--color-tile', 'Tiles', Sections.GENERAL),
+    WALLS_COLOR: new Color('WALLS_COLOR', '#52485a', '--color-walls', 'Walls', Sections.GENERAL),
+    DIRT_COLOR: new Color('DIRT_COLOR', '#3b2931', '--color-dirt', 'Dirt', Sections.GENERAL),
+    TILES_COLOR: new Color('TILES_COLOR', '#221725', '--color-tile', 'Tiles', Sections.GENERAL),
 
     TEAM_ONE: new Color('TEAM_ONE', '#fcc00d', '--color-team0', 'Text', Sections.CHEDDAR),
 
@@ -148,8 +148,8 @@ export const Presets: ColorPreset[] = [
                 LIGHT: '#aaaaaa22',
                 LIGHT_HIGHLIGHT: '#ffffff33',
                 LIGHT_CARD: '#f7f7f722',
-                WALLS_COLOR: '#547f31',
-                TILES_COLOR: '#4c301e',
+                WALLS_COLOR: '#52485A',
+                TILES_COLOR: '#221725',
                 TEAM_ONE: '#fcc00d',
                 TEAM_TWO: '#c91c7e'
             }

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
@@ -476,11 +485,13 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
     public symmetricApply(x: number, y: number, fields: Record<string, MapEditorBrushField>, robotOne: boolean) {
         const isCat: boolean = fields.isCat.value
         const selectedBodyID = GameRenderer.getSelectedRobot()
+        let lastSelectedCatLoc: Vector | null = null
 
         if (selectedBodyID !== null && selectedBodyID !== undefined) {
             const body = this.bodies.bodies.get(selectedBodyID)
             if (body && body.robotType === schema.RobotType.CAT) {
                 this.lastSelectedCat = selectedBodyID
+                lastSelectedCatLoc = this.bodies.getById(this.lastSelectedCat)?.pos
             }
         }
 
@@ -491,6 +502,7 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
             if (!robotOne) {
                 const symmetricPoint = this.map.applySymmetryCat(this.bodies.getById(this.lastSelectedCat)!.pos)
                 currentCat = this.bodies.getBodyAtLocation(symmetricPoint.x, symmetricPoint.y)!.id
+                lastSelectedCatLoc = this.map.applySymmetry(lastSelectedCatLoc!)
             }
 
             // if undoing a waypoint addition
@@ -518,6 +530,9 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
                 return null
             }
 
+            if (!this.map.catWaypoints.has(currentCat)) {
+                this.map.catWaypoints.set(currentCat, [lastSelectedCatLoc!])
+            }
             this.map.catWaypoints.get(currentCat)?.push({ x, y })
 
             return () => {
@@ -535,7 +550,6 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
 
             const id = this.bodies.getNextID()
             this.bodies.spawnBodyFromValues(id, schema.RobotType.CAT, team, pos, 0, robotOne ? 0 : 1)
-            this.map.catWaypoints.set(id, [{ x: x, y: y }]) // add initial waypoint at spawn location
 
             return id
         }
@@ -546,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)
                 }
@@ -573,14 +591,23 @@ 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
         if (!undo0) return () => {}
 
         undoFunctions.push(undo0)
 
-        const symmetryPoint = this.map.applySymmetryCat({ x: x, y: y })
+        let symmetryPoint: { x: number; y: number }
+        if (fields.catOrWaypointMode.value === 1) {
+            symmetryPoint = this.map.applySymmetry({ x: x, y: y })
+        } else {
+            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)
 

client/src/playback/Map.ts

@@ -261,8 +261,8 @@ export class CurrentMap {
                 ctx.fill()
             })
             waypoints?.forEach((waypoint, idx) => {
-                let prevWaypoint = bodies.getById(selectedBodyID).pos
-                if (idx > 0) {
+                let prevWaypoint = waypoints[0]
+                if (idx > 1) {
                     prevWaypoint = waypoints[idx - 1]
                 }
                 const startCoords = renderUtils.getRenderCoords(prevWaypoint.x, prevWaypoint.y, this.dimension)

client/src/playback/RoundStat.ts

@@ -87,11 +87,11 @@ export default class RoundStat {
                 const teamStat = this.teams.get(team) ?? assert.fail(`team ${i} not found in team stats in round`)
 
                 teamStat.cheeseAmount = delta.teamCheeseTransferred(i) ?? assert.fail('missing cheese amount')
-                teamStat.cheesePercent = teamStat.cheeseAmount / totalCheese
+                teamStat.cheesePercent = totalCheese ? teamStat.cheeseAmount / totalCheese : 0
                 teamStat.catDamageAmount = delta.teamCatDamage(i) ?? assert.fail('missing cat damage amount')
-                teamStat.catDamagePercent = teamStat.catDamageAmount / totalCatDamage
+                teamStat.catDamagePercent = totalCatDamage ? teamStat.catDamageAmount / totalCatDamage : 0
                 teamStat.ratKingCount = delta.teamAliveRatKings(i) ?? assert.fail('missing rat king count')
-                teamStat.ratKingPercent = teamStat.ratKingCount / totalRatKings
+                teamStat.ratKingPercent = totalRatKings ? teamStat.ratKingCount / totalRatKings : 0
                 teamStat.dirtAmount = delta.teamDirtAmounts(i) ?? assert.fail('missing dirt amount')
                 teamStat.ratTrapAmount = delta.teamRatTrapCount(i) ?? assert.fail('missing rat trap amount')
                 teamStat.catTrapAmount = delta.teamCatTrapCount(i) ?? assert.fail('missing cat trap amount')