|
| 1 | +"""Ants replay renderer. |
| 2 | +
|
| 3 | +Parses a per-game ``sim_*.json`` written by the engine and renders the toroidal grid |
| 4 | +from the spectator's view (no fog): water, food, hills, and every player's ants. |
| 5 | +
|
| 6 | +The JSON format (see engine.py ``write_replay``):: |
| 7 | +
|
| 8 | + {"rows":32, "cols":32, "num_players":2, "water":[[r,c], ...], |
| 9 | + "names":["p1","p2"], "winner": 0 | null, |
| 10 | + "frames":[{"t":0, "ants":[[r,c,owner], ...], "hills":[[r,c,owner], ...], |
| 11 | + "food":[[r,c], ...]}, ...]} |
| 12 | +
|
| 13 | +Water is static (recorded once). Each frame lists the live ants, living hills, and |
| 14 | +food. ``winner`` is the winning player id, or ``null`` for a draw. Grid cells are |
| 15 | +``[row, col]`` (row = y, col = x); the board wraps, but the renderer just draws it flat. |
| 16 | +""" |
| 17 | + |
| 18 | +from __future__ import annotations |
| 19 | + |
| 20 | +import json |
| 21 | + |
| 22 | +from codeclash.replay.base import ReplayData, ReplayRenderer |
| 23 | + |
| 24 | +DRAW_JS = """ |
| 25 | +const ARENA = (function(){ |
| 26 | + const PAL = ['#e5484d','#4593ff','#46a758','#f5d90a','#8e4ec6','#f76b15','#e93d82','#12a594']; |
| 27 | + const BG = '#0d1117', WATER = '#15304a', FOOD = '#e6edf3', LINE = 'rgba(255,255,255,0.04)'; |
| 28 | + let COLS, ROWS, CELL, WATERSET; |
| 29 | + function col(i){ return PAL[i % PAL.length]; } |
| 30 | + function setup(cv, G){ |
| 31 | + COLS = G.w; ROWS = G.h; |
| 32 | + CELL = Math.max(8, Math.min(22, Math.floor(640 / COLS))); |
| 33 | + cv.width = COLS * CELL; cv.height = ROWS * CELL; |
| 34 | + WATERSET = G.water || []; |
| 35 | + } |
| 36 | + function draw(ctx, cv, G, i){ |
| 37 | + const f = G.frames[i]; |
| 38 | + ctx.fillStyle = BG; ctx.fillRect(0, 0, cv.width, cv.height); |
| 39 | + // water |
| 40 | + ctx.fillStyle = WATER; |
| 41 | + WATERSET.forEach(w => ctx.fillRect(w[1]*CELL, w[0]*CELL, CELL, CELL)); |
| 42 | + // grid lines |
| 43 | + ctx.strokeStyle = LINE; ctx.lineWidth = 1; |
| 44 | + for(let x=0;x<=COLS;x++){ ctx.beginPath(); ctx.moveTo(x*CELL,0); ctx.lineTo(x*CELL,cv.height); ctx.stroke(); } |
| 45 | + for(let y=0;y<=ROWS;y++){ ctx.beginPath(); ctx.moveTo(0,y*CELL); ctx.lineTo(cv.width,y*CELL); ctx.stroke(); } |
| 46 | + // hills — an anthill glyph: a soft owner-tinted base, a mound with an entrance |
| 47 | + // hole, and a bold owner-colored ring that stays visible even with an ant on top. |
| 48 | + (f.hills||[]).forEach(h => { |
| 49 | + const cc = col(h[2]); |
| 50 | + const cx = h[1]*CELL + CELL/2, cy = h[0]*CELL + CELL/2, R = CELL*0.55; |
| 51 | + // soft glow base |
| 52 | + ctx.globalAlpha = 0.22; ctx.fillStyle = cc; |
| 53 | + ctx.beginPath(); ctx.arc(cx, cy, R, 0, 7); ctx.fill(); ctx.globalAlpha = 1; |
| 54 | + // mound (dome) with a white rim for contrast |
| 55 | + ctx.fillStyle = cc; |
| 56 | + ctx.beginPath(); |
| 57 | + ctx.moveTo(cx - R*0.82, cy + R*0.52); |
| 58 | + ctx.quadraticCurveTo(cx, cy - R*0.92, cx + R*0.82, cy + R*0.52); |
| 59 | + ctx.closePath(); ctx.fill(); |
| 60 | + ctx.strokeStyle = 'rgba(255,255,255,0.9)'; ctx.lineWidth = 1.5; ctx.stroke(); |
| 61 | + // entrance hole |
| 62 | + ctx.fillStyle = '#0d1117'; |
| 63 | + ctx.beginPath(); ctx.ellipse(cx, cy + R*0.14, R*0.24, R*0.3, 0, 0, 7); ctx.fill(); |
| 64 | + // framing ring (marks the cell as a hill regardless of an ant sitting on it) |
| 65 | + ctx.strokeStyle = cc; ctx.lineWidth = 2.5; |
| 66 | + ctx.beginPath(); ctx.arc(cx, cy, CELL*0.5 - 1, 0, 7); ctx.stroke(); |
| 67 | + }); |
| 68 | + // food (small white diamonds) |
| 69 | + ctx.fillStyle = FOOD; |
| 70 | + (f.food||[]).forEach(fd => { |
| 71 | + const cx = fd[1]*CELL + CELL/2, cy = fd[0]*CELL + CELL/2, s = Math.max(2, CELL*0.22); |
| 72 | + ctx.beginPath(); ctx.moveTo(cx, cy-s); ctx.lineTo(cx+s, cy); ctx.lineTo(cx, cy+s); ctx.lineTo(cx-s, cy); ctx.closePath(); ctx.fill(); |
| 73 | + }); |
| 74 | + // ants (filled rounded cells in the owner's color) |
| 75 | + (f.ants||[]).forEach(a => { |
| 76 | + ctx.fillStyle = col(a[2]); |
| 77 | + const x = a[1]*CELL, y = a[0]*CELL, p = Math.max(1, CELL*0.12); |
| 78 | + ctx.fillRect(x+p, y+p, CELL-2*p, CELL-2*p); |
| 79 | + }); |
| 80 | + } |
| 81 | + function side(G, i){ |
| 82 | + const f = G.frames[i], NM = G.names || [], n = G.num_players || NM.length; |
| 83 | + const done = i === G.frames.length - 1; |
| 84 | + const ants = {}, hills = {}; |
| 85 | + (f.ants||[]).forEach(a => ants[a[2]] = (ants[a[2]]||0) + 1); |
| 86 | + (f.hills||[]).forEach(h => hills[h[2]] = (hills[h[2]]||0) + 1); |
| 87 | + let rows = ''; |
| 88 | + for(let p=0;p<n;p++){ |
| 89 | + const dead = (ants[p]||0) === 0 && (hills[p]||0) === 0; |
| 90 | + rows += `<div class="team ${dead?'tdead':''}"><div class="tname">` |
| 91 | + + `<span class="sw" style="background:${col(p)}"></span>${NM[p] || ('player'+(p+1))}</div>` |
| 92 | + + `<div class="stat"><span>ants</span><b>${ants[p]||0}</b></div>` |
| 93 | + + `<div class="stat"><span>hills</span><b>${hills[p]||0}</b></div></div>`; |
| 94 | + } |
| 95 | + const res = done ? (G.draw ? 'DRAW' : (G.winner || '\\u2014')) : ''; |
| 96 | + return rows |
| 97 | + + `<div class="stat"><span>turn</span><b>${f.turn} / ${G.max_turns||''}</b></div>` |
| 98 | + + (done ? `<div class="stat"><span>result</span><b>${res}</b></div>` : ''); |
| 99 | + } |
| 100 | + return {setup, draw, side}; |
| 101 | +})(); |
| 102 | +""" |
| 103 | + |
| 104 | + |
| 105 | +class AntsReplayer(ReplayRenderer): |
| 106 | + arena = "Ants" |
| 107 | + sim_glob = "sim_*.json" |
| 108 | + DRAW_JS = DRAW_JS |
| 109 | + |
| 110 | + def parse(self, raw: bytes, players: list[dict] | None = None) -> ReplayData: |
| 111 | + log = json.loads(raw.decode(errors="replace")) |
| 112 | + rows = log.get("rows", 32) |
| 113 | + cols = log.get("cols", 32) |
| 114 | + n = log.get("num_players", 2) |
| 115 | + |
| 116 | + names = list(log.get("names", [])) |
| 117 | + if players: |
| 118 | + names = [p.get("name", names[i] if i < len(names) else f"player{i + 1}") for i, p in enumerate(players)] |
| 119 | + while len(names) < n: |
| 120 | + names.append(f"player{len(names) + 1}") |
| 121 | + |
| 122 | + frames = [ |
| 123 | + { |
| 124 | + "turn": fr.get("t", idx), |
| 125 | + "ants": fr.get("ants", []), |
| 126 | + "hills": fr.get("hills", []), |
| 127 | + "food": fr.get("food", []), |
| 128 | + } |
| 129 | + for idx, fr in enumerate(log.get("frames", [])) |
| 130 | + ] |
| 131 | + |
| 132 | + win = log.get("winner") |
| 133 | + draw = win is None |
| 134 | + winner = None if draw else names[win] if isinstance(win, int) and 0 <= win < len(names) else str(win) |
| 135 | + |
| 136 | + return ReplayData( |
| 137 | + w=cols, |
| 138 | + h=rows, |
| 139 | + frames=frames, |
| 140 | + winner=winner, |
| 141 | + draw=draw, |
| 142 | + extra={ |
| 143 | + "names": names, |
| 144 | + "num_players": n, |
| 145 | + "max_turns": log.get("max_turns", 500), |
| 146 | + "water": log.get("water", []), |
| 147 | + }, |
| 148 | + ) |
| 149 | + |
| 150 | + def peek_winner(self, raw: bytes, players: list[dict] | None = None) -> tuple[str | None, bool] | None: |
| 151 | + log = json.loads(raw.decode(errors="replace")) |
| 152 | + win = log.get("winner") |
| 153 | + if win is None: |
| 154 | + return (None, True) |
| 155 | + names = list(log.get("names", [])) |
| 156 | + if players: |
| 157 | + names = [p.get("name", names[i] if i < len(names) else f"player{i + 1}") for i, p in enumerate(players)] |
| 158 | + name = names[win] if isinstance(win, int) and 0 <= win < len(names) else str(win) |
| 159 | + return (name, False) |
0 commit comments