Huge bugfix release: merge

Huge bugfix release

Author: compiler64

.github/workflows/release-engine.yml

@@ -14,7 +14,7 @@ env:
   RELEASE_ARTIFACT_ID: battlecode26
 
   # IS_PUBLIC is whether to release deployments publicly. Set to exactly the text "YES" to do so.
-  IS_PUBLIC: YES
+  IS_PUBLIC: NO
 
 jobs:
   release-java:

client/src/components/sidebar/map-editor/MapGenerator.ts

@@ -3,7 +3,7 @@ import Game, { Team } from '../../../playback/Game'
 import Match from '../../../playback/Match'
 import { CurrentMap, StaticMap } from '../../../playback/Map'
 import Round from '../../../playback/Round'
-import Bodies from '../../../playback/Bodies'
+import Bodies, { Body } from '../../../playback/Bodies'
 import { BATTLECODE_YEAR, DIRECTIONS, TEAM_COLOR_NAMES } from '../../../constants'
 import { nativeAPI } from '../runner/native-api-wrapper'
 import { Vector } from '../../../playback/Vector'
@@ -180,6 +180,13 @@ function verifyMap(map: CurrentMap, bodies: Bodies): string {
                 `>= 3 away`
             )
         }
+
+        if (body.robotType === schema.RobotType.CAT) {
+            if (!map.staticMap.catWaypoints.get(body.id) || map.staticMap.catWaypoints.get(body.id)?.length === 0) {
+                return `Cat with id ${body.id} has no waypoints`
+            }
+        }
+
     }
 
     return ''

client/src/playback/Actions.ts

@@ -183,15 +183,40 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
         }
     },
     [schema.Action.RatNap]: class RatNapAction extends Action<schema.RatNap> {
+        private static readonly OFFSET = { x: -0.35, y: 0 }
         apply(round: Round): void {
             // move the target onto the source adjust target's size using scale factor
             const src = round.bodies.getById(this.robotId)
             const target = round.bodies.getById(this.actionData.id()) // rat getting napped
+
+            target.lastPos = { ...target.pos }
+            target.pos = { x: src.pos.x + RatNapAction.OFFSET.x, y: src.pos.y + RatNapAction.OFFSET.y }
+            target.size = 0.6
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             //target rat moves onto src rat, circle around carried group thing
-            const src = match.currentRound.bodies.getById(this.robotId)
-            const target = match.currentRound.bodies.getById(this.actionData.id()) // rat getting napped
+            const src = match.currentRound.bodies.getById(this.robotId) 
+            const srcCoords = renderUtils.getRenderCoords(src.pos.x, src.pos.y, match.map.dimension, true)
+            const t = match.getInterpolationFactor()
+            const bump = Math.sin(t * Math.PI * 8) * 0.03
+            const half = 0.5 + bump
+            const radius = 0.08 // corner radius
+
+            ctx.save()
+            ctx.shadowBlur = 12
+            ctx.shadowColor = src.team.color
+            ctx.strokeStyle = src.team.color
+            ctx.globalAlpha = 0.7
+            ctx.lineWidth = 0.04
+            ctx.beginPath()
+            ctx.moveTo(srcCoords.x - half + radius, srcCoords.y - half)
+            ctx.arcTo(srcCoords.x + half, srcCoords.y - half, srcCoords.x + half, srcCoords.y + half, radius)
+            ctx.arcTo(srcCoords.x + half, srcCoords.y + half, srcCoords.x - half, srcCoords.y + half, radius)
+            ctx.arcTo(srcCoords.x - half, srcCoords.y + half, srcCoords.x - half, srcCoords.y - half, radius)
+            ctx.arcTo(srcCoords.x - half, srcCoords.y - half, srcCoords.x + half, srcCoords.y - half, radius)
+            ctx.stroke()
+            ctx.restore()
+            ctx.restore() 
         }
     },
     [schema.Action.RatCollision]: class RatCollisionAction extends Action<schema.RatCollision> {
@@ -200,6 +225,33 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const src = match.currentRound.bodies.getById(this.robotId)
             const pos = match.map.indexToLocation(this.actionData.loc())
             const coords = renderUtils.getRenderCoords(pos.x, pos.y, match.map.dimension, true)
+            const t = match.getInterpolationFactor()
+
+            ctx.save()
+            // dusty base color that fills the cell and fades out
+            const baseAlpha = 0.4 * (1 - t)
+            ctx.fillStyle = `rgba(150,130,110,${baseAlpha})`
+            ctx.fillRect(coords.x - 0.5, coords.y - 0.5, 1, 1)
+
+            // these are the random rocks that fill the cell
+            const rockCount = 10
+            for (let i = 0; i < rockCount; i++) {
+                const rx = coords.x - 0.5 + Math.random() * 1
+                const ry = coords.y - 0.5 + Math.random() * 1
+                const size = 0.08 + Math.random() * 0.15
+                const shade = 90 + Math.floor(Math.random() * 50)
+                const alpha = 0.7 * (1 - t)
+                ctx.fillStyle = `rgba(${shade},${shade - 10},${shade - 20},${alpha})`
+                ctx.fillRect(rx, ry, size, size)
+            }
+
+            // ring outside the cell (also fades out)
+            ctx.strokeStyle = src.team.color
+            ctx.globalAlpha = 0.35 * (1 - t)
+            ctx.lineWidth = 0.04
+            ctx.strokeRect(coords.x - 0.5, coords.y - 0.5, 1, 1)
+            ctx.restore()
+
         }
     },
     [schema.Action.PlaceDirt]: class PlaceDirtAction extends Action<schema.PlaceDirt> {
@@ -284,8 +336,8 @@ export const ACTION_DEFINITIONS: Record<schema.Action, typeof Action<ActionUnion
             const target = round.bodies.getById(this.actionData.id())
             const amount = this.actionData.amount()
 
-            body.cheese -= amount
-            target.cheese += amount
+            body.cheese -= Math.min(body.cheese, amount)
+            target.cheese += Math.min(body.cheese, amount)
         }
         draw(match: Match, ctx: CanvasRenderingContext2D): void {
             const srcBody = match.currentRound.bodies.getById(this.robotId)

client/src/playback/Bodies.ts

@@ -99,10 +99,8 @@ export default class Bodies {
 
         return body
     }
+
     checkBodyCollisionAtLocation(type: schema.RobotType, pos: Vector): boolean {
-        const bodyClass = BODY_DEFINITIONS[type] ?? assert.fail(`Body type ${type} not found in BODY_DEFINITIONS`)
-        const tempBody = new bodyClass(this.game, pos, this.game.getTeamByID(1), 0)
-        const bodySize = tempBody.size
         const occupiedSpaces: Vector[] = []
 
         for (const otherBody of this.bodies.values()) {
@@ -154,6 +152,34 @@ export default class Bodies {
         return false
     }
 
+    checkBodyOutofBoundsAtLocation(type: schema.RobotType, pos: Vector): boolean {
+        const map = this.game.currentMatch?.map
+        if(!map) return false
+
+        const dimension = map.dimension
+        const occupiedSpaces: Vector[] = []
+
+        if (type == schema.RobotType.RAT) {
+            if(!map.inBounds(pos.x, pos.y)) return false
+        }
+        if (type == schema.RobotType.CAT) {
+            for (let xoff = 0; xoff <= 1; xoff++) {
+                for (let yoff = 0; yoff <= 1; yoff++) {
+                    if(!map.inBounds(pos.x+xoff, pos.y+yoff)) return false
+                }
+            }
+        }
+        if (type == schema.RobotType.RAT_KING) {
+            for (let xoff = -1; xoff <= 1; xoff++) {
+                for (let yoff = -1; yoff <= 1; yoff++) {
+                    if(!map.inBounds(pos.x+xoff, pos.y+yoff)) return false
+                }
+            }
+        }
+        
+        return true
+    }
+
     markBodyAsDead(id: number): void {
         const body = this.getById(id)
         body.dead = true

client/src/playback/Brushes.ts

@@ -546,7 +546,12 @@ export class CatBrush extends SymmetricMapEditorBrush<StaticMap> {
         const add = (x: number, y: number, team: Team) => {
             const pos = { x, y }
 
-            if (this.bodies.checkBodyCollisionAtLocation(schema.RobotType.CAT, pos)) return null
+            if (
+                this.bodies.checkBodyCollisionAtLocation(schema.RobotType.CAT, pos)||
+                !this.bodies.checkBodyOutofBoundsAtLocation(schema.RobotType.CAT, pos)
+            ) {
+                return null
+            }
 
             const id = this.bodies.getNextID()
             this.bodies.spawnBodyFromValues(id, schema.RobotType.CAT, team, pos, 0, robotOne ? 0 : 1)
@@ -650,7 +655,8 @@ export class RatKingBrush extends SymmetricMapEditorBrush<StaticMap> {
             const pos = { x, y }
             if (
                 this.bodies.getBodyAtLocation(x, y) ||
-                this.bodies.checkBodyCollisionAtLocation(schema.RobotType.RAT_KING, pos)
+                this.bodies.checkBodyCollisionAtLocation(schema.RobotType.RAT_KING, pos) ||
+                !this.bodies.checkBodyOutofBoundsAtLocation(schema.RobotType.RAT_KING, pos)
             ) {
                 return null
             }

client/src/playback/GameRenderer.ts

@@ -185,7 +185,7 @@ class GameRendererClass {
         const ctx = this.ctx(CanvasLayers.Background)
         const match = GameRunner.match
         if (!match || !ctx) return
-        match.currentRound.map.staticMap.draw(ctx)
+        match.currentRound.map.staticMap.draw(ctx, GameConfig.config)
         this.render()
     }
 

client/src/playback/Map.ts

@@ -41,7 +41,7 @@ export class CurrentMap {
     public readonly markers: [Int8Array, Int8Array] // Each team has markers
     public readonly ratTrapData: Int8Array
     public readonly catTrapData: Int8Array
-    public readonly cheeseData: Int8Array
+    public readonly cheeseData: Int32Array
     public readonly resourcePatterns: ResourcePatternData[]
 
     get width(): number {
@@ -60,7 +60,7 @@ export class CurrentMap {
 
             this.staticMap = from
             this.dirt = new Int8Array(from.initialDirt)
-            this.cheeseData = new Int8Array(from.cheese)
+            this.cheeseData = new Int32Array(from.cheese)
             this.markers = [new Int8Array(this.width * this.height), new Int8Array(this.width * this.height)]
             this.resourcePatterns = []
             this.ratTrapData = new Int8Array(this.width * this.height)
@@ -70,7 +70,7 @@ export class CurrentMap {
 
             this.staticMap = from.staticMap
             this.dirt = new Int8Array(from.dirt)
-            this.cheeseData = new Int8Array(from.cheeseData)
+            this.cheeseData = new Int32Array(from.cheeseData)
             this.markers = [new Int8Array(from.markers[0]), new Int8Array(from.markers[1])]
 
             // Assumes ResourcePatternData is immutable
@@ -284,6 +284,8 @@ export class CurrentMap {
 
         const dirt = this.dirt[schemaIdx]
         const wall = this.staticMap.walls[schemaIdx]
+        const ratTrap = this.ratTrapData[schemaIdx]
+        const catTrap = this.catTrapData[schemaIdx]
         const cheeseMine = this.staticMap.cheeseMines.find((r) => r.x === square.x && r.y === square.y)
         const cheese = this.cheeseData[schemaIdx]
         const srp = this.resourcePatterns.find((r) => r.center.x === square.x && r.center.y === square.y)
@@ -313,6 +315,12 @@ export class CurrentMap {
         if (dirt) {
             info.push('Dirt')
         }
+        if (ratTrap) {
+            info.push('Rat Trap')
+        }
+        if (ratTrap) {
+            info.push('Cat Trap')
+        }
         if (cheese) {
             info.push(`Cheese: ${cheese}`)
         }
@@ -552,7 +560,7 @@ export class StaticMap {
         }
     }
 
-    draw(ctx: CanvasRenderingContext2D) {
+    draw(ctx: CanvasRenderingContext2D, config: ClientConfig) {
         // Fill background
         ctx.fillStyle = Colors.TILES_COLOR.get()
         ctx.fillRect(
@@ -569,10 +577,15 @@ export class StaticMap {
 
                 // Render rounded (clipped) wall
                 if (this.walls[schemaIdx]) {
-                    renderUtils.renderRounded(ctx, i, j, this, this.walls, () => {
+                    if (config.enableFancyPaint) {
+                        renderUtils.renderRounded(ctx, i, j, this, this.walls, () => {
+                            ctx.fillStyle = Colors.WALLS_COLOR.get()
+                            ctx.fillRect(coords.x, coords.y, 1.0, 1.0)
+                        })
+                    } else {
                         ctx.fillStyle = Colors.WALLS_COLOR.get()
                         ctx.fillRect(coords.x, coords.y, 1.0, 1.0)
-                    })
+                    }
                 }
 
                 // Draw grid

crossplay_temp/started_java.txt

@@ -76,7 +76,7 @@ jar {
 
 javadoc {
   includes = ["**/common/**"]
-  options.windowTitle = "Battlecode 2025"
+  options.windowTitle = "Battlecode 2026"
   options.classpath = sourceSets.main.compileClasspath as List
   options.doclet = "jdk.javadoc.doclet.StandardDoclet"
   options.taglets = ["battlecode.doc.CostlyMethodTaglet"]

engine/build.gradle

@@ -130,7 +130,7 @@ public interface RobotController {
      *
      * @battlecode.doc.costlymethod
      */
-    public int getGlobalCheese();
+    int getGlobalCheese();
 
     /**
      * Returns the amount of cheese the robot has access to.
@@ -139,7 +139,7 @@ public interface RobotController {
      *
      * @battlecode.doc.costlymethod
      */
-    public int getAllCheese();
+    int getAllCheese();
 
     /**
      * Returns the amount of dirt that this robot's team has.
@@ -1034,5 +1034,3 @@ void setIndicatorLine(MapLocation startLoc, MapLocation endLoc, int red, int gre
      */
     void setTimelineMarker(String label, int red, int green, int blue);
 }
-// TODO: update bytecode costs, particularly for new methods + methods that got
-// renamed from last year