Merge branch 'master' into public-release

Author: TheApplePieGod

client/src/client-config.tsx

@@ -27,8 +27,11 @@ const DEFAULT_CONFIG = {
     showAllRobotRadii: false,
     showTimelineMarkers: true,
     showHealthBars: true,
-    showPaintBars: false,
+    showPaintBars: true,
     showPaintMarkers: true,
+    showSRPOutlines: true,
+    showSRPText: false,
+    showExceededBytecode: false,
     showMapXY: true,
     focusRobotTurn: true,
     enableFancyPaint: true,
@@ -58,6 +61,9 @@ const configDescription: Record<keyof ClientConfig, string> = {
     showHealthBars: 'Show health bars below all robots',
     showPaintBars: 'Show paint bars below all robots',
     showPaintMarkers: 'Show paint markers created using mark()',
+    showSRPOutlines: 'Show outlines around active SRPs',
+    showSRPText: 'Show remaining rounds in the center of inactive SRPs',
+    showExceededBytecode: 'Show a red highlight over bots that exceeded their bytecode limit',
     showMapXY: 'Show X,Y when hovering a tile',
     focusRobotTurn: 'Focus the robot when performing their turn during turn-stepping mode',
     enableFancyPaint: 'Enable fancy paint rendering',

client/src/components/game/tournament-renderer/tournament-renderer.tsx

@@ -19,7 +19,7 @@ export const TournamentRenderer: React.FC = () => {
     return (
         <div className="w-full h-screen relative">
             <Space ref={spaceRef} treatTwoFingerTrackPadGesturesLikeTouch={false}>
-                {tournament && spaceRef.current ? (
+                {tournament ? (
                     <TournamentTree
                         tournament={tournament}
                         tournamentState={tournamentState}
@@ -38,7 +38,7 @@ export const TournamentRenderer: React.FC = () => {
 interface TournamentTreeProps {
     tournament: Tournament
     tournamentState: TournamentState
-    spaceRef: Space
+    spaceRef: Space | null
     winnerStart: number
     loserStart: number
 }
@@ -85,7 +85,7 @@ const TournamentTree: React.FC<TournamentTreeProps> = (props) => {
 interface TournamentGameWrapperProps {
     game: TournamentGame
     tournamentState: TournamentState
-    spaceRef: Space
+    spaceRef: Space | null
     winnerStart: number
     loserStart: number
 }
@@ -106,7 +106,7 @@ const TournamentGameWrapper: React.FC<TournamentGameWrapperProps> = (props) => {
             if (!wrapperRef.current) return
 
             const wrapperRect = wrapperRef.current.getBoundingClientRect()
-            const scale = props.spaceRef.viewPort?.zoomFactor ?? 1
+            const scale = props.spaceRef?.viewPort?.zoomFactor ?? 1
             const startX = wrapperRect.x + wrapperRect.width / 2
             const startY = wrapperRect.y + wrapperRect.height - 17.45
 

client/src/components/sidebar/sidebar.tsx

@@ -74,6 +74,10 @@ export const Sidebar: React.FC = () => {
     React.useEffect(() => {
         if (localTournament) {
             setPage(PageType.TOURNAMENT)
+            context.setState((prevState) => ({
+                ...prevState,
+                tournament: new Tournament([])
+            }))
         }
     }, [localTournament])
 

client/src/components/sidebar/tournament/tournament.tsx

@@ -81,7 +81,6 @@ export const TournamentPage: React.FC<TournamentPageProps> = ({ open }) => {
         if (!tournament) return
 
         // Reset state if it was not overridden
-        console.log(tournamentShowLosers)
         context.setState((prevState) => ({
             ...prevState,
             tournamentState: {

client/src/constants.ts

@@ -1,4 +1,4 @@
-export const CLIENT_VERSION = '1.4.3'
+export const CLIENT_VERSION = '2.0.0'
 export const SPEC_VERSION = '1'
 export const BATTLECODE_YEAR: number = 2025
 export const MAP_SIZE_RANGE = {
@@ -21,7 +21,32 @@ export const DIRECTIONS: Record<number, Array<number>> = {
     8: [-1, 1]
 }
 
-export const ENGINE_BUILTIN_MAP_NAMES: string[] = ['DefaultSmall', 'DefaultMedium', 'DefaultLarge', 'DefaultHuge']
+export const ENGINE_BUILTIN_MAP_NAMES: string[] = [
+    // Default
+    'DefaultSmall',
+    'DefaultMedium',
+    'DefaultLarge',
+    'DefaultHuge',
+
+    // Sprint 1
+    'Justice',
+    'memstore',
+    'Mirage',
+    'MoneyTower',
+    'Restart',
+    'Thirds',
+    'catface',
+    'Fossil',
+    'gardenworld',
+    'Gears',
+    'Money',
+    'Racetrack',
+    'SaltyPepper',
+    'SMILE',
+    'TargetPractice',
+    'UglySweater',
+    'UnderTheSea'
+]
 
 export const TEAM_COLOR_NAMES = ['Silver', 'Gold']
 

client/src/playback/Actions.ts

@@ -341,18 +341,27 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
     },
     [schema.Action.TransferAction]: class TransferAction extends Action<schema.TransferAction> {
         apply(round: Round): void {
+            const src = round.bodies.getById(this.robotId)
             const amount = this.actionData.amount()
 
             if (amount === 0) {
                 /* ! SCUFFED SPECIAL CASE: Resource pattern completed ! */
+                const center = round.map.indexToLocation(this.actionData.id())
+                if (!round.map.resourcePatterns.find((srp) => srp.center.x === center.x && srp.center.y === center.y)) {
+                    round.map.resourcePatterns.push({
+                        center,
+                        teamId: src.team.id,
+                        createRound: round.roundNumber
+                    })
+                }
+
                 return
             }
 
-            const src = round.bodies.getById(this.robotId)
             const dst = round.bodies.getById(this.actionData.id())
 
-            src.paint -= amount
-            dst.paint += amount
+            src.paint = Math.max(src.paint - amount, 0)
+            dst.paint = Math.min(dst.paint + amount, dst.maxPaint)
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             if (this.actionData.amount() === 0) {

client/src/playback/Bodies.ts

@@ -272,6 +272,16 @@ export class Body {
         if (focused || config.showPaintBars) {
             this.drawPaintBar(match, ctx, focused || config.showHealthBars)
         }
+
+        // Draw bytecode overage indicator
+        if (config.showExceededBytecode && this.bytecodesUsed >= this.metadata.bytecodeLimit()) {
+            const pos = this.getInterpolatedCoords(match)
+            const renderCoords = renderUtils.getRenderCoords(pos.x, pos.y, match.currentRound.map.staticMap.dimension)
+            ctx.globalAlpha = 0.5
+            ctx.fillStyle = 'red'
+            ctx.fillRect(renderCoords.x, renderCoords.y, 1, 1)
+            ctx.globalAlpha = 1.0
+        }
     }
 
     public draw(match: Match, ctx: CanvasRenderingContext2D): void {
@@ -494,7 +504,9 @@ export class Body {
             `Location: (${this.pos.x}, ${this.pos.y})`,
             `Move Cooldown: ${this.moveCooldown}`,
             `Action Cooldown: ${this.actionCooldown}`,
-            `Bytecodes Used: ${this.bytecodesUsed}`
+            `Bytecodes Used: ${this.bytecodesUsed}${
+                this.bytecodesUsed >= this.metadata.bytecodeLimit() ? ' <EXCEEDED!>' : ''
+            }`
         ]
         if (this.indicatorString != '') {
             defaultInfo.push(`Indicator: ${this.indicatorString}`)

client/src/playback/Brushes.ts

@@ -212,7 +212,8 @@ export class PaintBrush extends SymmetricMapEditorBrush<CurrentMap> {
             const pos = this.map.indexToLocation(idx)
             const ruin = this.map.staticMap.ruins.find((r) => r.x === pos.x && r.y === pos.y)
             const wall = this.map.staticMap.walls[idx]
-            if (ruin || wall) return true
+            const body = this.bodies.getBodyAtLocation(pos.x, pos.y)
+            if (body || ruin || wall) return true
             this.map.paint[idx] = value
             this.map.staticMap.initialPaint[idx] = this.map.paint[idx]
         }

client/src/playback/Map.ts

@@ -25,10 +25,17 @@ type SchemaPacket = {
     ruinsOffset: number
 }
 
+type ResourcePatternData = {
+    teamId: number
+    center: Vector
+    createRound: number
+}
+
 export class CurrentMap {
     public readonly staticMap: StaticMap
     public readonly paint: Int8Array
     public readonly markers: [Int8Array, Int8Array] // Each team has markers
+    public readonly resourcePatterns: ResourcePatternData[]
 
     get width(): number {
         return this.dimension.width
@@ -48,12 +55,16 @@ export class CurrentMap {
             this.staticMap = from
             this.paint = new Int8Array(from.initialPaint)
             this.markers = [new Int8Array(this.width * this.height), new Int8Array(this.width * this.height)]
+            this.resourcePatterns = []
         } else {
             // Create current map from current map (copy)
 
             this.staticMap = from.staticMap
             this.paint = new Int8Array(from.paint)
             this.markers = [new Int8Array(from.markers[0]), new Int8Array(from.markers[1])]
+
+            // Assumes ResourcePatternData is immutable
+            this.resourcePatterns = [...from.resourcePatterns]
         }
     }
 
@@ -78,9 +89,34 @@ export class CurrentMap {
     }
 
     /**
-     * Mutates this currentMap to reflect the given turn.
+     * Mutates this currentMap to reflect the given round.
      */
-    applyTurnDelta(turn: schema.Turn): void {}
+    applyRoundDelta(round: Round, delta: schema.Round | null): void {
+        // Update resource patterns and remove if they have been broken
+        const patternMask = 28873275
+        for (let i = 0; i < this.resourcePatterns.length; i++) {
+            const srp = this.resourcePatterns[i]
+            let patternIdx = 0
+            let patternFailed = false
+            for (let y = srp.center.y + 2; y >= srp.center.y - 2; y--) {
+                for (let x = srp.center.x - 2; x <= srp.center.x + 2; x++) {
+                    const idx = this.locationToIndex(x, y)
+                    const expectedPaint = ((patternMask >> patternIdx) & 1) + (srp.teamId - 1) * 2 + 1
+                    const actualPaint = this.paint[idx]
+                    if (actualPaint !== expectedPaint) {
+                        this.resourcePatterns[i] = this.resourcePatterns[this.resourcePatterns.length - 1]
+                        this.resourcePatterns.pop()
+                        i--
+                        patternFailed = true
+                        break
+                    }
+                    patternIdx++
+                }
+
+                if (patternFailed) break
+            }
+        }
+    }
 
     draw(
         match: Match,
@@ -152,6 +188,32 @@ export class CurrentMap {
                 }
             }
         }
+
+        if (config.showSRPOutlines || config.showSRPText) {
+            ctx.globalAlpha = 1
+            ctx.lineWidth = 0.03
+            this.resourcePatterns.forEach((srp) => {
+                const topLeftCoords = renderUtils.getRenderCoords(srp.center.x - 2, srp.center.y + 2, this.dimension)
+                const roundsRemaining = Math.max(srp.createRound + 50 - match.currentRound.roundNumber, -1)
+                if (roundsRemaining >= 0 && config.showSRPText) {
+                    const label = roundsRemaining.toString()
+                    ctx.fillStyle = 'white'
+                    ctx.textAlign = 'right'
+                    ctx.font = '1px monospace'
+                    ctx.shadowColor = 'black'
+                    ctx.shadowBlur = 4
+                    ctx.scale(0.4, 0.4)
+                    ctx.fillText(label, (topLeftCoords.x + 3) * 2.5, (topLeftCoords.y + 2.5) * 2.5)
+                    ctx.scale(2.5, 2.5)
+                    ctx.shadowColor = ''
+                    ctx.shadowBlur = 0
+                    ctx.textAlign = 'start'
+                } else if (roundsRemaining === -1 && config.showSRPOutlines) {
+                    ctx.strokeStyle = teamColors[srp.teamId - 1]
+                    ctx.strokeRect(topLeftCoords.x, topLeftCoords.y, 5, 5)
+                }
+            })
+        }
     }
 
     getTooltipInfo(square: Vector, match: Match): string[] {
@@ -163,6 +225,7 @@ export class CurrentMap {
         const paint = this.paint[schemaIdx]
         const wall = this.staticMap.walls[schemaIdx]
         const ruin = this.staticMap.ruins.find((r) => r.x === square.x && r.y === square.y)
+        const srp = this.resourcePatterns.find((r) => r.center.x === square.x && r.center.y === square.y)
         const markerA = this.markers[0][schemaIdx]
         const markerB = this.markers[1][schemaIdx]
 
@@ -186,6 +249,14 @@ export class CurrentMap {
         if (ruin) {
             info.push('Ruin')
         }
+        if (srp) {
+            const roundsRemaining = Math.max(srp.createRound + 50 - match.currentRound.roundNumber, 0)
+            if (roundsRemaining === 0) {
+                info.push(`${TEAM_COLOR_NAMES[srp.teamId - 1]} SRP Center (Active)`)
+            } else {
+                info.push(`${TEAM_COLOR_NAMES[srp.teamId - 1]} SRP Center (${roundsRemaining} Rounds Left)`)
+            }
+        }
 
         return info
     }

client/src/playback/Round.ts

@@ -59,6 +59,7 @@ export default class Round {
 
         this.roundNumber += 1
 
+        this.map.applyRoundDelta(this, this.currentDelta)
         this.stat.applyRoundDelta(this, this.currentDelta)
 
         this.initialRoundState = null
@@ -125,7 +126,6 @@ export default class Round {
 
         this.bodies.clearIndicators(turn.robotId())
 
-        this.map.applyTurnDelta(turn)
         this.actions.applyTurnDelta(this, turn)
         this.bodies.applyTurnDelta(this, turn)