Merge branch 'master' into schema-colors

Author: TheApplePieGod

client/src/client-config.tsx

@@ -25,6 +25,7 @@ const DEFAULT_CONFIG = {
     showAllRobotRadii: false,
     showTimelineMarkers: true,
     showHealthBars: true,
+    showPaintBars: false,
     showPaintMarkers: true,
     showMapXY: true,
     enableFancyPaint: true,
@@ -52,6 +53,7 @@ const configDescription: Record<keyof ClientConfig, string> = {
     showAllRobotRadii: 'Show all robot view and attack radii',
     showTimelineMarkers: 'Show user-generated markers on the timeline',
     showHealthBars: 'Show health bars below all robots',
+    showPaintBars: 'Show paint bars below all robots',
     showPaintMarkers: 'Show paint markers created using mark()',
     showMapXY: 'Show X,Y when hovering a tile',
     enableFancyPaint: 'Enable fancy paint rendering',

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/components/sidebar/map-editor/MapGenerator.ts

@@ -4,9 +4,10 @@ import Match from '../../../playback/Match'
 import { CurrentMap, StaticMap } from '../../../playback/Map'
 import Round from '../../../playback/Round'
 import Bodies from '../../../playback/Bodies'
-import { BATTLECODE_YEAR, DIRECTIONS } from '../../../constants'
+import { BATTLECODE_YEAR, DIRECTIONS, TEAM_COLOR_NAMES } from '../../../constants'
 import { nativeAPI } from '../runner/native-api-wrapper'
 import { Vector } from '../../../playback/Vector'
+import { RobotType } from 'battlecode-schema/js/battlecode/schema'
 
 export function loadFileAsMap(file: File): Promise<Game> {
     return new Promise((resolve, reject) => {
@@ -54,8 +55,6 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
 
     // Validate map elements
     let numWalls = 0
-    let numPaintTowers = 0
-    let numMoneyTowers = 0
     const mapSize = map.width * map.height
     for (let i = 0; i < mapSize; i++) {
         const pos = map.indexToLocation(i)
@@ -104,8 +103,6 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
             }
         }
 
-        numPaintTowers += body && body.robotType === schema.RobotType.PAINT_TOWER ? 1 : 0
-        numMoneyTowers += body && body.robotType === schema.RobotType.MONEY_TOWER ? 1 : 0
         numWalls += wall
     }
 
@@ -117,24 +114,61 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
     }
 
     // Validate initial bodies
-    if (numPaintTowers !== 2) {
-        return `Expected exactly 2 paint towers, found ${numPaintTowers}`
-    }
-    if (numMoneyTowers !== 2) {
-        return `Expected exactly 2 money towers, found ${numMoneyTowers}`
-    }
+    const numPaintTowers = [0, 0]
+    const numMoneyTowers = [0, 0]
     for (const body of bodies.bodies.values()) {
-        // Check distance to nearby ruins
+        // Check distance to nearby ruins, towers, and walls
+
+        if (body.robotType === RobotType.PAINT_TOWER) {
+            numPaintTowers[body.team.id - 1]++
+        } else if (body.robotType === RobotType.MONEY_TOWER) {
+            numMoneyTowers[body.team.id - 1]++
+        } else {
+            return `Tower at (${body.pos.x}, ${body.pos.y}) has invalid type!`
+        }
 
         for (const checkRuin of map.staticMap.ruins) {
-            if (squareIntersects(checkRuin, body.pos, 2)) {
+            if (squareIntersects(checkRuin, body.pos, 4)) {
                 return (
                     `Tower at (${body.pos.x}, ${body.pos.y}) is too close to ruin ` +
                     `at (${checkRuin.x}, ${checkRuin.y}), must be ` +
-                    `>= 3 away`
+                    `>= 5 away`
+                )
+            }
+        }
+
+        for (const checkBody of bodies.bodies.values()) {
+            if (checkBody === body) continue
+            if (squareIntersects(checkBody.pos, body.pos, 4)) {
+                return (
+                    `Tower at (${body.pos.x}, ${body.pos.y}) is too close to ruin ` +
+                    `at (${checkBody.pos.x}, ${checkBody.pos.y}), must be ` +
+                    `>= 5 away`
                 )
             }
         }
+
+        const wall = map.staticMap.walls.findIndex(
+            (v, i) => !!v && squareIntersects(map.indexToLocation(i), body.pos, 2)
+        )
+        if (wall !== -1) {
+            const pos = map.indexToLocation(wall)
+            return (
+                `Tower at (${body.pos.x}, ${body.pos.y}) is too close to wall ` +
+                `at (${pos.x}, ${pos.y}), must be ` +
+                `>= 3 away`
+            )
+        }
+    }
+
+    for (const teamIdx of [0, 1]) {
+        if (numPaintTowers[teamIdx] !== 1) {
+            return `Expected exactly 1 ${TEAM_COLOR_NAMES[teamIdx]} paint tower, found ${numPaintTowers[teamIdx]}`
+        }
+
+        if (numMoneyTowers[teamIdx] !== 1) {
+            return `Expected exactly 1 ${TEAM_COLOR_NAMES[teamIdx]} money tower, found ${numMoneyTowers[teamIdx]}`
+        }
     }
 
     return ''

client/src/components/sidebar/map-editor/map-editor.tsx

@@ -160,7 +160,7 @@ export const MapEditorPage: React.FC<Props> = (props) => {
             GameRunner.setMatch(editGame.current.currentMatch)
 
             const round = editGame.current.currentMatch!.currentRound
-            const brushes = round.map.getEditorBrushes().concat(round.bodies.getEditorBrushes(round.map.staticMap))
+            const brushes = round.map.getEditorBrushes(round).concat(round.bodies.getEditorBrushes(round))
             brushes[0].open = true
             setBrushes(brushes)
             setCleared(round.bodies.isEmpty() && round.map.isEmpty())

client/src/constants.ts

@@ -1,6 +1,4 @@
-import {Colors} from './colors'
-
-export const CLIENT_VERSION = '1.0.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

@@ -188,8 +188,8 @@ export default class Bodies {
         return this.bodies.size === 0
     }
 
-    getEditorBrushes(map: StaticMap): MapEditorBrush[] {
-        return [new TowerBrush(this, map)]
+    getEditorBrushes(round: Round): MapEditorBrush[] {
+        return [new TowerBrush(round)]
     }
 
     toInitialBodyTable(builder: flatbuffers.Builder): number {
@@ -275,6 +275,9 @@ export class Body {
             if (focused || config.showHealthBars) {
                 this.drawHealthBar(match, overlayCtx)
             }
+            if (focused || config.showPaintBars) {
+                this.drawPaintBar(match, overlayCtx, focused || config.showHealthBars)
+            }
         }
     }
 
@@ -382,6 +385,15 @@ export class Body {
         const squares2 = this.getAllLocationsWithinRadiusSquared(match, pos, this.metadata.visionRadiusSquared())
         this.drawEdges(match, ctx, lightly, squares2)
 
+        // Currently vision/message radius are always the same
+        /*
+        ctx.beginPath()
+        ctx.strokeStyle = 'brown'
+        ctx.lineWidth = 0.1
+        const squares3 = this.getAllLocationsWithinRadiusSquared(match, pos, this.metadata.messageRadiusSquared())
+        this.drawEdges(match, ctx, lightly, squares3)
+        */
+
         ctx.globalAlpha = 1
     }
 
@@ -427,6 +439,21 @@ export class Body {
         ctx.fillRect(hpBarX, hpBarY, hpBarWidth * (this.hp / this.maxHp), hpBarHeight)
     }
 
+    private drawPaintBar(match: Match, ctx: CanvasRenderingContext2D, healthVisible: boolean): void {
+        const dimension = match.currentRound.map.staticMap.dimension
+        const interpCoords = this.getInterpolatedCoords(match)
+        const renderCoords = renderUtils.getRenderCoords(interpCoords.x, interpCoords.y, dimension)
+        const paintBarWidth = 0.8
+        const paintBarHeight = 0.1
+        const paintBarYOffset = 0.4 + (healthVisible ? 0.11 : 0)
+        const paintBarX = renderCoords.x + 0.5 - paintBarWidth / 2
+        const paintBarY = renderCoords.y + 0.5 + paintBarYOffset
+        ctx.fillStyle = 'rgba(0,0,0,.3)'
+        ctx.fillRect(paintBarX, paintBarY, paintBarWidth, paintBarHeight)
+        ctx.fillStyle = '#c515ed'
+        ctx.fillRect(paintBarX, paintBarY, paintBarWidth * (this.paint / this.maxPaint), paintBarHeight)
+    }
+
     protected drawLevel(match: Match, ctx: CanvasRenderingContext2D) {
         if (this.level <= 1) return
 

client/src/playback/Brushes.ts

@@ -9,6 +9,7 @@ import Bodies from './Bodies'
 import { CurrentMap, StaticMap } from './Map'
 import { Vector } from './Vector'
 import { Team } from './Game'
+import Round from './Round'
 
 const applyInRadius = (
     map: CurrentMap | StaticMap,
@@ -40,7 +41,35 @@ const squareIntersects = (check: Vector, center: Vector, radius: number) => {
     )
 }
 
+const checkValidRuinPlacement = (check: Vector, map: StaticMap, bodies: Bodies) => {
+    // Check if ruin is too close to the border
+    if (check.x <= 1 || check.x >= map.width - 2 || check.y <= 1 || check.y >= map.height - 2) {
+        return false
+    }
+
+    // Check if this is a valid ruin location
+    const idx = map.locationToIndex(check.x, check.y)
+    const ruin = map.ruins.findIndex((l) => squareIntersects(l, check, 4))
+    const wall = map.walls.findIndex((v, i) => !!v && squareIntersects(map.indexToLocation(i), check, 2))
+    const paint = map.initialPaint[idx]
+
+    let tower = undefined
+    for (const b of bodies.bodies.values()) {
+        if (squareIntersects(check, b.pos, 4)) {
+            tower = b
+            break
+        }
+    }
+
+    if (tower || ruin !== -1 || wall !== -1 || paint) {
+        return false
+    }
+
+    return true
+}
+
 export class WallsBrush extends SymmetricMapEditorBrush<StaticMap> {
+    private readonly bodies: Bodies
     public readonly name = 'Walls'
     public readonly fields = {
         shouldAdd: {
@@ -54,8 +83,9 @@ export class WallsBrush extends SymmetricMapEditorBrush<StaticMap> {
         }
     }
 
-    constructor(map: StaticMap) {
-        super(map)
+    constructor(round: Round) {
+        super(round.map.staticMap)
+        this.bodies = round.bodies
     }
 
     public symmetricApply(x: number, y: number, fields: Record<string, MapEditorBrushField>) {
@@ -64,7 +94,17 @@ export class WallsBrush extends SymmetricMapEditorBrush<StaticMap> {
             const pos = this.map.indexToLocation(idx)
             const ruin = this.map.ruins.findIndex((l) => squareIntersects(l, pos, 2))
             const paint = this.map.initialPaint[idx]
-            if (ruin !== -1 || paint) return true
+
+            let tower = undefined
+            for (const b of this.bodies.bodies.values()) {
+                if (squareIntersects(pos, b.pos, 2)) {
+                    tower = b
+                    break
+                }
+            }
+
+            if (tower || ruin !== -1 || paint) return true
+
             this.map.walls[idx] = 1
         }
 
@@ -94,6 +134,7 @@ export class WallsBrush extends SymmetricMapEditorBrush<StaticMap> {
 }
 
 export class RuinsBrush extends SymmetricMapEditorBrush<StaticMap> {
+    private readonly bodies: Bodies
     public readonly name = 'Ruins'
     public readonly fields = {
         shouldAdd: {
@@ -102,26 +143,14 @@ export class RuinsBrush extends SymmetricMapEditorBrush<StaticMap> {
         }
     }
 
-    constructor(map: StaticMap) {
-        super(map)
+    constructor(round: Round) {
+        super(round.map.staticMap)
+        this.bodies = round.bodies
     }
 
     public symmetricApply(x: number, y: number, fields: Record<string, MapEditorBrushField>) {
         const add = (x: number, y: number) => {
-            // Check if ruin is too close to the border
-            if (x <= 1 || x >= this.map.width - 2 || y <= 1 || y >= this.map.height - 2) {
-                return true
-            }
-
-            // Check if this is a valid ruin location
-            const pos = { x, y }
-            const idx = this.map.locationToIndex(x, y)
-            const ruin = this.map.ruins.findIndex((l) => squareIntersects(l, pos, 4))
-            const wall = this.map.walls.findIndex(
-                (v, i) => !!v && squareIntersects(this.map.indexToLocation(i), pos, 2)
-            )
-            const paint = this.map.initialPaint[idx]
-            if (ruin !== -1 || wall !== -1 || paint) {
+            if (!checkValidRuinPlacement({ x, y }, this.map, this.bodies)) {
                 return true
             }
 
@@ -145,6 +174,7 @@ export class RuinsBrush extends SymmetricMapEditorBrush<StaticMap> {
 }
 
 export class PaintBrush extends SymmetricMapEditorBrush<CurrentMap> {
+    private readonly bodies: Bodies
     public readonly name = 'Paint'
     public readonly fields = {
         shouldAdd: {
@@ -171,8 +201,9 @@ export class PaintBrush extends SymmetricMapEditorBrush<CurrentMap> {
         }
     }
 
-    constructor(map: CurrentMap) {
-        super(map)
+    constructor(round: Round) {
+        super(round.map)
+        this.bodies = round.bodies
     }
 
     public symmetricApply(x: number, y: number, fields: Record<string, MapEditorBrushField>, robotOne: boolean) {
@@ -217,6 +248,7 @@ export class PaintBrush extends SymmetricMapEditorBrush<CurrentMap> {
 }
 
 export class TowerBrush extends SymmetricMapEditorBrush<StaticMap> {
+    private readonly bodies: Bodies
     public readonly name = 'Towers'
     public readonly fields = {
         isTower: {
@@ -238,26 +270,20 @@ export class TowerBrush extends SymmetricMapEditorBrush<StaticMap> {
         }
     }
 
-    constructor(
-        private readonly bodies: Bodies,
-        map: StaticMap
-    ) {
-        super(map)
+    constructor(round: Round) {
+        super(round.map.staticMap)
+        this.bodies = round.bodies
     }
 
     public symmetricApply(x: number, y: number, fields: Record<string, MapEditorBrushField>, robotOne: boolean) {
         const towerType: schema.RobotType = fields.towerType.value
         const isTower: boolean = fields.isTower.value
 
         const add = (x: number, y: number, team: Team) => {
-            // Check if this is a valid tower location
             const pos = { x, y }
-            const idx = this.map.locationToIndex(x, y)
-            const body = this.bodies.getBodyAtLocation(x, y)
-            const wall = this.map.walls[idx]
-            const ruin = this.map.ruins.findIndex((l) => squareIntersects(l, pos, 2))
-
-            if (body || wall || ruin !== -1) return null
+            if (!checkValidRuinPlacement(pos, this.map, this.bodies)) {
+                return null
+            }
 
             const id = this.bodies.getNextID()
             this.bodies.spawnBodyFromValues(id, towerType, team, pos)