Merge branch 'master' of https://github.com/battlecode/battlecode25

Author: Ian Gonzalez Hermosillo

client/src/components/controls-bar/controls-bar.tsx

@@ -167,7 +167,7 @@ export const ControlsBar: React.FC = () => {
                     icon={<ControlIcons.SkipForwardsIcon />}
                     tooltip={'Increase Speed'}
                     onClick={() => GameRunner.multiplyUpdatesPerSecond(2)}
-                    disabled={Math.abs(targetUPS) >= 64}
+                    disabled={Math.abs(targetUPS) >= 128}
                 />
                 <ControlsBarButton
                     icon={<ControlIcons.PlaybackStopIcon />}

client/src/constants.ts

@@ -1,4 +1,4 @@
-export const CLIENT_VERSION = '1.2.0'
+export const CLIENT_VERSION = '1.3.0'
 export const SPEC_VERSION = '1'
 export const BATTLECODE_YEAR: number = 2025
 export const MAP_SIZE_RANGE = {

client/src/playback/Bodies.ts

@@ -275,7 +275,7 @@ export class Body {
                 this.drawHealthBar(match, overlayCtx)
             }
             if (focused || config.showPaintBars) {
-                this.drawPaintBar(match, overlayCtx, config.showHealthBars)
+                this.drawPaintBar(match, overlayCtx, focused || config.showHealthBars)
             }
         }
     }

client/src/playback/GameRenderer.ts

@@ -155,6 +155,7 @@ class GameRendererClass {
 
     private canvasMouseMove(e: MouseEvent) {
         const newTile = eventToPoint(e)
+        if (!newTile) return
         if (newTile.x !== this.mouseTile?.x || newTile.y !== this.mouseTile?.y) {
             this.mouseTile = newTile
             this.render()
@@ -176,7 +177,9 @@ class GameRendererClass {
     }
 
     private canvasMouseEnter(e: MouseEvent) {
-        this.mouseTile = eventToPoint(e)
+        const point = eventToPoint(e)
+        if (!point) return
+        this.mouseTile = point
         this.mouseDown = e.buttons > 0
         if (e.buttons === 2) this.mouseDownRight = true
         this._trigger(this._canvasHoverListeners)
@@ -192,6 +195,9 @@ class GameRendererClass {
             return
 
         this.selectedTile = eventToPoint(e)
+
+        if (!this.selectedTile) return
+
         const newSelectedBody = GameRunner.match?.currentRound.bodies.getBodyAtLocation(
             this.selectedTile.x,
             this.selectedTile.y
@@ -244,15 +250,16 @@ class GameRendererClass {
     }
 }
 
-const eventToPoint = (e: MouseEvent) => {
+const eventToPoint = (e: MouseEvent): Vector | undefined => {
     const canvas = e.target as HTMLCanvasElement
     const rect = canvas.getBoundingClientRect()
-    const map = GameRunner.match?.map ?? assert.fail('map is null in onclick')
+    const map = GameRunner.match?.map
+    if (!map) return undefined
     let x = Math.floor(((e.clientX - rect.left) / rect.width) * map.width)
     let y = Math.floor((1 - (e.clientY - rect.top) / rect.height) * map.height)
     x = Math.max(0, Math.min(x, map.width - 1))
     y = Math.max(0, Math.min(y, map.height - 1))
-    return { x: x, y: y }
+    return { x, y }
 }
 
 export const GameRenderer = new GameRendererClass()

client/src/playback/GameRunner.ts

@@ -123,7 +123,7 @@ class GameRunnerClass {
     multiplyUpdatesPerSecond(multiplier: number) {
         if (!this.match) return
         const scaled = this.targetUPS * multiplier
-        const newMag = Math.max(1 / 4, Math.min(64, Math.abs(scaled)))
+        const newMag = Math.max(1 / 4, Math.min(128, Math.abs(scaled)))
         this.targetUPS = Math.sign(scaled) * newMag
         this._trigger(this._controlListeners)
     }

client/src/playback/Map.ts

@@ -73,6 +73,10 @@ export class CurrentMap {
         return this.staticMap.locationToIndex(x, y)
     }
 
+    locationToIndexUnchecked(x: number, y: number): number {
+        return this.staticMap.locationToIndexUnchecked(x, y)
+    }
+
     applySymmetry(point: Vector): Vector {
         return this.staticMap.applySymmetry(point)
     }
@@ -96,7 +100,7 @@ export class CurrentMap {
         const dimension = this.dimension
         for (let i = 0; i < dimension.width; i++) {
             for (let j = 0; j < dimension.height; j++) {
-                const schemaIdx = this.locationToIndex(i, j)
+                const schemaIdx = this.locationToIndexUnchecked(i, j)
                 const coords = renderUtils.getRenderCoords(i, j, dimension)
 
                 // Render rounded (clipped) paint
@@ -321,6 +325,10 @@ export class StaticMap {
         return Math.floor(y) * this.width + Math.floor(x)
     }
 
+    locationToIndexUnchecked(x: number, y: number): number {
+        return y * this.width + x
+    }
+
     /**
      * Returns a point representing the reflection of the given point following the map's symmetry.
      */
@@ -360,7 +368,7 @@ export class StaticMap {
 
         for (let i = 0; i < this.dimension.width; i++) {
             for (let j = 0; j < this.dimension.height; j++) {
-                const schemaIdx = this.locationToIndex(i, j)
+                const schemaIdx = this.locationToIndexUnchecked(i, j)
                 const coords = renderUtils.getRenderCoords(i, j, this.dimension)
 
                 // Render rounded (clipped) wall

client/src/playback/Match.ts

@@ -181,12 +181,15 @@ export default class Match {
         const currentTurnNumber = this.currentRound.turnNumber
 
         this._currentSimulationStep += deltaTime * MAX_SIMULATION_STEPS
+
         if (this.playbackPerTurn) {
+            // This works because of the way floor works
+            const deltaTurns = Math.floor(this._currentSimulationStep / MAX_SIMULATION_STEPS)
             if (this._currentSimulationStep >= MAX_SIMULATION_STEPS) {
-                this._stepTurn(1)
+                this._stepTurn(deltaTurns)
                 this._currentSimulationStep = 0
             } else if (this._currentSimulationStep < 0) {
-                this._stepTurn(-1)
+                this._stepTurn(deltaTurns)
                 this._currentSimulationStep = MAX_SIMULATION_STEPS - 1
             }
         } else {
@@ -230,6 +233,8 @@ export default class Match {
     }
 
     private _updateSimulationRoundsByTime(deltaTime: number): void {
+        // This works because of the way floor works
+        const deltaRounds = Math.floor(this._currentSimulationStep / MAX_SIMULATION_STEPS)
         if (this.currentRound.roundNumber == this.maxRound && deltaTime > 0) {
             // If we are at the end, round the simulation to the max value
             this._currentSimulationStep = Math.min(this._currentSimulationStep, MAX_SIMULATION_STEPS)
@@ -239,12 +244,12 @@ export default class Match {
         } else if (this._currentSimulationStep < 0) {
             // If we are going in reverse, step the rounds back by one. Also,
             // apply all turns for that round so that the transition is smooth
-            this._stepRound(-1)
+            this._stepRound(deltaRounds)
             this.currentRound.jumpToTurn(this.currentRound.turnsLength)
             this._currentSimulationStep = MAX_SIMULATION_STEPS - 1
         } else if (this._currentSimulationStep >= MAX_SIMULATION_STEPS) {
             // If we are going forward, simply step the turn
-            this._stepRound(1)
+            this._stepRound(deltaRounds)
         }
     }