dsh-eval-guard 0.2.2 → 0.3.0

package/eval/arena/bomberman/workspace/baseline.cpp

@@ -0,0 +1,240 @@
+#define MOVE_MODE 1
+// Independently implemented challenger strategy. No baseline/opponent source reuse.
+// Public input only; deterministic time-expanded reachability and escape denial.
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+using namespace std;
+const string DS="UDLRS";const int DX[]={0,0,-1,1,0},DY[]={-1,1,0,0,0};
+int N,P,ME,T,LIMIT,FUSE,RANGE,CAP,FIRE,SHRINK,EVERY;
+struct Player{int x,y,alive;};struct Bomb{int owner,x,y,at;};struct Flame{int x,y,end;};
+vector<string> board;vector<Player> players;vector<Bomb> bombs;vector<Flame> flames;
+int cell(int x,int y){return y*N+x;}
+struct Prediction{vector<vector<unsigned char>> safe,open,occupied;};
+Prediction predict(vector<Bomb> bs,int horizon){
+ Prediction out;out.safe=out.open=out.occupied=vector(horizon,vector<unsigned char>(N*N));
+ auto grid=board;vector<int> expires(N*N,-1);for(auto f:flames)expires[cell(f.x,f.y)]=f.end;
+ for(int k=0;k<horizon;k++){
+  int now=T+k,layer=now<SHRINK?0:1+(now-SHRINK)/EVERY;
+  for(int y=0;y<N;y++)for(int x=0;x<N;x++)if(min({x,y,N-1-x,N-1-y})<=layer){grid[y][x]='#';expires[cell(x,y)]=-1;}
+  bs.erase(remove_if(bs.begin(),bs.end(),[&](Bomb b){return grid[b.y][b.x]=='#';}),bs.end());
+  vector<int> at(N*N,-1);for(int i=0;i<(int)bs.size();i++){at[cell(bs[i].x,bs[i].y)]=i;out.occupied[k][cell(bs[i].x,bs[i].y)]=1;}
+  for(int y=0;y<N;y++)for(int x=0;x<N;x++)out.open[k][cell(x,y)]=grid[y][x]=='.';
+  queue<int> q;vector<bool> gone(bs.size());vector<unsigned char> hit(N*N);
+  for(int i=0;i<(int)bs.size();i++)if(bs[i].at<=now||expires[cell(bs[i].x,bs[i].y)]>=now)q.push(i);
+  while(!q.empty()){
+   int i=q.front();q.pop();if(gone[i])continue;gone[i]=true;auto b=bs[i];hit[cell(b.x,b.y)]=1;
+   for(int d=0;d<4;d++)for(int r=1;r<=RANGE;r++){
+    int x=b.x+DX[d]*r,y=b.y+DY[d]*r;if(x<0||y<0||x>=N||y>=N||grid[y][x]=='#')break;
+    int c=cell(x,y);hit[c]=1;if(grid[y][x]=='+')break;if(at[c]>=0){q.push(at[c]);break;}
+   }
+  }
+  vector<Bomb> left;for(int i=0;i<(int)bs.size();i++)if(!gone[i])left.push_back(bs[i]);bs=move(left);
+  for(int y=0;y<N;y++)for(int x=0;x<N;x++){
+   int c=cell(x,y);if(hit[c]){expires[c]=max(expires[c],now+FIRE-1);if(grid[y][x]=='+')grid[y][x]='.';}
+   out.safe[k][c]=grid[y][x]=='.'&&expires[c]<now;
+  }
+ }
+ return out;
+}
+vector<double> potential;
+struct Reach {array<int,5> count{},life{};array<double,5> utility{};int unique=0;};
+Reach reach(const Prediction& pr,int who,int forced=-1){
+ vector<unsigned char> current(N*N);auto player=players[who];current[cell(player.x,player.y)]=31;
+ Reach result;result.utility.fill(-1e6);
+ for(int k=0;k<(int)pr.safe.size();k++){
+  vector<unsigned char> next(N*N);int now=T+k,layer=now<SHRINK?0:1+(now-SHRINK)/EVERY;
+  for(int c=0;c<N*N;c++)if(current[c]){
+   int x=c%N,y=c/N;if(min({x,y,N-1-x,N-1-y})<=layer)continue;
+   for(int d=0;d<5;d++){
+    int nx=x+DX[d],ny=y+DY[d],nc=c;
+    if(nx>=0&&ny>=0&&nx<N&&ny<N){int z=cell(nx,ny);if(pr.open[k][z]&&(!pr.occupied[k][z]||z==c))nc=z;}
+    if(k==0&&forced>=0)nc=forced;
+    if(pr.safe[k][nc])next[nc]|=k==0?(1<<d):current[c];
+   }
+  }
+  current=move(next);for(int c=0;c<N*N;c++)if(current[c])for(int d=0;d<5;d++)if(current[c]&(1<<d))result.life[d]=k+1;
+ }
+ for(int c=0;c<N*N;c++)if(current[c]){
+  result.unique++;
+  for(int d=0;d<5;d++)if(current[c]&(1<<d)){result.count[d]++;result.utility[d]=max(result.utility[d],potential.empty()?0:potential[c]);}
+ }
+ return result;
+}
+int blast_value(int x,int y){
+ int score=0;
+ for(int d=0;d<4;d++)for(int r=1;r<=RANGE;r++){
+  int nx=x+DX[d]*r,ny=y+DY[d]*r;if(nx<0||ny<0||nx>=N||ny>=N||board[ny][nx]=='#')break;
+  if(board[ny][nx]=='+'){score+=3;break;}
+  for(int i=0;i<P;i++)if(i!=ME&&players[i].alive&&players[i].x==nx&&players[i].y==ny)score+=4;
+ }
+ return score;
+}
+void make_potential(){
+ potential.assign(N*N,-1e6);priority_queue<pair<double,int>> q;
+ for(int y=0;y<N;y++)for(int x=0;x<N;x++)if(board[y][x]=='.'){
+  int edge=min({x,y,N-1-x,N-1-y});double val=blast_value(x,y)*.9;
+  int until=SHRINK+max(0,edge-1)*EVERY-T;
+  if(until<12)val-=30;else val+=min(4.0,edge*.4);
+  potential[cell(x,y)]=val;q.push({val,cell(x,y)});
+ }
+ // Reverse distance transform rewards approaching a useful bombing position,
+ // respecting walls/crates rather than using straight-line Manhattan distance.
+ while(!q.empty()){
+  auto [v,c]=q.top();q.pop();if(v<potential[c]-1e-9)continue;
+  int x=c%N,y=c/N;for(int d=0;d<4;d++){int nx=x+DX[d],ny=y+DY[d];if(nx<0||ny<0||nx>=N||ny>=N||board[ny][nx]!='.')continue;
+   int nc=cell(nx,ny);if(v-.8>potential[nc]){potential[nc]=v-.8;q.push({v-.8,nc});}
+  }
+ }
+}
+
+// Experiment: persistent target + immediate progress + decaying visit memory.
+// AGGRESSIVE adds opponent pursuit and more reward for reducing enemy escapes.
+vector<int> recent;int goal=-1,goal_turn=-100,last_x=-1,last_y=-1;
+vector<int> goal_distance;
+vector<int> distances(int start){
+ vector<int> dist(N*N,10000);queue<int> q;dist[start]=0;q.push(start);
+ while(!q.empty()){int c=q.front();q.pop();for(int d=0;d<4;d++){
+  int x=c%N+DX[d],y=c/N+DY[d];if(x<0||y<0||x>=N||y>=N||board[y][x]!='.')continue;
+  int z=cell(x,y);if(dist[z]>dist[c]+1){dist[z]=dist[c]+1;q.push(z);}
+ }}return dist;
+}
+double visits(int c){double sum=0;for(int k=0;k<(int)recent.size();k++)if(recent[k]==c)sum+=1.0/(1+.15*(recent.size()-1-k));return sum;}
+void update_goal(){
+ int current=cell(players[ME].x,players[ME].y);recent.push_back(current);if(recent.size()>32)recent.erase(recent.begin());
+ auto dist=distances(current);vector<int> enemy(N*N,10000);
+#ifdef AGGRESSIVE
+ for(int i=0;i<P;i++)if(i!=ME&&players[i].alive){auto dd=distances(cell(players[i].x,players[i].y));for(int c=0;c<N*N;c++)enemy[c]=min(enemy[c],dd[c]);}
+#endif
+ int layer=T<SHRINK?0:1+(T-SHRINK)/EVERY;
+ if(goal<0||board[goal/N][goal%N]!='.'||dist[goal]>=10000||T-goal_turn>=12||
+    min({goal%N,goal/N,N-1-goal%N,N-1-goal/N})<=layer+1||current==goal){
+  goal=-1;double best=-1e20;
+  for(int c=0;c<N*N;c++)if(dist[c]<10000){
+   int x=c%N,y=c/N,edge=min({x,y,N-1-x,N-1-y});
+   double v=1.5*blast_value(x,y)-.65*dist[c]-.9*visits(c);
+   int until=SHRINK+max(0,edge-1)*EVERY-T;
+   if(until<=dist[c]+10)v-=40;else v+=min(3.0,edge*.3);
+#ifdef AGGRESSIVE
+   if(enemy[c]<10000)v+=max(-12.0,9.0-1.4*abs(enemy[c]-3));
+#endif
+   if(v>best){best=v;goal=c;}
+  }goal_turn=T;
+ }goal_distance=distances(goal<0?current:goal);
+}
+
+
+vector<int> previous_cells;
+int predict_destination(const Prediction& pr,int my_direction){
+ vector<int> ids,origin,target;
+ for(int i=0;i<P;i++)if(players[i].alive&&pr.open[0][cell(players[i].x,players[i].y)]){
+  auto p=players[i];int old=cell(p.x,p.y),d=4;
+  if(i==ME)d=my_direction;
+  else if(!previous_cells.empty())for(int j=0;j<4;j++)if(old==previous_cells[i]+DY[j]*N+DX[j])d=j;
+  int x=p.x+DX[d],y=p.y+DY[d],dest=old;
+  if(x>=0&&y>=0&&x<N&&y<N&&pr.open[0][cell(x,y)]&&(!pr.occupied[0][cell(x,y)]||old==cell(x,y)))dest=cell(x,y);
+  ids.push_back(i);origin.push_back(old);target.push_back(dest);
+ }
+ auto result=target;
+#if MOVE_MODE != 0
+ for(int i=0;i<(int)ids.size();i++)if(count(target.begin(),target.end(),target[i])>1)result[i]=origin[i];
+#if MOVE_MODE == 2
+ for(int i=0;i<(int)ids.size();i++)for(int j=0;j<i;j++)if(result[i]==origin[j]&&result[j]==origin[i]){result[i]=origin[i];result[j]=origin[j];}
+#endif
+ bool changed=true;while(changed){changed=false;auto last=result;
+  for(int i=0;i<(int)ids.size();i++)for(int j=0;j<(int)ids.size();j++)if(last[j]==origin[j]&&result[i]==origin[j]&&result[i]!=origin[i]){result[i]=origin[i];changed=true;}
+ }
+#endif
+ for(int i=0;i<(int)ids.size();i++)if(ids[i]==ME)return result[i];
+ return cell(players[ME].x,players[ME].y);
+}
+
+pair<int,int> decide(){
+ int horizon=min(8,LIMIT-T);auto me=players[ME];make_potential();update_goal();
+ auto normal=predict(bombs,horizon);auto ordinary=reach(normal,ME);
+ vector<int> enemy_base(P);for(int i=0;i<P;i++)if(i!=ME&&players[i].alive)enemy_base[i]=reach(normal,i).unique;
+ int active=0;bool occupied=false,shared=false;for(auto b:bombs){active+=b.owner==ME;occupied|=b.x==me.x&&b.y==me.y;}
+ for(int i=0;i<P;i++)if(i!=ME&&players[i].alive&&players[i].x==me.x&&players[i].y==me.y)shared=true;
+ pair<int,int> answer={4,0};double best=-1e30;
+ for(int place=0;place<=1;place++){
+  if(place&&(active>=CAP||occupied||shared))continue;
+  auto bs=bombs;if(place)bs.push_back({ME,me.x,me.y,T+FUSE});
+  auto scenario=place?predict(bs,horizon):normal;auto own=place?reach(scenario,ME):ordinary;
+  double denial=0;
+  if(place){
+   denial=blast_value(me.x,me.y)*.7-2.5;
+   for(int i=0;i<P;i++)if(i!=ME&&players[i].alive&&enemy_base[i]>0){
+    int remaining=reach(scenario,i).unique;
+    denial+=remaining==0?100:5.0*max(0.0,1.0-double(remaining)/enemy_base[i]);
+   }
+  }
+  // Counterfactual: nearest rival may place a bomb NOW. This is a threat model,
+  // not an oracle or an opponent-specific policy; recomputed from public state.
+  int threat=-1,dist=1000;
+  for(int i=0;i<P;i++)if(i!=ME&&players[i].alive){
+   auto e=players[i];int distance=abs(e.x-me.x)+abs(e.y-me.y),count=0;bool blocked=false;
+   for(auto b:bs){count+=b.owner==i;blocked|=b.x==e.x&&b.y==e.y;}
+   if(distance<=7&&distance<dist&&count<CAP&&!blocked){threat=i;dist=distance;}
+  }
+  Reach cautious=own;
+  if(threat>=0){auto e=players[threat];auto other=bs;other.push_back({threat,e.x,e.y,T+FUSE});cautious=reach(predict(other,horizon),ME);}
+  for(int d=0;d<5;d++){
+   int predicted=predict_destination(scenario,d);
+   Reach adjusted=own;
+#if MOVE_MODE != 0
+   adjusted=reach(scenario,ME,predicted);
+#endif
+   double score=adjusted.life[d]*10000;
+   if(adjusted.count[d]>0){
+    score+=.25*adjusted.utility[d]+1.1*log(1.0+adjusted.count[d])+denial;
+#ifdef AGGRESSIVE
+    if(place)score+=max(0.0,denial)*.7;
+#endif
+    int tx=me.x+DX[d],ty=me.y+DY[d],dest=cell(me.x,me.y);
+    if(tx>=0&&ty>=0&&tx<N&&ty<N&&scenario.open[0][cell(tx,ty)]&&
+       (!scenario.occupied[0][cell(tx,ty)]||dest==cell(tx,ty)))dest=cell(tx,ty);
+    dest=predicted;
+    score-=1.3*min(50,goal_distance[dest])+1.8*visits(dest);
+    if(dest==cell(me.x,me.y))score-=.6;
+
+    if(cautious.count[d]==0)score-=35+5*(horizon-cautious.life[d]);
+    else score+=.7*log(1.0+cautious.count[d]);
+    int nx=me.x+DX[d],ny=me.y+DY[d];
+    for(int i=0;i<P;i++)if(i!=ME&&players[i].alive&&players[i].x==nx&&players[i].y==ny)score-=1.5;
+   }
+#if MOVE_MODE != 0
+   int intended=cell(me.x+DX[d],me.y+DY[d]);
+   bool contested=false;
+   for(int i=0;i<P;i++)if(i!=ME&&players[i].alive&&abs(players[i].x-(me.x+DX[d]))+abs(players[i].y-(me.y+DY[d]))<=1)contested=true;
+   if(contested&&d!=4){auto blocked=reach(scenario,ME,cell(me.x,me.y));if(blocked.life[d]<horizon)score-=80;else score-=1;}
+#endif
+   score-=.002*((d+T)%5);
+   if(score>best){best=score;answer={d,place};}
+  }
+ }
+ if(answer.second)goal=-1;
+ previous_cells.clear();for(auto p:players)previous_cells.push_back(cell(p.x,p.y));
+ return answer;
+}
+bool read(){string word;if(!(cin>>word>>T))return false;cin>>word;for(auto &row:board)cin>>row;
+ for(int i=0,id;i<P;i++){cin>>word>>id;cin>>players[id].x>>players[id].y>>players[id].alive;}
+ int k;cin>>word>>k;bombs.resize(k);for(auto &b:bombs)cin>>word>>b.owner>>b.x>>b.y>>b.at;
+ cin>>word>>k;flames.resize(k);for(auto &f:flames)cin>>word>>f.x>>f.y>>f.end;
+ // This baseline keeps its strategy; consume the public score/source extension.
+ while(cin>>word){if(word=="END")return true;string line;getline(cin,line);}
+ return false;
+}
+int main(int argc,char**argv){ios::sync_with_stdio(false);cin.tie(nullptr);string word;
+ if(!(cin>>word>>N>>P>>ME>>LIMIT>>FUSE>>RANGE>>CAP>>FIRE>>SHRINK>>EVERY))return 0;
+ board.resize(N);players.resize(P);
+ while(read()){
+  if(argc>1&&string(argv[1])=="--forecast-check"){
+   auto pr=predict(bombs,min(7,LIMIT-T));for(auto &grid:pr.safe){for(int bit:grid)cout<<bit;cout<<'\n';}cout.flush();
+  }else{auto [d,b]=decide();cout<<T<<' '<<DS[d]<<' '<<b<<endl;}
+ }
+ return 0;
+}

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

@@ -0,0 +1,25 @@
+"""Read-only extraction clock; never uses archived modification time."""
+import argparse, datetime, json, os, time
+from pathlib import Path
+
+def read_clock():
+    st=Path(__file__).resolve().stat()
+    birth=getattr(st,'st_birthtime',None)
+    start=birth if birth is not None else st.st_ctime
+    now=time.time(); elapsed=max(0,now-start)
+    return dict(start_utc=datetime.datetime.fromtimestamp(start,datetime.timezone.utc).isoformat(),
+                elapsed_seconds=round(elapsed,3),remaining_seconds=round(max(0,5400-elapsed),3),
+                hard_stop_reached=elapsed>=5400,
+                source='file_birthtime' if birth is not None or os.name=='nt' else 'file_ctime')
+
+def main():
+    ap=argparse.ArgumentParser(description='Read elapsed time since extraction; writes no files.')
+    ap.add_argument('--json',action='store_true')
+    ap.add_argument('--start',action='store_true',help=argparse.SUPPRESS)
+    args=ap.parse_args(); data=read_clock()
+    if args.json: print(json.dumps(data,indent=2)); return
+    print('Elapsed: %.1f min | Remaining: %.1f min' % (data['elapsed_seconds']/60,data['remaining_seconds']/60))
+    if data['elapsed_seconds'] >= 3600 and not data['hard_stop_reached']:
+        print('60-minute target reached; finish validation and submit by 90 minutes.')
+    if data['hard_stop_reached']: print('90-minute deadline reached: submit your current bot.')
+if __name__=='__main__': main()

package/eval/arena/bomberman/workspace/engine/arena.py

@@ -0,0 +1,198 @@
+"""Match CLI: built-in bots or external persistent text-protocol processes."""
+import argparse, hashlib, json, os, platform, queue, re, subprocess, sys, threading, time, signal
+from collections import deque
+from pathlib import Path
+from engine import Game, config_for, VERSION
+
+BASE=Path(__file__).resolve().parent
+BUILTINS=set()
+
+class ProcessBot:
+    def __init__(self,cmd,header):
+        self.q=queue.Queue(maxsize=32);self.bad=threading.Event();self.writeq=queue.Queue(maxsize=2);self.failure=''
+        self.stderr_tail=deque(maxlen=16)
+        self.p=subprocess.Popen(cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,
+                                creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0),bufsize=0,
+                                start_new_session=os.name!='nt')
+        def read_stderr():
+            try:
+                while True:
+                    chunk=self.p.stderr.read(512)
+                    if not chunk: break
+                    self.stderr_tail.append(chunk)
+            except (OSError,ValueError): pass
+        threading.Thread(target=read_stderr,daemon=True).start()
+        def reader():
+            try:
+                while True:
+                    line=self.p.stdout.readline(257)
+                    if not line:
+                        # Preserve already-received valid output, then report EOF immediately.
+                        try:self.q.put_nowait((time.perf_counter(),None))
+                        except queue.Full:pass
+                        break
+                    if len(line)>256 or not line.endswith(b'\n'):self.failure='stdout_line_too_long';self.bad.set();break
+                    self.q.put_nowait((time.perf_counter(),line))
+            except (OSError,ValueError,queue.Full) as e:self.failure=type(e).__name__+' while reading stdout';self.bad.set()
+        threading.Thread(target=reader,daemon=True).start()
+        def writer():
+            try:
+                while True:
+                    data=self.writeq.get()
+                    if data is None:return
+                    data=memoryview(data)
+                    while data:
+                        written=self.p.stdin.write(data)
+                        if not written:raise OSError('stdin closed')
+                        data=data[written:]
+                    self.p.stdin.flush()
+            except (OSError,ValueError) as e:self.failure=type(e).__name__+' while writing stdin';self.bad.set()
+        threading.Thread(target=writer,daemon=True).start()
+        self.header=header
+    def send(self,text):
+        self.sent=time.perf_counter()
+        data=(self.header+text).encode('ascii');self.header=''
+        # A non-reading bot must not block the whole match on a full stdin pipe.
+        try:self.writeq.put_nowait(data)
+        except queue.Full:self.failure='stdin_backpressure';self.bad.set()
+    def receive(self,turn,limit):
+        deadline=self.sent+limit/1000
+        try:
+            if self.bad.is_set():return None,'io:'+self.failure,0
+            stamp,line=self.q.get(timeout=max(0,deadline-time.perf_counter()))
+            if line is None:return None,'stdout_closed',max(0,(stamp-self.sent)*1000)
+            if stamp<self.sent or stamp>deadline:return None,'timing',max(0,(stamp-self.sent)*1000)
+            match=re.fullmatch(rb'(0|[1-9][0-9]{0,5}) ([UDLRS]) ([01])\r?\n',line)
+            if not match or int(match[1])!=turn:return None,'protocol',(stamp-self.sent)*1000
+            return (match[2].decode(),int(match[3])),'',(stamp-self.sent)*1000
+        except queue.Empty:
+            if self.bad.is_set():return None,'io:'+self.failure,limit
+            if self.p.poll() is not None:return None,'process_exit',limit
+            return None,'timeout',limit
+    def diagnostic(self):
+        return dict(returncode=self.p.poll(),stderr_tail=b''.join(self.stderr_tail).decode('utf-8',errors='replace'))
+
+    def close(self):
+        # Terminate the bot's process group/tree, not unrelated shell or agent processes.
+        try:
+            if os.name!='nt':
+                try:os.killpg(self.p.pid,signal.SIGKILL)
+                except ProcessLookupError:pass
+            elif self.p.poll() is None:
+                try:subprocess.run(['taskkill','/PID',str(self.p.pid),'/T','/F'],stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.DEVNULL,timeout=3,creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+                except (OSError,subprocess.TimeoutExpired):pass
+            if self.p.poll() is None:self.p.kill()
+            self.p.wait(timeout=3)
+        except (OSError,subprocess.TimeoutExpired):
+            pass
+        try:self.writeq.put_nowait(None)
+        except queue.Full:pass
+        for stream in (self.p.stdin,self.p.stdout,self.p.stderr):
+            try:stream.close()
+            except (OSError,ValueError):pass
+
+def command(label):
+    p=Path(label).resolve()
+    if not p.exists():raise FileNotFoundError(p)
+    return [sys.executable,str(p)] if p.suffix=='.py' else [str(p)]
+
+def play(labels,seed=0,replay=None,move_ms=50,initial_ms=2000):
+    if not 2<=len(labels)<=10:raise ValueError('between 2 and 10 bots required')
+    if move_ms<=0 or initial_ms<=0:raise ValueError('time limits must be positive')
+    pairs=[s.split('=',1) if '=' in s else [s,s] for s in labels]
+    names=[p[0] for p in pairs];labels=[p[1] for p in pairs]
+    if any(not n for n in names) or len(set(names))!=len(names):raise ValueError('bot names must be nonempty and unique')
+    g=Game(seed,config_for(len(labels)));frames=[g.snapshot()]
+    processes={};errors=[0]*len(labels);max_ms=[0.0]*len(labels);diagnostics=[]
+    started=time.perf_counter();initial_failures=[]
+    manifest={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in [BASE/'engine.py',BASE/'arena.py']}
+    for i,label in enumerate(labels):
+        if label not in BUILTINS:
+            try:manifest[f'bot_{i}']=hashlib.sha256(Path(label).read_bytes()).hexdigest()
+            except OSError as e:manifest[f'bot_{i}']=dict(unavailable=str(e))
+    try:
+        for i,label in enumerate(labels):
+            if label not in BUILTINS:
+                try:processes[i]=ProcessBot(command(label),g.header(i))
+                except OSError as e:
+                    errors[i]+=1
+                    initial_failures.append(i);diagnostics.append(dict(turn=0,player=i,error='launch',detail=str(e)))
+        while not g.over():
+            actions=[('S',0)]*len(labels);forfeits=initial_failures[:] if g.turn==0 else []
+            requested=[None]*len(labels);timings=[None]*len(labels);turn_diagnostics=[]
+            state=g.state_text()
+            for i,b in processes.items():
+                if g.players[i]['alive']:b.send(state)
+            for i,b in processes.items():
+                if not g.players[i]['alive']:continue
+                a,err,ms=b.receive(g.turn,initial_ms if g.turn==0 else move_ms)
+                timings[i]=ms
+                max_ms[i]=max(max_ms[i],ms)
+                if err:
+                    errors[i]+=1
+                    detail=dict(turn=g.turn,player=i,error=err,**b.diagnostic())
+                    diagnostics.append(detail);turn_diagnostics.append(detail)
+                    # Fail closed on any protocol/timeout error. No stale-output resync ambiguity.
+                    forfeits.append(i)
+                else:actions[i]=a;requested[i]=a
+            frame=g.step(actions,forfeits);frame['actions']=actions;frame['forfeits']=forfeits;frames.append(frame)
+            frame.update(requested_actions=requested,response_ms=timings,diagnostics=turn_diagnostics,input_text=state)
+            for i in list(processes):
+                if not g.players[i]['alive']:processes.pop(i).close()
+        result=g.result();result.update(names=names,bot_specs=labels,errors=errors,max_ms=max_ms,diagnostics=diagnostics,
+                                       elapsed_seconds=time.perf_counter()-started,version=VERSION)
+        result['hashes']=manifest
+        result['valid_for_scoring']=not initial_failures
+        result['environment']=dict(platform=platform.platform(),python=sys.version.split()[0],executable=sys.executable,
+                                   clock='time.perf_counter (monotonic wall time)',move_ms=move_ms,initial_ms=initial_ms)
+        if replay:
+            payload=dict(version=VERSION,result=result,frames=frames)
+            path=Path(replay);path.parent.mkdir(parents=True,exist_ok=True)
+            path.with_suffix('.json').write_text(json.dumps(payload,ensure_ascii=False,separators=(',',':')),encoding='utf-8')
+            template=(BASE.parent/'viewer/index.html').read_text(encoding='utf-8')
+            safe=json.dumps(payload,ensure_ascii=False,separators=(',',':')).replace('<','\\u003c')
+            path.with_suffix('.html').write_text(template.replace('/*REPLAY_DATA*/null',safe),encoding='utf-8')
+        return result
+    finally:
+        for b in processes.values():b.close()
+
+def inspect_replay(path, turn=0, context=2):
+    """Plain-text replay inspection; never executes a bot or loads its code."""
+    data=json.loads(Path(path).read_text(encoding='utf-8'))
+    frames=data['frames'];names=data['result']['names']
+    if context<0 or context>20:raise ValueError('context must be between 0 and 20')
+    if not 0<=turn<len(frames)-1:raise ValueError(f'action turn must be 0..{len(frames)-2}')
+    lines=[f"REPLAY {data.get('version','?')} | seed={data['result']['seed']}",
+           'Coordinates: x right, y down, zero-based. Each block shows the board BEFORE the action.',
+           'Requested action is distinct from actual movement. Internal intentions/search are not recorded.']
+    for i in range(max(0,turn-context),min(len(frames)-1,turn+context+1)):
+        before,after=frames[i],frames[i+1]
+        lines += ['',f'ACTION {before["turn"]} -> STATE {after["turn"]}',
+                  '    '+''.join(str(x%10) for x in range(len(before['board'][0])))]
+        lines += [f'{y:02d}  {row}' for y,row in enumerate(before['board'])]
+        for j,(a,b) in enumerate(zip(before['players'],after['players'])):
+            if not a['alive']:continue
+            action=after.get('requested_actions',after.get('actions',[]))
+            request=f'{action[j][0]} place={action[j][1]}' if j<len(action) and action[j] is not None else 'no valid response'
+            lines.append(f'P{j} {names[j]}: ({a["x"]},{a["y"]}) requested {request}; actual ({b["x"]},{b["y"]}); alive={b["alive"]}; reason={b.get("reason","")}')
+        lines.append('BOMBS before: '+json.dumps(before['bombs'],ensure_ascii=False))
+        lines.append('FLAMES before [x,y,last_lethal_turn]: '+json.dumps(before['flames'],ensure_ascii=False))
+        lines.append('EVENTS after: '+json.dumps(after.get('events',[]),ensure_ascii=False))
+        lines.append('DIAGNOSTICS: '+json.dumps(after.get('diagnostics',[]),ensure_ascii=False))
+    return '\n'.join(lines)
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--bots',nargs='+',default=[])
+    ap.add_argument('--seed',type=int,default=1);ap.add_argument('--replay',default='replays/demo.html')
+    ap.add_argument('--move-ms',type=int,default=50);ap.add_argument('--initial-ms',type=int,default=2000)
+    ap.add_argument('--inspect',help='inspect a saved replay as plain text; does not run a match')
+    ap.add_argument('--turn',type=int,default=0);ap.add_argument('--context',type=int,default=2)
+    args=ap.parse_args()
+    if args.inspect:
+        try:print(inspect_replay(args.inspect,args.turn,args.context))
+        except (OSError,ValueError,KeyError,IndexError) as e:ap.error(str(e))
+        return
+    if not 2<=len(args.bots)<=10:ap.error('between 2 and 10 bots required')
+    print(json.dumps(play(args.bots,args.seed,args.replay,args.move_ms,args.initial_ms),ensure_ascii=False,indent=2))
+if __name__=='__main__':main()

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

@@ -0,0 +1,35 @@
+"""Compile a bot with an existing compiler; never run the compiled program."""
+import argparse,json,os,platform,shutil,subprocess,sys,tempfile,time
+from pathlib import Path
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--compile',action='store_true');ap.add_argument('--output',default='bot.exe' if os.name=='nt' else 'bot')
+    ap.add_argument('--source',default='baseline.cpp',help='C++ source to compile')
+    args=ap.parse_args();base=Path(__file__).resolve().parent.parent
+    compiler=os.environ.get('CXX') or shutil.which('g++') or shutil.which('clang++')
+    if not compiler and os.name=='nt':  # 没加进 PATH 的 w64devkit：仓库根目录下的 tools/，或 C 盘根目录
+        for root in [*(a/'tools' for a in base.parents),Path('C:/')]:
+            guess=root/'w64devkit/bin/g++.exe'
+            if guess.is_file():compiler=str(guess);break
+    info=dict(python=sys.executable,version=sys.version.split()[0],platform=platform.platform(),
+              standard_library_only=True,compiler=compiler,clock=time.get_clock_info('perf_counter').__dict__)
+    try:
+        with tempfile.TemporaryFile(dir=base) as f:f.write(b'probe');f.flush()
+        info['workspace_writable']=True
+    except OSError as e:info['workspace_writable']=False;info['write_error']=str(e)
+    if args.compile:
+        if not compiler:raise SystemExit('No C++ compiler found. Report the environment failure; do not install software or change permissions.')
+        cmd=[compiler,'-std=c++20','-O2',str(base/args.source),'-o',str(Path(args.output).resolve())]
+        if os.name=='nt':cmd.insert(1,'-static')
+        try:
+            subprocess.run(cmd,check=True,timeout=60)
+        except subprocess.TimeoutExpired:
+            raise SystemExit('Compilation exceeded 60 seconds; no bot was launched.')
+        except subprocess.CalledProcessError as e:
+            raise SystemExit(f'Compiler failed with exit code {e.returncode}; see diagnostics above.')
+        except OSError as e:
+            raise SystemExit(f'Cannot start compiler: {e}')
+        info['compiled_program']=str(Path(args.output).resolve())
+    print(json.dumps(info,ensure_ascii=False,indent=2))
+    if sys.version_info<(3,10) or not info['workspace_writable']:raise SystemExit(1)
+if __name__=='__main__':main()