Add PaintVolley arena

Author: john-b-yang

codeclash/arenas/__init__.py

@@ -15,6 +15,7 @@
 from codeclash.arenas.halite2.halite2 import Halite2Arena
 from codeclash.arenas.halite3.halite3 import Halite3Arena
 from codeclash.arenas.huskybench.huskybench import HuskyBenchArena
+from codeclash.arenas.paintvolley.paintvolley import PaintVolleyArena
 from codeclash.arenas.robocode.robocode import RoboCodeArena
 from codeclash.arenas.robotrumble.robotrumble import RobotRumbleArena
 from codeclash.arenas.scml.scml import SCMLOneShotArena
@@ -36,6 +37,7 @@
     Halite2Arena,
     Halite3Arena,
     HuskyBenchArena,
+    PaintVolleyArena,
     RoboCodeArena,
     RobotRumbleArena,
     SCMLOneShotArena,

codeclash/arenas/paintvolley/PaintVolley.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install Python 3.10, pip, and prerequisites
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+    curl ca-certificates python3.10 python3.10-venv \
+    python3-pip python-is-python3 wget git build-essential jq curl locales \
+ && rm -rf /var/lib/apt/lists/*
+
+# Clone PaintVolley game repository
+RUN git clone https://github.com/CodeClash-ai/PaintVolley.git /workspace \
+    && cd /workspace \
+    && git remote set-url origin https://github.com/CodeClash-ai/PaintVolley.git
+WORKDIR /workspace
+
+# No additional dependencies needed - engine uses only the standard library

codeclash/arenas/paintvolley/__init__.py

@@ -0,0 +1,93 @@
+import re
+
+from codeclash.agents.player import Player
+from codeclash.arenas.arena import CodeArena, RoundStats
+from codeclash.constants import RESULT_TIE
+from codeclash.utils.environment import assert_zero_exit_code
+
+PAINTVOLLEY_LOG = "result.log"
+
+
+class PaintVolleyArena(CodeArena):
+    name: str = "PaintVolley"
+    submission: str = "main.py"
+    description: str = """Your bot (`main.py`) controls a helmet-wearing character in PaintVolley, a
+territory-painting game. Characters patrol the bottom of a rectangular field while balls fly around
+bouncing off all four walls (no gravity). Each tick, every ball paints the tile it is over in its own
+color. Balls start neutral and paint nothing; when a ball lands on your helmet it turns your color and
+bounces upward, so it then paints for you until an opponent steals it. The helmet-contact point sets
+the exit angle (center = straight up, edges = steep), so you aim where paint goes. Most tiles owned
+when the tick budget runs out wins.
+
+Your bot must implement:
+    def get_action(obs: dict) -> str
+
+Return one of: "LEFT", "RIGHT", "JUMP", "JUMP_LEFT", "JUMP_RIGHT", "NONE".
+Invalid/crashing/slow actions are treated as "NONE" for that tick.
+
+`obs` is the full deterministic state each tick: obs["tick"]/["max_ticks"], obs["field"]
+(width/height/cols/rows), obs["rules"] (every physics constant, so you can forward-simulate),
+obs["you"] (id/color), obs["players"] (id, color, x, y, on_ground), obs["balls"]
+(x, y, vx, vy, color where color is the owner id or -1 for neutral), obs["tiles"]
+(tiles[row][col] = owner id or -1), and obs["scores"]. Origin is top-left; up is -y.
+"""
+
+    def __init__(self, config, **kwargs):
+        super().__init__(config, **kwargs)
+        assert len(config["players"]) >= 2, "PaintVolley needs at least two players"
+
+    def execute_round(self, agents: list[Player]) -> None:
+        args = [f"/{agent.name}/{self.submission}" for agent in agents]
+        cmd = (
+            f"python engine.py {' '.join(args)} -r {self.game_config['sims_per_round']} "
+            f"-o {self.log_env} > {self.log_env / PAINTVOLLEY_LOG};"
+        )
+        self.logger.info(f"Running game: {cmd}")
+        assert_zero_exit_code(self.environment.execute(cmd))
+
+    def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
+        with open(self.log_round(round_num) / PAINTVOLLEY_LOG) as f:
+            round_log = f.read()
+        lines = round_log.split("FINAL_RESULTS")[-1].splitlines()
+
+        # Engine prints: "Bot_<i>: <wins> games won, <avg> avg_tiles (<name>)".
+        # Score a bot by games won (1-indexed bot id maps to agents[id-1]).
+        scores: dict[str, float] = {}
+        for line in lines:
+            match = re.search(r"Bot_(\d+):\s+(\d+)\s+games\s+won", line)
+            if match:
+                bot_id = int(match.group(1))
+                wins = int(match.group(2))
+                if 1 <= bot_id <= len(agents):
+                    scores[agents[bot_id - 1].name] = wins
+
+        draw_match = re.search(r"Draws:\s+(\d+)", round_log)
+        if draw_match and int(draw_match.group(1)) > 0:
+            scores[RESULT_TIE] = int(draw_match.group(1))
+
+        if scores:
+            real = {k: v for k, v in scores.items() if k != RESULT_TIE}
+            max_score = max(real.values()) if real else 0
+            winners = [k for k, v in real.items() if v == max_score]
+            stats.winner = winners[0] if len(winners) == 1 else RESULT_TIE
+        else:
+            stats.winner = "unknown"
+
+        stats.scores = scores
+        for player, score in scores.items():
+            if player != RESULT_TIE:
+                stats.player_stats[player].score = score
+
+    def validate_code(self, agent: Player) -> tuple[bool, str | None]:
+        if self.submission not in agent.environment.execute("ls")["output"]:
+            return False, f"No {self.submission} file found in the root directory"
+
+        bot_content = agent.environment.execute(f"cat {self.submission}")["output"]
+        if "def get_action(" not in bot_content:
+            return (
+                False,
+                f"{self.submission} must define a get_action(obs) function. "
+                "See the game description for the required signature.",
+            )
+
+        return True, None

codeclash/arenas/paintvolley/paintvolley.py

@@ -0,0 +1,170 @@
+"""PaintVolley replay renderer.
+
+Parses a per-game ``sim_*.json`` written by the engine into one frame per recorded
+tick and renders the painted tile grid, the flying balls, and the helmet characters
+patrolling the bottom, with a live scoreboard.
+
+The JSON format (see engine.py ``write_replay``)::
+
+    {"cols":32, "rows":24, "num_players":2, "max_ticks":1500,
+     "names":["p1","p2"], "winner": 0 | null, "final_scores": {"0":399,"1":255},
+     "frames":[{"tick":0, "grid":["...01.",...], "balls":[{"x","y","c"}],
+                "players":[{"x","y","id"}], "scores":{"0":n,"1":m}}, ...]}
+
+Each frame's ``grid`` is one string per row; each char is the tile owner encoded in
+base36 (``'0'``..), or ``'.'`` for a neutral (unpainted) tile. Ball/player ``color``
+values are player ids (0-based) or ``-1`` for an unclaimed ball. ``winner`` is the
+winning player id, or ``null`` for a draw.
+"""
+
+from __future__ import annotations
+
+import json
+
+from codeclash.replay.base import ReplayData, ReplayRenderer
+
+DRAW_JS = """
+const ARENA = (function(){
+  // Visual constants mirror the engine (BALL_RADIUS, PLAYER_HALF_WIDTH, PLAYER_HEIGHT).
+  const CELL = 18, BALL_R = 0.6, BODY_HW = 0.9, PH = 2.5;
+  // Player palette (index by player id); neutral tiles use the dark background.
+  const PAL = ['#e5484d','#4593ff','#46a758','#f5d90a','#8e4ec6','#f76b15','#e93d82','#12a594'];
+  const NEUTRAL = '#161b22';
+  let COLS, ROWS;
+  function col(c){ return c < 0 ? NEUTRAL : PAL[c % PAL.length]; }
+  function setup(cv, G){
+    COLS = G.w; ROWS = G.h;
+    cv.width = COLS * CELL; cv.height = ROWS * CELL;
+  }
+  function draw(ctx, cv, G, i){
+    const f = G.frames[i];
+    // background
+    ctx.fillStyle = NEUTRAL; ctx.fillRect(0, 0, cv.width, cv.height);
+    // painted tiles (each row is a string; '.' = neutral, else base36 owner id)
+    for(let r=0;r<ROWS;r++){
+      const row = f.grid[r];
+      for(let c=0;c<COLS;c++){
+        const ch = row[c];
+        if(ch !== '.'){ ctx.fillStyle = col(parseInt(ch, 36)); ctx.fillRect(c*CELL, r*CELL, CELL, CELL); }
+      }
+    }
+    // faint grid lines
+    ctx.strokeStyle = 'rgba(255,255,255,0.05)'; ctx.lineWidth = 1;
+    for(let c=0;c<=COLS;c++){ ctx.beginPath(); ctx.moveTo(c*CELL,0); ctx.lineTo(c*CELL,cv.height); ctx.stroke(); }
+    for(let r=0;r<=ROWS;r++){ ctx.beginPath(); ctx.moveTo(0,r*CELL); ctx.lineTo(cv.width,r*CELL); ctx.stroke(); }
+    // players — each a distinct fixed-size character (helmet head + body) whose feet
+    // rest at helmet_y + PH. When it jumps, helmet_y decreases so the whole figure
+    // lifts off the floor (a gap opens under its feet) instead of stretching. A shadow
+    // on the floor shrinks with height to sell the jump.
+    const FLOOR = ROWS*CELL;
+    (f.players||[]).forEach(p=>{
+      const px = p.x*CELL, py = p.y*CELL, bw = BODY_HW*2*CELL, cc = col(p.id);
+      const feet = py + PH*CELL;                 // fixed offset below the helmet
+      const lift = Math.max(0, FLOOR - feet);    // how far off the floor (px)
+      // floor shadow (shrinks as the character rises)
+      const sw = (bw/2) * (1 - Math.min(0.6, lift/(6*CELL)));
+      ctx.fillStyle = 'rgba(0,0,0,0.28)';
+      ctx.beginPath(); ctx.ellipse(px, FLOOR-3, Math.max(3, sw), 3.5, 0, 0, 7); ctx.fill();
+      // body (fixed height, from just under the head down to the feet)
+      const hr = bw/2, hcy = py + hr*0.85;
+      ctx.strokeStyle = 'rgba(0,0,0,0.55)'; ctx.lineWidth = 2; ctx.fillStyle = cc;
+      ctx.beginPath(); ctx.roundRect(px-bw/2, hcy, bw, Math.max(6, feet-hcy), Math.min(7, bw/2)); ctx.fill(); ctx.stroke();
+      // head + helmet rim
+      ctx.beginPath(); ctx.arc(px, hcy, hr, 0, 7); ctx.fillStyle = cc; ctx.fill(); ctx.stroke();
+      ctx.strokeStyle = 'rgba(0,0,0,0.3)'; ctx.lineWidth = 3;
+      ctx.beginPath(); ctx.arc(px, hcy, hr, Math.PI, 2*Math.PI); ctx.stroke();
+      // eyes
+      ctx.fillStyle = '#fff';
+      ctx.beginPath(); ctx.arc(px-hr*0.33, hcy+2, 2.4, 0, 7); ctx.arc(px+hr*0.33, hcy+2, 2.4, 0, 7); ctx.fill();
+      ctx.fillStyle = '#111';
+      ctx.beginPath(); ctx.arc(px-hr*0.33, hcy+2, 1.1, 0, 7); ctx.arc(px+hr*0.33, hcy+2, 1.1, 0, 7); ctx.fill();
+    });
+    // balls — glow ring + body + highlight so the color (and who owns it) reads clearly
+    (f.balls||[]).forEach(b=>{
+      const bx = b.x*CELL, by = b.y*CELL, br = BALL_R*CELL, cc = b.c < 0 ? '#c9d1d9' : col(b.c);
+      ctx.globalAlpha = 0.25; ctx.fillStyle = cc;
+      ctx.beginPath(); ctx.arc(bx, by, br+3, 0, 7); ctx.fill();
+      ctx.globalAlpha = 1;
+      ctx.beginPath(); ctx.arc(bx, by, br, 0, 7); ctx.fillStyle = cc; ctx.fill();
+      ctx.strokeStyle = '#0d1117'; ctx.lineWidth = 2; ctx.stroke();
+      ctx.beginPath(); ctx.arc(bx-br*0.3, by-br*0.3, br*0.35, 0, 7); ctx.fillStyle = 'rgba(255,255,255,0.75)'; ctx.fill();
+    });
+  }
+  function side(G, i){
+    const f = G.frames[i], NM = G.names || [], total = COLS*ROWS;
+    const done = i === G.frames.length - 1;
+    let rows = '';
+    const n = G.num_players || NM.length;
+    for(let p=0;p<n;p++){
+      const s = (f.scores && (f.scores[p] != null ? f.scores[p] : f.scores[String(p)])) || 0;
+      const pct = total ? (100*s/total).toFixed(1) : '0.0';
+      rows += `<div class="team"><div class="tname">`
+        + `<span class="sw" style="background:${col(p)}"></span>`
+        + `${NM[p] || ('player'+(p+1))}</div>`
+        + `<div class="stat"><span>tiles</span><b>${s}</b></div>`
+        + `<div class="stat"><span>share</span><b>${pct}%</b></div></div>`;
+    }
+    const res = done ? (G.draw ? 'TIE' : (G.winner || '\\u2014')) : '';
+    return rows
+      + `<div class="stat"><span>tick</span><b>${f.turn} / ${G.max_ticks||''}</b></div>`
+      + (done ? `<div class="stat"><span>result</span><b>${res}</b></div>` : '');
+  }
+  return {setup, draw, side};
+})();
+"""
+
+
+class PaintVolleyReplayer(ReplayRenderer):
+    arena = "PaintVolley"
+    sim_glob = "sim_*.json"
+    DRAW_JS = DRAW_JS
+
+    def peek_winner(self, raw: bytes, players: list[dict] | None = None) -> tuple[str | None, bool] | None:
+        """Cheap per-sim winner for the index (reads the top-level ``winner`` without
+        touching the frames). ``winner`` is a 0-based player id, or null for a draw."""
+        log = json.loads(raw.decode(errors="replace"))
+        win = log.get("winner")
+        if win is None:
+            return (None, True)
+        names = list(log.get("names", []))
+        if players:
+            names = [p.get("name", names[i] if i < len(names) else f"player{i + 1}") for i, p in enumerate(players)]
+        name = names[win] if isinstance(win, int) and 0 <= win < len(names) else str(win)
+        return (name, False)
+
+    def parse(self, raw: bytes, players: list[dict] | None = None) -> ReplayData:
+        log = json.loads(raw.decode(errors="replace"))
+        cols = log.get("cols", 32)
+        rows = log.get("rows", 24)
+        n = log.get("num_players", 2)
+
+        # Prefer the tournament's real player names; fall back to what the engine recorded.
+        names = list(log.get("names", []))
+        if players:
+            names = [p.get("name", names[i] if i < len(names) else f"player{i + 1}") for i, p in enumerate(players)]
+        while len(names) < n:
+            names.append(f"player{len(names) + 1}")
+
+        frames = [
+            {
+                "turn": fr.get("tick", idx),
+                "grid": fr["grid"],
+                "balls": fr.get("balls", []),
+                "players": fr.get("players", []),
+                "scores": fr.get("scores", {}),
+            }
+            for idx, fr in enumerate(log.get("frames", []))
+        ]
+
+        win = log.get("winner")
+        draw = win is None
+        winner = None if draw else names[win] if 0 <= win < len(names) else str(win)
+
+        return ReplayData(
+            w=cols,
+            h=rows,
+            frames=frames,
+            winner=winner,
+            draw=draw,
+            extra={"names": names, "num_players": n, "max_ticks": log.get("max_ticks")},
+        )

codeclash/arenas/paintvolley/replay.py

@@ -57,6 +57,10 @@ def get_replayer(arena: str) -> ReplayRenderer | None:
         from codeclash.arenas.gomoku.replay import GomokuReplayer
 
         return GomokuReplayer()
+    if arena == "PaintVolley":
+        from codeclash.arenas.paintvolley.replay import PaintVolleyReplayer
+
+        return PaintVolleyReplayer()
     if arena == "Halite":
         from codeclash.arenas.halite.replay import HaliteReplayer
 
@@ -102,6 +106,20 @@ def _arena_from_name(folder: Path) -> str:
     return parts[1] if len(parts) > 1 else ""
 
 
+def _fill_sim_winners(games: list[GameRef], renderer: ReplayRenderer | None, players: list[dict]) -> None:
+    """Populate each game's per-sim winner via the renderer's cheap ``peek_winner``.
+    Skipped entirely for arenas that don't implement it (avoids extra sim I/O)."""
+    if renderer is None or type(renderer).peek_winner is ReplayRenderer.peek_winner:
+        return
+    for g in games:
+        try:
+            res = renderer.peek_winner(read_sim(g), players)
+        except Exception:
+            res = None
+        if res is not None:
+            g.sim_winner, g.sim_draw = res
+
+
 def load_tournament(folder: Path) -> TournamentInfo:
     """Read a tournament folder: metadata (if present) plus every discoverable game.
 
@@ -139,6 +157,7 @@ def load_tournament(folder: Path) -> TournamentInfo:
         arena = _arena_from_name(folder)
         renderer = get_replayer(arena)
         games = discover_games(folder, renderer.sim_glob) if renderer else []
+        _fill_sim_winners(games, renderer, [])
         return TournamentInfo(
             folder=folder, arena=arena, players=[], rounds=None, sims_per_round=None, round_winners={}, games=games
         )
@@ -158,6 +177,7 @@ def load_tournament(folder: Path) -> TournamentInfo:
     games = discover_games(folder, renderer.sim_glob) if renderer else []
     for g in games:  # attach each game's round winner for the index
         g.winner = round_winners.get(g.round)
+    _fill_sim_winners(games, renderer, players)
 
     return TournamentInfo(
         folder=folder,