dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/land/workspace/anchors/greedy.cpp

@@ -0,0 +1,194 @@
+// Anchor bot "greedy": fixed-pattern rectangle loops, ignores the opponents.
+#include <bits/stdc++.h>
+using namespace std;
+
+const int DX[4] = {0, 0, -1, 1};
+const int DY[4] = {-1, 1, 0, 0};
+const char DC[4] = {'U', 'D', 'L', 'R'};
+
+int dirIndex(char c) { return string("UDLR").find(c); }
+
+struct Player {
+    int x, y, dir, trailLen, area, deaths;
+};
+
+struct State {
+    int turn;
+    vector<Player> p;
+    vector<string> owner;  // owner[y][x]: '.' neutral, '0'..'3' territory of that player
+    vector<string> trail;  // trail[y][x]:  '.' none,    '0'..'3' trail of that player
+};
+
+int W, H, MAX_TURNS, N, ME, MOVE_MS, INIT_MS;
+vector<pair<int, int>> spawn;
+
+bool readState(State& s) {
+    string tok;
+    if (!(cin >> tok)) return false;  // "TURN"
+    cin >> s.turn;
+    s.p.assign(N, {});
+    for (int i = 0; i < N; i++) {
+        int id;
+        char d;
+        Player q;
+        cin >> tok >> id >> q.x >> q.y >> d >> q.trailLen >> q.area >> q.deaths;
+        q.dir = dirIndex(d);
+        s.p[id] = q;
+    }
+    cin >> tok;  // OWNER
+    s.owner.assign(H, "");
+    for (auto& row : s.owner) cin >> row;
+    cin >> tok;  // TRAIL
+    s.trail.assign(H, "");
+    for (auto& row : s.trail) cin >> row;
+    cin >> tok;  // END
+    return true;
+}
+
+// Greedy loop maker: leave the territory, draw the largest rectangle it can find,
+// return home by the shortest safe path. Ignores the opponents, except that it
+// always takes an immediate chance to cut an opponent's trail.
+mt19937 rng(20260925);
+deque<int> plan;
+bool wasOutside = false;
+
+bool inb(int x, int y) { return x >= 0 && x < W && y >= 0 && y < H; }
+
+// BFS from the head (no reversing) through cells that are not our own trail.
+// Returns the direction path to the nearest cell satisfying goal(x, y); empty if none.
+template <class F>
+vector<int> bfsPath(const State& s, F goal) {
+    const Player& me = s.p[ME];
+    char myTrail = '0' + ME;
+    vector<int> from(W * H, -1), fdir(W * H, -1);
+    deque<int> q;
+    int start = me.y * W + me.x;
+    from[start] = start;
+    for (int d = 0; d < 4; d++) {
+        if (d == (me.dir ^ 1)) continue;
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        if (!inb(nx, ny) || s.trail[ny][nx] == myTrail) continue;
+        int k = ny * W + nx;
+        if (from[k] != -1) continue;
+        from[k] = start;
+        fdir[k] = d;
+        q.push_back(k);
+    }
+    while (!q.empty()) {
+        int k = q.front();
+        q.pop_front();
+        int x = k % W, y = k / W;
+        if (goal(x, y)) {
+            vector<int> path;
+            for (int c = k; c != start; c = from[c]) path.push_back(fdir[c]);
+            reverse(path.begin(), path.end());
+            return path;
+        }
+        for (int d = 0; d < 4; d++) {
+            int nx = x + DX[d], ny = y + DY[d];
+            if (!inb(nx, ny) || s.trail[ny][nx] == myTrail) continue;
+            int nk = ny * W + nx;
+            if (from[nk] != -1) continue;
+            from[nk] = k;
+            fdir[nk] = d;
+            q.push_back(nk);
+        }
+    }
+    return {};
+}
+
+void makePlan(const State& s) {
+    char mine = '0' + ME;
+    vector<int> path = bfsPath(s, [&](int x, int y) { return s.owner[y][x] != mine; });
+    if (path.empty()) return;
+    int ex = s.p[ME].x, ey = s.p[ME].y;
+    for (int d : path) ex += DX[d], ey += DY[d];
+    int d = path.back();
+    int best = -1, ba = 0, bb = 0, bs = 0;
+    for (int it = 0; it < 24; it++) {
+        int a = 3 + rng() % 6, b = 3 + rng() % 6;
+        int side = (d < 2) ? 2 + rng() % 2 : rng() % 2;  // perpendicular to d
+        int fx = ex + DX[d] * (a - 1), fy = ey + DY[d] * (a - 1);
+        int cx = fx + DX[side] * b, cy = fy + DY[side] * b;
+        if (!inb(fx, fy) || !inb(cx, cy)) continue;
+        int gain = 0;
+        for (int y = min(ey, cy); y <= max(ey, cy); y++)
+            for (int x = min(ex, cx); x <= max(ex, cx); x++)
+                if (s.owner[y][x] != mine) gain++;
+        if (gain > best) best = gain, ba = a, bb = b, bs = side;
+    }
+    plan.assign(path.begin(), path.end());
+    if (best < 0) return;
+    for (int i = 0; i < ba - 1; i++) plan.push_back(d);
+    for (int i = 0; i < bb; i++) plan.push_back(bs);
+    for (int i = 0; i < ba - 1; i++) plan.push_back(d ^ 1);
+}
+
+int anySafe(const State& s) {
+    const Player& me = s.p[ME];
+    char myTrail = '0' + ME;
+    for (int d : {me.dir, 0, 1, 2, 3}) {
+        if (d == (me.dir ^ 1)) continue;
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        if (inb(nx, ny) && s.trail[ny][nx] != myTrail) return d;
+    }
+    return me.dir;
+}
+
+int decide(const State& s) {
+    const Player& me = s.p[ME];
+    char mine = '0' + ME;
+    bool inside = s.owner[me.y][me.x] == mine;
+    if (inside && wasOutside) plan.clear();  // just captured or respawned
+    wasOutside = !inside;
+
+    for (int d = 0; d < 4; d++) {
+        if (d == (me.dir ^ 1)) continue;
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        if (inb(nx, ny) && s.trail[ny][nx] != '.' && s.trail[ny][nx] != mine) {  // any opponent's trail
+            plan.clear();
+            return d;
+        }
+    }
+    if (plan.empty()) {
+        if (inside) makePlan(s);
+        else {
+            vector<int> home = bfsPath(s, [&](int x, int y) { return s.owner[y][x] == mine; });
+            if (!home.empty()) return home[0];
+            return anySafe(s);
+        }
+    }
+    if (!plan.empty()) {
+        int d = plan.front();
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        if (d != (me.dir ^ 1) && inb(nx, ny) && s.trail[ny][nx] != mine) {
+            plan.pop_front();
+            return d;
+        }
+        plan.clear();
+        if (!inside) {
+            vector<int> home = bfsPath(s, [&](int x, int y) { return s.owner[y][x] == mine; });
+            if (!home.empty()) return home[0];
+        }
+    }
+    return anySafe(s);
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    string tok;
+    cin >> tok;  // INIT
+    cin >> W >> H >> MAX_TURNS >> N >> ME >> MOVE_MS >> INIT_MS;
+    spawn.resize(N);
+    for (int i = 0; i < N; i++) {
+        int id, x, y;
+        cin >> tok >> id >> x >> y;
+        spawn[id] = {x, y};
+    }
+    State s;
+    while (readState(s)) {
+        int d = decide(s);
+        cout << s.turn << ' ' << DC[d] << endl;  // endl flushes: required every turn
+    }
+}

package/eval/arena/land/workspace/anchors/random.cpp

@@ -0,0 +1,80 @@
+// Anchor bot "random": a uniformly random move among those that do not hit a wall or its own trail.
+#include <bits/stdc++.h>
+using namespace std;
+
+const int DX[4] = {0, 0, -1, 1};
+const int DY[4] = {-1, 1, 0, 0};
+const char DC[4] = {'U', 'D', 'L', 'R'};
+
+int dirIndex(char c) { return string("UDLR").find(c); }
+
+struct Player {
+    int x, y, dir, trailLen, area, deaths;
+};
+
+struct State {
+    int turn;
+    vector<Player> p;
+    vector<string> owner;  // owner[y][x]: '.' neutral, '0'..'3' territory of that player
+    vector<string> trail;  // trail[y][x]:  '.' none,    '0'..'3' trail of that player
+};
+
+int W, H, MAX_TURNS, N, ME, MOVE_MS, INIT_MS;
+vector<pair<int, int>> spawn;
+
+bool readState(State& s) {
+    string tok;
+    if (!(cin >> tok)) return false;  // "TURN"
+    cin >> s.turn;
+    s.p.assign(N, {});
+    for (int i = 0; i < N; i++) {
+        int id;
+        char d;
+        Player q;
+        cin >> tok >> id >> q.x >> q.y >> d >> q.trailLen >> q.area >> q.deaths;
+        q.dir = dirIndex(d);
+        s.p[id] = q;
+    }
+    cin >> tok;  // OWNER
+    s.owner.assign(H, "");
+    for (auto& row : s.owner) cin >> row;
+    cin >> tok;  // TRAIL
+    s.trail.assign(H, "");
+    for (auto& row : s.trail) cin >> row;
+    cin >> tok;  // END
+    return true;
+}
+
+mt19937 rng(12345);
+
+int decide(const State& s) {
+    const Player& me = s.p[ME];
+    char myTrail = '0' + ME;
+    vector<int> ok;
+    for (int d = 0; d < 4; d++) {
+        if (d == (me.dir ^ 1)) continue;
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        if (nx >= 0 && nx < W && ny >= 0 && ny < H && s.trail[ny][nx] != myTrail) ok.push_back(d);
+    }
+    if (ok.empty()) return me.dir;
+    return ok[rng() % ok.size()];
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    string tok;
+    cin >> tok;  // INIT
+    cin >> W >> H >> MAX_TURNS >> N >> ME >> MOVE_MS >> INIT_MS;
+    spawn.resize(N);
+    for (int i = 0; i < N; i++) {
+        int id, x, y;
+        cin >> tok >> id >> x >> y;
+        spawn[id] = {x, y};
+    }
+    State s;
+    while (readState(s)) {
+        int d = decide(s);
+        cout << s.turn << ' ' << DC[d] << endl;  // endl flushes: required every turn
+    }
+}

package/eval/arena/land/workspace/clock.py

@@ -0,0 +1,64 @@
+"""Development timer; never infer the unpack time from file mtime.
+Explicit organizer start is preferred. Legacy birthtime/ctime is frozen once.
+"""
+import argparse
+import datetime
+import json
+import os
+import platform
+import time
+from pathlib import Path
+
+MARKER = '.development-clock.json'
+
+def boot_id():
+    try:return Path('/proc/sys/kernel/random/boot_id').read_text().strip()
+    except OSError:return None
+
+def initialize(root, explicit=False, wall=None, monotonic=None):
+    root=Path(root);marker=root/MARKER
+    if marker.exists():return json.loads(marker.read_text(encoding='utf-8'))
+    now=time.time();mono=time.monotonic()
+    if explicit:
+        start=now if wall is None else wall
+        start_mono=mono if monotonic is None else monotonic
+        source='explicit_start'
+    else:
+        st=root.stat();start=getattr(st,'st_birthtime',None) or st.st_ctime
+        source='directory_birthtime' if getattr(st,'st_birthtime',None) or os.name=='nt' else 'directory_ctime_estimate'
+        start_mono=mono-max(0,now-start)
+    state=dict(version=1,start_unix=start,start_monotonic=start_mono,source=source,
+               host=platform.node(),system=platform.system(),boot_id=boot_id(),boot_epoch=now-mono,
+               suggested_seconds=3600,hard_stop_seconds=5400)
+    try:
+        with marker.open('x',encoding='utf-8') as f:json.dump(state,f,indent=2)
+    except FileExistsError:return json.loads(marker.read_text(encoding='utf-8'))
+    return state
+
+def read_clock(root, explicit=False):
+    state=initialize(root,explicit);now=time.time();mono=time.monotonic();current_boot=boot_id()
+    same_host=state['host']==platform.node() and state['system']==platform.system()
+    same_boot=(state['boot_id']==current_boot if state['boot_id'] and current_boot
+               else abs((now-mono)-state['boot_epoch'])<120)
+    use_mono=same_host and same_boot and mono>=state['start_monotonic']
+    elapsed=max(0,mono-state['start_monotonic'] if use_mono else now-state['start_unix'])
+    return dict(now_utc=datetime.datetime.fromtimestamp(now,datetime.timezone.utc).isoformat(),
+                start_utc=datetime.datetime.fromtimestamp(state['start_unix'],datetime.timezone.utc).isoformat(),
+                elapsed_seconds=round(elapsed,3),remaining_seconds=round(max(0,5400-elapsed),3),
+                hard_stop_reached=elapsed>=5400,source=state['source'],
+                measurement='monotonic' if use_mono else 'persisted_UTC_fallback',
+                approximate_start=state['source']=='directory_ctime_estimate')
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--start',action='store_true',help='start once; never resets an existing timer')
+    ap.add_argument('--json',action='store_true');args=ap.parse_args()
+    data=read_clock(Path(__file__).resolve().parent,args.start)
+    if args.json:print(json.dumps(data,ensure_ascii=True,indent=2));return
+    print('Current UTC: '+data['now_utc'])
+    print('Elapsed: %.1f min | Remaining until 90-minute deadline: %.1f min | Suggested: 60 min.' %
+          (data['elapsed_seconds']/60,data['remaining_seconds']/60))
+    print('Start: %s | Clock: %s | Source: %s' % (data['start_utc'],data['measurement'],data['source']))
+    if data['approximate_start']:print('NOTE: legacy Linux ctime start is approximate; prefer the organizer unpack launcher.')
+    if data['hard_stop_reached']:print('HARD STOP REACHED: submit the current version now.')
+
+if __name__=='__main__':main()

package/eval/arena/land/workspace/engine/build.py

@@ -0,0 +1,33 @@
+"""Compile a bot with the official flags. The compiler is taken from $CXX (default g++)."""
+import hashlib
+import os
+import subprocess
+import sys
+
+FLAGS = ['-O2', '-std=c++20']
+if sys.platform == 'win32':
+    FLAGS.append('-static')
+
+
+def compile_bot(src, cache_dir=None):
+    """Compile src (.cpp) and return the executable path. Rebuilds only when the source changes."""
+    src = os.path.abspath(src)
+    cache_dir = cache_dir or os.path.join(os.path.dirname(src), '.build')
+    os.makedirs(cache_dir, exist_ok=True)
+    with open(src, 'rb') as f:
+        digest = hashlib.sha1(f.read()).hexdigest()[:12]
+    name = os.path.splitext(os.path.basename(src))[0] + '_' + digest
+    exe = os.path.join(cache_dir, name + ('.exe' if sys.platform == 'win32' else ''))
+    if not os.path.exists(exe):
+        cmd = [os.environ.get('CXX', 'g++')] + FLAGS + ['-o', exe, src]
+        r = subprocess.run(cmd, capture_output=True, text=True)
+        if r.returncode != 0:
+            raise RuntimeError('compile failed: %s\n%s' % (' '.join(cmd), r.stderr[-4000:]))
+    return exe
+
+
+def resolve(path, cache_dir=None):
+    """Accept a .cpp (compiled on demand) or an executable."""
+    if path.endswith('.cpp'):
+        return compile_bot(path, cache_dir)
+    return os.path.abspath(path)

package/eval/arena/land/workspace/engine/game.py

@@ -0,0 +1,273 @@
+"""Territory game (圈地) rules engine.
+
+Pure Python, no dependencies, fully deterministic. This file is the single
+source of truth for the rules; RULES.md describes the same behaviour in prose.
+"""
+import random
+
+DIRS = {'U': (0, -1), 'D': (0, 1), 'L': (-1, 0), 'R': (1, 0)}
+OPPOSITE = {'U': 'D', 'D': 'U', 'L': 'R', 'R': 'L'}
+
+DEFAULT_CONFIG = {
+    'width': 40,
+    'height': 40,
+    'max_turns': 600,
+    'start_radius': 2,      # initial territory: (2r+1)x(2r+1) square around spawn
+    'protect_radius': 1,    # protected zone: (2r+1)x(2r+1) square, can never be captured
+    'spawn_margin': 4,      # min distance from spawn to the border
+    'min_spawn_dist': 16,   # min Manhattan distance between any two spawns
+    'players': 2,
+}
+
+# 4 人混战：正方形棋盘，四个出生点互为 90° 旋转
+MELEE_CONFIG = dict(DEFAULT_CONFIG, width=48, height=48, players=4, spawn_margin=5)
+
+ROT90 = {'U': 'R', 'R': 'D', 'D': 'L', 'L': 'U'}  # clockwise
+
+
+def config_for(players):
+    return MELEE_CONFIG if players == 4 else DEFAULT_CONFIG
+
+
+def make_start(seed, cfg=DEFAULT_CONFIG):
+    """Spawns and initial directions for a seed.
+    2 players: player 1 is player 0 rotated 180 degrees.
+    4 players: player k is player 0 rotated k x 90 degrees clockwise (square board)."""
+    rng = random.Random(seed)
+    W, H, m = cfg['width'], cfg['height'], cfg['spawn_margin']
+    if cfg.get('players', 2) == 4:
+        assert W == H
+        while True:
+            x, y = rng.randint(m, W - 1 - m), rng.randint(m, H - 1 - m)
+            pts = [(x, y)]
+            for _ in range(3):
+                px, py = pts[-1]
+                pts.append((W - 1 - py, px))
+            if all(abs(a[0] - b[0]) + abs(a[1] - b[1]) >= cfg['min_spawn_dist']
+                   for i, a in enumerate(pts) for b in pts[i + 1:]):
+                break
+        d = rng.choice('UDLR')
+        dirs = [d]
+        for _ in range(3):
+            dirs.append(ROT90[dirs[-1]])
+        return pts, dirs
+    while True:
+        x, y = rng.randint(m, W - 1 - m), rng.randint(m, H - 1 - m)
+        x2, y2 = W - 1 - x, H - 1 - y
+        if abs(x - x2) + abs(y - y2) >= cfg['min_spawn_dist']:
+            break
+    d = rng.choice('UDLR')
+    return [(x, y), (x2, y2)], [d, OPPOSITE[d]]
+
+
+class Game:
+    def __init__(self, cfg, spawns, dirs):
+        self.cfg = cfg
+        self.W, self.H = cfg['width'], cfg['height']
+        self.N = len(spawns)
+        n = self.W * self.H
+        self.owner = [-1] * n       # territory owner per cell
+        self.trail = [-1] * n       # trail owner per cell
+        self.protected = [-1] * n   # protected-zone owner per cell
+        self.spawns = list(spawns)
+        self.init_dirs = list(dirs)
+        self.pos = list(spawns)
+        self.dir = list(dirs)
+        self.trails = [[] for _ in range(self.N)]  # ordered trail cell indices
+        self.deaths = [0] * self.N
+        self.kills = [0] * self.N
+        self.out = [False] * self.N  # 被淘汰（程序崩溃或错误过多）的玩家：停在出生点，不再行动
+        self.turn = 0
+        for i, (sx, sy) in enumerate(spawns):
+            r = cfg['start_radius']
+            for y in range(sy - r, sy + r + 1):
+                for x in range(sx - r, sx + r + 1):
+                    self.owner[y * self.W + x] = i
+            r = cfg['protect_radius']
+            for y in range(sy - r, sy + r + 1):
+                for x in range(sx - r, sx + r + 1):
+                    self.protected[y * self.W + x] = i
+
+    def over(self):
+        return self.turn >= self.cfg['max_turns']
+
+    def areas(self):
+        a = [0] * self.N
+        for o in self.owner:
+            if o >= 0:
+                a[o] += 1
+        return a
+
+    def eliminate(self, i):
+        """Remove a forfeited player from play (melee only): its trail is cleared, it stays
+        on its spawn and never moves again. Its territory stays on the board."""
+        for k in self.trails[i]:
+            self.trail[k] = -1
+        self.trails[i] = []
+        self.pos[i] = self.spawns[i]
+        self.out[i] = True
+
+    def _enclosed(self, i):
+        """Cells not owned by i and not on i's trail that cannot reach the border
+        without crossing i's territory or trail."""
+        W, H = self.W, self.H
+        owner, trail = self.owner, self.trail
+        wall = bytearray(W * H)
+        for k in range(W * H):
+            if owner[k] == i or trail[k] == i:
+                wall[k] = 1
+        seen = bytearray(W * H)
+        stack = []
+        for x in range(W):
+            for k in (x, (H - 1) * W + x):
+                if not wall[k] and not seen[k]:
+                    seen[k] = 1
+                    stack.append(k)
+        for y in range(H):
+            for k in (y * W, y * W + W - 1):
+                if not wall[k] and not seen[k]:
+                    seen[k] = 1
+                    stack.append(k)
+        while stack:
+            k = stack.pop()
+            x = k % W
+            for nk, ok in ((k - W, k >= W), (k + W, k < W * (H - 1)),
+                           (k - 1, x > 0), (k + 1, x < W - 1)):
+                if ok and not wall[nk] and not seen[nk]:
+                    seen[nk] = 1
+                    stack.append(nk)
+        return [k for k in range(W * H) if not wall[k] and not seen[k]]
+
+    def step(self, moves):
+        """Advance one turn. moves[i] is 'U'/'D'/'L'/'R' or None (keep direction).
+        Returns a frame dict describing what changed (used for replays)."""
+        W, H, N = self.W, self.H, self.N
+        dirs, new = [], []
+        dead = [None] * N  # (reason, other_player)
+
+        # 1. intended moves; reversing or invalid input keeps the current direction
+        for i in range(N):
+            d = self.dir[i]
+            m = moves[i]
+            if self.out[i]:
+                dirs.append(d)
+                new.append(None)
+                continue
+            if m in DIRS and m != OPPOSITE[d]:
+                d = m
+            dirs.append(d)
+            x, y = self.pos[i]
+            dx, dy = DIRS[d]
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < W and 0 <= ny < H:
+                new.append(ny * W + nx)
+            else:
+                new.append(None)
+                dead[i] = ('wall', None)
+
+        # 2. head-on collisions (same target cell, or swapping cells)
+        cur = [py * W + px for px, py in self.pos]
+        for i in range(N):
+            for j in range(i + 1, N):
+                if new[i] is None or new[j] is None:
+                    continue
+                if new[i] == new[j] or (new[i] == cur[j] and new[j] == cur[i]):
+                    dead[i] = dead[i] or ('head', j)
+                    dead[j] = dead[j] or ('head', i)
+
+        # 3. trail cuts: entering a trail cell kills the trail's owner
+        for i in range(N):
+            if new[i] is None:
+                continue
+            c = self.trail[new[i]]
+            if c != -1 and dead[c] is None:
+                dead[c] = ('self', i) if c == i else ('cut', i)
+
+        frame = {'events': [], 'owner': [], 'trail_clear': [], 'trail_add': []}
+
+        # 4. deaths: drop trail, teleport to spawn, keep territory
+        for i in range(N):
+            if dead[i] is None:
+                continue
+            for k in self.trails[i]:
+                self.trail[k] = -1
+            self.trails[i] = []
+            self.pos[i] = self.spawns[i]
+            self.dir[i] = self.init_dirs[i]
+            self.deaths[i] += 1
+            reason, by = dead[i]
+            if reason == 'cut':
+                self.kills[by] += 1
+            frame['events'].append({'type': 'death', 'player': i, 'reason': reason, 'by': by})
+            frame['trail_clear'].append(i)
+
+        # 5. survivors move
+        capturers = []
+        for i in range(N):
+            if dead[i] is not None or self.out[i]:
+                continue
+            k = new[i]
+            self.dir[i] = dirs[i]
+            self.pos[i] = (k % W, k // W)
+            if self.owner[k] == i:
+                if self.trails[i]:
+                    capturers.append(i)
+            else:
+                self.trails[i].append(k)
+                self.trail[k] = i
+                frame['trail_add'].append([i, k])
+
+        # 6. captures, computed on the pre-capture board and applied together
+        if capturers:
+            enclosed = {i: self._enclosed(i) for i in capturers}
+            trail_cells = {}
+            for i in capturers:
+                for k in self.trails[i]:
+                    trail_cells[k] = i
+            claims = {}
+            for i in capturers:
+                for k in enclosed[i]:
+                    claims.setdefault(k, []).append(i)
+            gained = {i: 0 for i in capturers}
+
+            def take(k, i):
+                if self.protected[k] not in (-1, i) or self.owner[k] == i:
+                    return
+                self.owner[k] = i
+                gained[i] += 1
+                frame['owner'].append([k, i])
+
+            for k, i in trail_cells.items():
+                take(k, i)
+            for k, cl in claims.items():
+                if len(cl) == 1 and k not in trail_cells:
+                    take(k, cl[0])
+            for i in capturers:
+                for k in self.trails[i]:
+                    self.trail[k] = -1
+                self.trails[i] = []
+                frame['trail_clear'].append(i)
+                frame['events'].append({'type': 'capture', 'player': i, 'cells': gained[i]})
+
+        self.turn += 1
+        frame['pos'] = [[x, y, d] for (x, y), d in zip(self.pos, self.dir)]
+        return frame
+
+    def state_text(self, turn):
+        """Per-turn message sent to bots (see RULES.md)."""
+        areas = self.areas()
+        lines = ['TURN %d' % turn]
+        for i in range(self.N):
+            x, y = self.pos[i]
+            lines.append('P %d %d %d %s %d %d %d' % (
+                i, x, y, self.dir[i], len(self.trails[i]), areas[i], self.deaths[i]))
+        W = self.W
+        ch = '.0123456789'
+        lines.append('OWNER')
+        row = ''.join(ch[o + 1] for o in self.owner)
+        lines.extend(row[y * W:(y + 1) * W] for y in range(self.H))
+        lines.append('TRAIL')
+        row = ''.join(ch[o + 1] for o in self.trail)
+        lines.extend(row[y * W:(y + 1) * W] for y in range(self.H))
+        lines.append('END')
+        return '\n'.join(lines) + '\n'