dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/tank/bots/half1/gpt-6-astra.cpp

@@ -0,0 +1,233 @@
+// First-half entry: weighted terrain routing, joint task allocation,
+// simultaneous-action matrix search and exact three-turn tactical rollouts.
+// Search keeps a legal one-turn fallback and checks the CPU budget.
+#include "tank.hpp"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <queue>
+#include <vector>
+#include <cstdio>
+using namespace tank;
+namespace ai {
+constexpr float INF=10000;
+struct Context { float field[6][CELLS]; float attack[2][2][CELLS]; float sd[2][MAX_SUPPLY][CELLS]; float ed[6][CELLS]; int occ[CELLS]; float wallval[CELLS]; int walls[CELLS],nw; uint64_t wh; int me; } ctx;
+int hist[6][CELLS];
+unsigned rng=7123671;
+unsigned rnd(){rng^=rng<<13;rng^=rng>>17;rng^=rng<<5;return rng;}
+int md(int a,int b){return std::abs(cell_x(a)-cell_x(b))+std::abs(cell_y(a)-cell_y(b));}
+void dijkstra(const State&s,float* d,bool steel,float speed){
+ using P=std::pair<float,int>;std::priority_queue<P,std::vector<P>,std::greater<P>>q;
+ for(int y=0;y<s.P.size;y++)for(int x=0;x<s.P.size;x++){int c=cell_of(x,y);if(d[c]<INF)q.push({d[c],c});}
+ while(!q.empty()){auto [v,c]=q.top();q.pop();if(v>d[c]+.001)continue;
+  int gc=s.grid[c];float cost=1/speed+(gc==BRICK?1.8f:gc==STEEL?2.0f:0);
+  for(int k=0;k<4;k++){int n=c+DIR_DELTA[k],g=s.grid[n];if(g!=EMPTY&&g!=BRICK&&!(g==STEEL&&steel))continue;
+   float nv=v+cost;if(nv<d[n]){d[n]=nv;q.push({nv,n});}}
+ }
+}
+void setup(const State&s,int me){
+ ctx.me=me;ctx.nw=0;ctx.wh=s.wall_hash;std::fill(ctx.occ,ctx.occ+CELLS,-1);for(int i=0;i<6;i++)if(s.tank[i].alive)ctx.occ[s.tank[i].pos]=i;
+ for(int seat=0;seat<2;seat++)for(int st=0;st<2;st++){
+  float* d=ctx.attack[seat][st];std::fill(d,d+CELLS,INF);
+  int base=s.base_pos[1-seat];
+  for(int dir=0;dir<4;dir++){float cost=0;int len=0;for(int c=base+DIR_DELTA[dir];s.grid[c]!=OUTSIDE;c+=DIR_DELTA[dir]){
+   int g=s.grid[c];if(g==BASE0||g==BASE1||(g==STEEL&&!st))break;len++;cost+=(g==BRICK||g==STEEL)?1.9f:0;
+   if(g!=WATER)d[c]=cost+len*.75f;
+   int blocker=ctx.occ[c];if(blocker>=0)cost+=(blocker/3==seat?2.0f:6.0f);}}
+  dijkstra(s,d,st,1);
+ }
+ for(int st=0;st<2;st++)for(int k=0;k<s.n_supply;k++){float*d=ctx.sd[st][k];std::fill(d,d+CELLS,INF);d[s.supply[k]]=0;dijkstra(s,d,st,1);}
+
+ for(int j=0;j<6;j++){
+  float*d=ctx.ed[j];std::fill(d,d+CELLS,INF);if(!s.tank[j].alive)continue;
+  int p=s.tank[j].pos;d[p]=1;
+  for(int k=0;k<4;k++)for(int n=1,c=p+DIR_DELTA[k];n<=5;n++,c+=DIR_DELTA[k]){
+   if(s.grid[c]!=EMPTY&&s.grid[c]!=WATER)break;
+   if(s.grid[c]==EMPTY)d[c]=n*.65f;
+  }
+  dijkstra(s,d,false,1);
+ }
+ for(int seat=0;seat<2;seat++){
+  float util[3][8];
+  for(int t=0;t<3;t++){int i=3*seat+t;const Tank&a=s.tank[i];int p=a.alive?a.pos:s.spawn[i];float speed=t==0?1.65f:1;
+   util[t][0]=34-1.6f*ctx.attack[seat][a.level>=2][p]/speed;
+   for(int k=0;k<s.n_supply;k++){
+    float dis=ctx.sd[a.level>=2][k][p]/speed;
+    int wait=(s.star_mask>>k&1)?0:(s.turn<10?11-s.turn:21-(s.turn-10)%20);
+    float val=33-2.25f*dis-3.6f*std::max(0.0f,wait-dis);
+    if(a.level>=2)val=-1000;
+    if(a.level==0)val+=7;else val-=12;
+    if(t==0)val+=3;
+    util[t][k+1]=val;
+   }
+   for(int e=0;e<3;e++){
+    int j=(1-seat)*3+e;float bd=ctx.attack[1-seat][s.tank[j].level>=2][s.tank[j].pos];
+    int home=md(s.tank[j].pos,s.base_pos[seat]);float threat=std::max(0,8-home)*4.5f;
+    float dis=ctx.ed[j][p]/speed;
+    util[t][s.n_supply+1+e]=s.tank[j].alive&&home<=7?40+threat-2.5f*dis:-1000;
+   }
+  }
+  int goals[3]={};float best=-1e9;
+  for(int a=0;a<=s.n_supply+3;a++)for(int b=0;b<=s.n_supply+3;b++)for(int c=0;c<=s.n_supply+3;c++){
+   if((a&&a==b)||(a&&a==c)||(b&&b==c))continue;
+   int nd=(a>s.n_supply)+(b>s.n_supply)+(c>s.n_supply);
+   float v=util[0][a]+util[1][b]+util[2][c]-std::max(0,nd-1)*24;if(v>best){best=v;goals[0]=a;goals[1]=b;goals[2]=c;}}
+  for(int t=0;t<3;t++){int i=seat*3+t;const Tank&a=s.tank[i];float speed=t==0?1.65f:1;int goal=goals[t];
+   for(int c=0;c<CELLS;c++){
+    float atk=34-1.6f*std::min(40.f,ctx.attack[seat][a.level>=2][c]/speed);
+    float v=atk;
+    if(goal&&goal<=s.n_supply){int k=goal-1;float dis=ctx.sd[a.level>=2][k][c]/speed;v=47-2.25f*std::min(40.f,dis);}
+    if(goal>s.n_supply){int j=(1-seat)*3+goal-s.n_supply-1;v=50-2.5f*std::min(40.f,ctx.ed[j][c]/speed);}
+    ctx.field[i][c]=v;
+   }
+  }
+ }
+ // Credit terrain changes immediately, including bullets consumed this turn.
+ for(int c=0;c<CELLS;c++)if(s.grid[c]==BRICK||s.grid[c]==STEEL){
+  ctx.walls[ctx.nw++]=c;float vv[2]={};
+  for(int i=0;i<6;i++)if(s.tank[i].alive){int p=s.tank[i].pos;int d=md(p,c);float gain=ctx.field[i][c]-ctx.field[i][p];
+   if(d<=6&&gain>0)vv[i/3]=std::max(vv[i/3],3.8f+gain*.45f-std::max(0,d-2)*.6f);
+  }
+  if(md(c,s.base_pos[0])<=2)vv[1]+=7;
+  if(md(c,s.base_pos[1])<=2)vv[0]+=7;
+  ctx.wallval[c]=vv[0]-vv[1];
+ }
+}
+float bulletval(const State&s,const Bullet&b){
+ int seat=seat_of(b.owner),pos=b.pos;
+ float val=0;
+ for(int n=1;n<=s.P.size+1;n++){
+  pos+=DIR_DELTA[b.dir];int g=s.grid[pos];if(g==OUTSIDE)break;
+  if(g==BRICK||(g==STEEL&&b.steel)){
+   float gain=ctx.wallval[pos]*(seat==0?1:-1);
+   val=gain;break;
+  }
+  if(g==STEEL)break;
+  if(g==BASE0||g==BASE1){int side=g-BASE0;val=(side!=seat?1.f:-1.f)*135.f/(1+.035f*n);break;}
+  int hit=tank_at(s,pos);
+  if(hit>=0){
+   int free=0;for(int k=0;k<4;k++)if((k/2)!=(b.dir/2)&&s.grid[pos+DIR_DELTA[k]]==EMPTY&&tank_at(s,pos+DIR_DELTA[k])<0)free++;
+   float p=(n<=2?.36f:.20f);if(free==0)p=.8f;
+   if(can_fire(s,hit))p*=.55f;
+   float damage=16+(s.tank[hit].hp==1?45.f:0);
+   val=damage*p*(seat_of(hit)==seat?-1.f:1.f);break;
+  }
+ }
+ return seat==0?val:-val;
+}
+float eval(const State&s){
+ if(s.done)return s.winner==0?1e6f:s.winner==1?-1e6f:0;
+ float z=(s.base_hp[0]-s.base_hp[1])*180.f+(s.kills[0]-s.kills[1])*28.f+(s.stars_eaten[0]-s.stars_eaten[1])*2;
+ for(int i=0;i<6;i++){
+  const Tank&t=s.tank[i];float v;
+  if(!t.alive)v=-3*respawn_in(s,i);
+  else {
+   v=40+t.hp*15+t.level*8+ctx.field[i][t.pos];
+   if(can_fire(s,i))v+=1.4f;
+   int base=s.base_pos[1-i/3];int dir=-1;
+   if(cell_x(base)==cell_x(t.pos))dir=base>t.pos?DOWN:UP;
+   if(cell_y(base)==cell_y(t.pos))dir=base>t.pos?RIGHT:LEFT;
+   if(dir>=0){
+    bool clear=true;int dis=md(base,t.pos);
+    for(int c=t.pos+DIR_DELTA[dir];c!=base;c+=DIR_DELTA[dir])if(s.grid[c]==BRICK||s.grid[c]==STEEL||tank_at(s,c)>=0){clear=false;break;}
+    if(clear)v+=100.f/(1+dis*.35f)*(t.level==0&&i%3!=FIRE?.8f:1.f);
+   }
+   for(int j=0;j<6;j++)if(seat_of(j)!=seat_of(i)&&!s.tank[j].alive&&s.spawn[j]==t.pos)v-=respawn_in(s,j)<=1?100:15;
+   // Only a modest exploration penalty; do not abandon productive siege squares.
+   v-=std::min(8,hist[i][t.pos])*.11f;
+  }
+  z+=(i<3?v:-v);
+ }
+ if(s.wall_hash!=ctx.wh)for(int k=0;k<ctx.nw;k++){int c=ctx.walls[k];if(s.grid[c]==EMPTY)z+=ctx.wallval[c];}
+ for(int k=0;k<s.n_bullets;k++)z+=bulletval(s,s.bullet[k]);
+ return z;
+}
+float value(const State&s,int seat,const Orders&a,const Orders&b){State n=s;step_as(n,seat,a,b);float v=eval(n);return seat==0?v:-v;}
+struct Choice {Cmd c;float v;};
+struct Pool{std::vector<Orders> a;void add(Orders x){for(auto y:a)if(x==y)return;a.push_back(x);}};
+Orders improve(const State&s,int seat,Orders own,const Orders&enemy, std::array<std::vector<Choice>,3>*rank=nullptr){
+ for(int t=0;t<3;t++){
+  Cmd cmds[N_CMDS];int n=legal_commands(s,seat*3+t,cmds);float best=-1e20;Cmd bc=0;std::vector<Choice>ls;
+  for(int k=0;k<n;k++){Orders a=own;a.cmd[t]=cmds[k];float v=value(s,seat,a,enemy);ls.push_back({cmds[k],v});if(v>best+1e-4){best=v;bc=cmds[k];}}
+  own.cmd[t]=bc;
+  if(rank){std::sort(ls.begin(),ls.end(),[](Choice a,Choice b){return a.v>b.v;});(*rank)[t]=ls;}
+ }
+ return own;
+}
+}
+void init(const State&s,int me){using namespace ai;for(auto &row:hist)std::fill(row,row+CELLS,0);rng=7123671+me;}
+Orders decide(const State&s,int me){
+ using namespace ai;setup(s,me);
+ for(int i=0;i<6;i++)if(s.tank[i].alive)hist[i][s.tank[i].pos]++;
+ Orders a,b;
+ a=improve(s,me,a,b);b=improve(s,1-me,b,a);
+ Pool pa,pb;pa.add(a);pb.add(b);pb.add(Orders{});
+ std::array<std::vector<Choice>,3> ra,rb;
+ for(int it=0;it<3;it++){
+  a=improve(s,me,a,b,&ra);pa.add(a);
+  b=improve(s,1-me,b,a,&rb);pb.add(b);
+ }
+ for(int t=0;t<3;t++){
+  for(int k=0;k<std::min(4,(int)ra[t].size());k++){Orders x=a;x.cmd[t]=ra[t][k].c;pa.add(x);}
+  for(int k=0;k<std::min(4,(int)rb[t].size());k++){Orders x=b;x.cmd[t]=rb[t][k].c;pb.add(x);}
+ }
+ // Include coordinated variants; a single best reply cannot express simultaneous dodges.
+ for(int k=0;k<9;k++){
+  Orders x=a,y=b;for(int t=0;t<3;t++){int r=(k/(t==0?1:t==1?3:1)+t)%3;if(r<(int)ra[t].size())x.cmd[t]=ra[t][r].c;if(r<(int)rb[t].size())y.cmd[t]=rb[t][r].c;}pa.add(x);pb.add(y);
+ }
+ int na=pa.a.size(),nb=pb.a.size();float mat[32][32];
+ for(int i=0;i<na;i++)for(int j=0;j<nb;j++)mat[i][j]=value(s,me,pa.a[i],pb.a[j]);
+ // Fictitious play gives a robust mixed policy for the simultaneous-action game.
+ float sa[32]={},sb[32]={};int ca[32]={},cb[32]={};int bi=0,bj=0;
+ for(int it=0;it<160;it++){
+  ca[bi]++;cb[bj]++;
+  for(int i=0;i<na;i++)sa[i]+=mat[i][bj];
+  for(int j=0;j<nb;j++)sb[j]+=mat[bi][j];
+  bi=0;bj=0;for(int i=1;i<na;i++)if(sa[i]>sa[bi])bi=i;for(int j=1;j<nb;j++)if(sb[j]<sb[bj])bj=j;
+ }
+ int sel=0;float bv=-1e20;
+ for(int i=0;i<na;i++){
+  float v=0,w=1e20;for(int j=0;j<nb;j++){v+=mat[i][j]*cb[j]/160.f;w=std::min(w,mat[i][j]);}
+  v=.85f*v+.15f*w;
+  if(v>bv){bv=v;sel=i;}
+ }
+
+ // Extend the most relevant simultaneous choices through three full turns.
+ std::vector<int> ia,ib;
+ for(int i=0;i<na;i++)ia.push_back(i);
+ for(int j=0;j<nb;j++)ib.push_back(j);
+ float ar[64]={},br[64]={};
+ for(int i=0;i<na;i++){float w=1e20;for(int j=0;j<nb;j++){ar[i]+=mat[i][j]*cb[j]/160.f;w=std::min(w,mat[i][j]);}ar[i]=ar[i]*.85f+.15f*w;}
+ for(int j=0;j<nb;j++){float w=-1e20;for(int i=0;i<na;i++){br[j]+=mat[i][j]*ca[i]/160.f;w=std::max(w,mat[i][j]);}br[j]=br[j]*.85f+.15f*w;}
+ std::sort(ia.begin(),ia.end(),[&](int x,int y){return ar[x]>ar[y];});
+ std::sort(ib.begin(),ib.end(),[&](int x,int y){return br[x]<br[y];});
+ ia.erase(std::remove(ia.begin(),ia.end(),sel),ia.end());ia.insert(ia.begin(),sel);
+ ia.resize(std::min(12,(int)ia.size()));ib.resize(std::min(10,(int)ib.size()));
+ float deep[12][12];int nr=ia.size(),nc=ib.size();
+ for(int x=0;x<nr;x++)for(int y=0;y<nc;y++){
+  if(budget_left()<6)return pa.a[sel];
+  State n=s;step_as(n,me,pa.a[ia[x]],pb.a[ib[y]]);
+  float v=eval(n)*(me==0?1:-1)*.25f;
+  for(int depth=0;depth<2&&!n.done;depth++){
+   Orders aa,bb;
+   aa=improve(n,me,aa,bb);bb=improve(n,1-me,bb,aa);
+   Orders aa2=improve(n,me,aa,bb);
+   step_as(n,me,aa2,bb);
+   v+=eval(n)*(me==0?1:-1)*(depth==0?.30f:.45f);
+  }
+  deep[x][y]=n.done?eval(n)*(me==0?1:-1):v;
+ }
+ std::fill(sa,sa+32,0);std::fill(sb,sb+32,0);std::fill(ca,ca+32,0);std::fill(cb,cb+32,0);bi=bj=0;
+ for(int it=0;it<200;it++){
+  ca[bi]++;cb[bj]++;
+  for(int i=0;i<nr;i++)sa[i]+=deep[i][bj];
+  for(int j=0;j<nc;j++)sb[j]+=deep[bi][j];
+  bi=bj=0;for(int i=1;i<nr;i++)if(sa[i]>sa[bi])bi=i;for(int j=1;j<nc;j++)if(sb[j]<sb[bj])bj=j;
+ }
+ bv=-1e20;
+ for(int i=0;i<nr;i++){
+  float v=0,w=1e20;for(int j=0;j<nc;j++){v+=deep[i][j]*cb[j]/200.f;w=std::min(w,deep[i][j]);}
+  v=.85f*v+.15f*w;if(v>bv){bv=v;sel=ia[i];}
+ }
+ return pa.a[sel];
+}

package/eval/arena/tank/bots/half1/gpt-6.1-sol-ultrafast.cpp

@@ -0,0 +1,350 @@
+// Tank battle: coordinated supply control, a committed fast flanker, and adaptive defenders.
+// Dijkstra fields provide strategic guidance. Joint orders are evaluated with the exact engine.
+// Quiet positions use three-turn rollouts and double-oracle response expansion; close combat
+// uses a nested simultaneous-action matrix game. All searches retain a legal budget fallback.
+#include "tank.hpp"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <queue>
+#include <utility>
+#include <vector>
+#include <cstdio>
+#include <unordered_map>
+using namespace tank;
+namespace bot {
+constexpr float INF=10000;
+float bd[6][CELLS], sd[6][MAX_SUPPLY][CELLS], hd[6][3][CELLS], field[6][CELLS];
+int goal[6], previous[6];float anchor[6];
+uint64_t rng=123456789;
+uint64_t random64(){rng^=rng<<13;rng^=rng>>7;rng^=rng<<17;return rng;}
+float rand01(){return (random64()>>40)*(1.0f/16777216);}
+int md(int a,int b){return std::abs(cell_x(a)-cell_x(b))+std::abs(cell_y(a)-cell_y(b));}
+int direction(int a,int b){if(a==b)return -1;if(cell_x(a)==cell_x(b))return a>b?0:1;if(cell_y(a)==cell_y(b))return a>b?2:3;return -1;}
+bool clear(const State&s,int a,int b){int d=direction(a,b);if(d<0)return false;for(int p=a+DIR_DELTA[d];p!=b;p+=DIR_DELTA[d])if(s.grid[p]!=EMPTY&&s.grid[p]!=WATER)return false;return true;}
+void dijkstra(const State&s,int i,float *dist,const std::vector<std::pair<int,float>>& seeds){
+ for(int p=0;p<CELLS;p++)dist[p]=INF;
+ using Node=std::pair<float,int>;
+ std::priority_queue<Node,std::vector<Node>,std::greater<Node>>q;
+ for(auto [p,v]:seeds)if(v<dist[p]){dist[p]=v;q.emplace(v,p);}
+ float walk=type_of(i)==FAST?.58f:1.f;
+ while(!q.empty()){
+  auto [v,p]=q.top();q.pop();if(v>dist[p]+.001f)continue;
+  int g=s.grid[p];float extra=g==BRICK?2.f:g==STEEL?3.f:0.f;
+  for(int d=0;d<4;d++){
+   int n=p+DIR_DELTA[d];if(n<0||n>=CELLS)continue;
+   int ng=s.grid[n];if(ng==OUTSIDE||ng==WATER||ng==BASE0||ng==BASE1||(ng==STEEL&&s.tank[i].level<2))continue;
+   float nv=v+walk+extra;
+   if(nv<dist[n]){dist[n]=nv;q.emplace(nv,n);}
+  }
+ }
+}
+void prepare(const State&s){
+ for(int i=0;i<6;i++){
+  int side=seat_of(i),base=s.base_pos[1-side];std::vector<std::pair<int,float>> seeds;
+  for(int d=0;d<4;d++){
+   int walls=0,range=0;
+   for(int p=base+DIR_DELTA[d];p>=0&&p<CELLS;p+=DIR_DELTA[d]){
+    int g=s.grid[p];if(g==OUTSIDE||g==BASE0||g==BASE1||(g==STEEL&&s.tank[i].level<2))break;
+    range++;if(g==BRICK||g==STEEL)walls++;
+    if(g!=WATER)seeds.emplace_back(p,range*(type_of(i)==FAST?1.45f:.85f)+walls*2.0f+((type_of(i)==FAST&&d<2)?5.f:0.f));
+   }
+  }
+  dijkstra(s,i,bd[i],seeds);
+  for(int k=0;k<s.n_supply;k++)dijkstra(s,i,sd[i][k],{{s.supply[k],0}});
+ }
+ for(int i=0;i<6;i++)for(int t=0;t<3;t++){
+  int j=(1-seat_of(i))*3+t,p=s.tank[j].pos;
+  std::vector<std::pair<int,float>> seeds;
+  if(s.tank[j].alive)for(int d=0;d<4;d++)for(int range=1;range<=5;range++){
+   int q=p+DIR_DELTA[d]*range;if(q<0||q>=CELLS||s.grid[q]==OUTSIDE)break;
+   int g=s.grid[q];if(g==BASE0||g==BASE1)break;if(g==STEEL&&s.tank[i].level<2)break;
+   if(g==EMPTY||g==BRICK||g==STEEL)seeds.emplace_back(q,1.0f*range+(g==EMPTY?0.f:2.f));
+   if(g==BRICK||g==STEEL)break;
+  }
+  dijkstra(s,i,hd[i][t],seeds);
+ }
+ for(int side=0;side<2;side++){
+  float options[3][7];int next=s.turn<10?10-s.turn:20-(s.turn-10)%20;
+  for(int t=0;t<3;t++){
+   int i=side*3+t;int p=s.tank[i].alive?s.tank[i].pos:s.spawn[i];
+   options[t][0]=-bd[i][p]*.65f;
+   for(int k=0;k<s.n_supply;k++){
+    float wait=(s.star_mask&(1<<k))?0.f:float(next+1);
+    float eta=sd[i][k][p],enemy=INF;
+    for(int j=(1-side)*3;j<(1-side)*3+3;j++)if(s.tank[j].alive&&s.tank[j].level<2)enemy=std::min(enemy,sd[j][k][s.tank[j].pos]);
+    float value=(s.tank[i].level==0?17.f:0.f)-1.5f*std::max(eta,wait);
+    if(enemy+1<eta&&wait<eta)value-=std::min(10.f,(eta-enemy)*2.f);
+    if(!s.tank[i].alive)value=-INF;
+    if(s.tank[i].level>=2)value=-INF;
+    options[t][k+1]=value;
+   }
+   for(int e=0;e<3;e++){
+    int j=(1-side)*3+e;
+    float threat=-INF;
+    if(s.tank[j].alive){
+     int dist=md(s.tank[j].pos,s.base_pos[side]);
+     if(dist<=7){threat=27.f-2.f*dist+3.f*s.tank[j].level;
+      if(clear(s,s.tank[j].pos,s.base_pos[side]))threat+=18.f;
+     }
+    }
+    options[t][4+e]=threat-1.5f*hd[i][e][p];
+    if(t==0||!s.tank[i].alive)options[t][4+e]=-INF;
+   }
+  }
+  float best=-INF*10;int choice[3]={};
+  for(int a=0;a<7;a++)for(int b=0;b<7;b++)for(int c=0;c<7;c++){
+   if((a&&a==b)||(a&&a==c)||(b&&b==c))continue;
+   float v=options[0][a]+options[1][b]+options[2][c];
+   if(v>best){best=v;choice[0]=a;choice[1]=b;choice[2]=c;}
+  }
+  for(int t=0;t<3;t++){
+   int i=side*3+t;goal[i]=choice[t]-1;
+   for(int p=0;p<CELLS;p++)field[i][p]=goal[i]<0?-bd[i][p]:goal[i]<3?-sd[i][goal[i]][p]:-hd[i][goal[i]-3][p];
+  }
+ }
+}
+float projectile(const State&s,const Bullet&b){
+ int side=seat_of(b.owner),p=b.pos,steps=0;
+ for(;;){
+  if(p<0||p>=CELLS)return 0;
+  int g=s.grid[p];
+  if(g==OUTSIDE||g==BRICK||g==STEEL)return 0;
+  if(g==BASE0||g==BASE1){
+   float value=60.f/(1.f+.08f*steps);
+   for(int j=0;j<6;j++)if(seat_of(j)!=side&&s.tank[j].alive){int dd=md(s.tank[j].pos,p);if(dd<steps/2+2)value*=.72f;}
+   return (g-BASE0==side?-1.f:1.f)*value;
+  }
+  for(int j=0;j<6;j++)if(s.tank[j].alive&&s.tank[j].pos==p){
+   int escapes=0;for(int d=0;d<4;d++){int n=p+DIR_DELTA[d];if(s.grid[n]==EMPTY&&tank_at(s,n)<0)escapes++;}
+   float value=(s.tank[j].hp==1?19.f:9.f)/(1.f+.35f*steps);
+   if(steps>0)value*=escapes? .3f:.9f;
+   if(steps>0&&can_fire(s,j)&&direction(p,b.pos)>=0)value*=.6f;
+   return (seat_of(j)==side?-1.f:1.f)*value;
+  }
+  p+=DIR_DELTA[b.dir];steps++;
+ }
+}
+float evaluate(const State&s,int side){
+ if(s.done)return s.winner<0?0.f:(s.winner==side?100000.f:-100000.f);
+ float v=140.f*(s.base_hp[side]-s.base_hp[1-side])+30.f*(s.kills[side]-s.kills[1-side])+4.f*(s.stars_eaten[side]-s.stars_eaten[1-side]);
+ for(int i=0;i<6;i++){
+  auto&t=s.tank[i];float val;
+  if(t.alive){
+   val=34.f+11.f*t.hp+14.f*t.level;
+   val+=5.f*(std::max(-45.f,field[i][t.pos])-anchor[i]);
+   if(clear(s,t.pos,s.base_pos[1-seat_of(i)]))val+=25.f/(1.f+.18f*md(t.pos,s.base_pos[1-seat_of(i)]));
+  }else val=-4.f*respawn_in(s,i)-20.f;
+  v+=(seat_of(i)==side?1.f:-1.f)*val;
+ }
+ for(int k=0;k<s.n_bullets;k++)v+=(seat_of(s.bullet[k].owner)==side?1.f:-1.f)*projectile(s,s.bullet[k]);
+ return v;
+}
+void path(const State&s,int i,Cmd c,int&p1,int&p2){
+ p1=p2=s.tank[i].pos;
+ int d1=-1,d2=-1;if(is_move(c))d1=c-1;else if(is_move2(c)){d1=(c-9)/4;d2=(c-9)%4;}
+ if(d1>=0){int n=p1+DIR_DELTA[d1];if(s.grid[n]==EMPTY&&tank_at(s,n)<0)p1=n;}
+ p2=p1;if(d2>=0){int n=p2+DIR_DELTA[d2];if(s.grid[n]==EMPTY&&tank_at(s,n)<0)p2=n;}
+}
+float shot_value(const State&s,int i,int d){
+ int p=s.tank[i].pos,side=seat_of(i),steps=0;
+ for(int n=p+DIR_DELTA[d];;n+=DIR_DELTA[d]){
+  steps++;int g=s.grid[n];if(g==OUTSIDE)return 0;
+  if(g==BASE0||g==BASE1)return g-BASE0==side?-200.f:70.f/(1.f+.08f*steps);
+  int j=tank_at(s,n);
+  if(j>=0){
+   if(seat_of(j)==side)return -25.f/(1.f+.1f*steps);
+   int exits=0;for(int k=0;k<4;k++)if(s.grid[n+DIR_DELTA[k]]==EMPTY&&tank_at(s,n+DIR_DELTA[k])<0)exits++;
+   float value=(s.tank[j].hp==1?20.f:13.f)/(1+.35f*steps);
+   if(exits>1)value*=.65f;
+   if(can_fire(s,j))value*=.65f;
+   return value;
+  }
+  if(g==BRICK||g==STEEL){
+   if(g==STEEL&&s.tank[i].level<2)return 0;
+   float gain=field[i][n]-field[i][p];
+   float value=std::max(0.f,2.0f*gain-1.f)/(1.f+.2f*steps);
+   int base=s.base_pos[1-side];
+   if(direction(p,base)==d){
+    bool line=true;for(int q=n+DIR_DELTA[d];q!=base;q+=DIR_DELTA[d]){if(s.grid[q]==OUTSIDE||(s.grid[q]==STEEL&&s.tank[i].level<2)){line=false;break;}}
+    if(line)value+=12.f/(1.f+.1f*md(p,base));
+   }
+   int own=s.base_pos[side];if(md(n,own)<=2&&md(p,own)<6)value-=8.f;
+   return value;
+  }
+ }
+}
+float primitive(const State&s,int i,Cmd c){
+ if(!s.tank[i].alive)return 0;
+ int p=s.tank[i].pos,p1,p2;path(s,i,c,p1,p2);
+ float val=3.2f*(field[i][p2]-field[i][p]);
+ bool fire=is_fire(c)&&can_fire(s,i);int fd=fire?c-5:-1;
+ if(fire)val+=shot_value(s,i,fd);
+ if(c==STAY)val-=.12f;
+ if(p2==p&&is_move(c))val-=.4f;
+ int damage=0;
+ for(int k=0;k<s.n_bullets;k++){
+  const auto&b=s.bullet[k];int n=b.pos+DIR_DELTA[b.dir],nn=n+DIR_DELTA[b.dir];
+  bool cancel=false;
+  if(fire){int f1=p+DIR_DELTA[fd],f2=f1+DIR_DELTA[fd];cancel=(f1==n)||(f1==b.pos&&n==p)||(f2==nn)||(f2==n&&nn==f1);}
+  if(cancel)continue;
+  bool hit=n==p1||(n==p&&b.pos==p1);
+  if(!hit&&s.grid[n]!=BRICK&&s.grid[n]!=STEEL&&s.grid[n]!=OUTSIDE&&tank_at(s,n)<0)hit=nn==p2||(nn==p1&&n==p2);
+  if(hit)damage++;
+ }
+ if(damage)val-=damage*17.f+(damage>=s.tank[i].hp?65.f+15*s.tank[i].level:0.f);
+ for(int j=0;j<6;j++)if(seat_of(i)!=seat_of(j)&&s.tank[j].alive&&can_fire(s,j)){
+  int e=s.tank[j].pos;
+  for(int d=0;d<4;d++){
+   int n=e+DIR_DELTA[d],nn=n+DIR_DELTA[d];
+   bool hit=(n==p1)||(nn==p2&&s.grid[n]!=BRICK&&s.grid[n]!=STEEL&&tank_at(s,n)<0)||(p1==e&&n==p);
+   if(hit){if(fire&&fd==(d^1)&&direction(p,e)==fd)continue;val-=(s.tank[i].hp==1?17.f:7.f);}
+  }
+ }
+ for(int j=0;j<6;j++)if(seat_of(j)!=seat_of(i)&&!s.tank[j].alive&&s.spawn[j]==p2&&respawn_in(s,j)<=1)val-=200;
+ if(goal[i]>=0&&goal[i]<3&&p2==s.supply[goal[i]]&&s.tank[i].level<2&&(s.star_mask&(1<<goal[i])))val+=28;
+ if(p2==previous[i]&&p2!=p)val-=.18f;
+ return val;
+}
+struct Rated {Cmd c;float v;};
+struct Plan {Orders o;float v;};
+std::vector<Rated> ranked(const State&s,int i){
+ Cmd a[N_CMDS];int n=legal_commands(s,i,a);std::vector<Rated>r;
+ for(int k=0;k<n;k++)r.push_back({a[k],primitive(s,i,a[k])});
+ std::stable_sort(r.begin(),r.end(),[](auto&a,auto&b){return a.v>b.v;});return r;
+}
+Orders policy(const State&s,int side){
+ Orders o;int p1[3],p2[3];
+ for(int t=0;t<3;t++){
+  int i=side*3+t;auto r=ranked(s,i);float best=-INF;
+  for(auto x:r){int a,b;path(s,i,x.c,a,b);float v=x.v;
+   for(int j=0;j<t;j++)if(s.tank[side*3+j].alive&&s.tank[i].alive){if(a==p1[j])v-=20;if(b==p2[j])v-=20;}
+   if(v>best){best=v;o.cmd[t]=x.c;p1[t]=a;p2[t]=b;}
+  }
+ }
+ return o;
+}
+std::vector<Orders> plans(const State&s,int side){
+ std::vector<Rated> r[3];for(int t=0;t<3;t++)r[t]=ranked(s,side*3+t);
+ std::vector<Plan> all;
+ for(int a=0;a<std::min(4,(int)r[0].size());a++)for(int b=0;b<std::min(4,(int)r[1].size());b++)for(int c=0;c<std::min(4,(int)r[2].size());c++){
+  Orders o;o.cmd[0]=r[0][a].c;o.cmd[1]=r[1][b].c;o.cmd[2]=r[2][c].c;
+  int p1[3],p2[3];float v=r[0][a].v+r[1][b].v+r[2][c].v;
+  for(int t=0;t<3;t++)path(s,side*3+t,o.cmd[t],p1[t],p2[t]);
+  for(int t=0;t<3;t++)for(int j=t+1;j<3;j++)if(s.tank[side*3+t].alive&&s.tank[side*3+j].alive){if(p1[t]==p1[j])v-=20;if(p2[t]==p2[j])v-=20;}
+  all.push_back({o,v});
+ }
+ std::stable_sort(all.begin(),all.end(),[](auto&a,auto&b){return a.v>b.v;});
+ std::vector<Orders>out;
+ auto add=[&](Orders o){for(auto q:out)if(q==o)return;out.push_back(o);};
+ add(policy(s,side));for(int k=0;k<std::min(14,(int)all.size());k++)add(all[k].o);
+ Orders best=out[0];
+ for(int t=0;t<3;t++)for(int a=0;a<std::min(7,(int)r[t].size());a++){Orders o=best;o.cmd[t]=r[t][a].c;add(o);}
+ add(Orders{});return out;
+}
+std::vector<Orders> smallplans(const State&s,int side){
+ Orders base=policy(s,side);std::vector<Orders> a{base};
+ for(int t=0;t<3;t++){
+  auto r=ranked(s,side*3+t);int got=0;
+  for(auto x:r)if(x.c!=base.cmd[t]){Orders q=base;q.cmd[t]=x.c;if(std::find(a.begin(),a.end(),q)==a.end())a.push_back(q);if(++got>=2)break;}
+ }
+ return a;
+}
+float subgame(const State&s,int side){
+ if(s.done)return evaluate(s,side);
+ auto a=smallplans(s,side),b=smallplans(s,1-side);int n=a.size(),m=b.size();
+ float M[8][8];for(int i=0;i<n;i++)for(int j=0;j<m;j++){State z=s;step_as(z,side,a[i],b[j]);M[i][j]=evaluate(z,side);}
+ double u[8]={},v[8]={},ca[8]={},cb[8]={};int x=0,y=0;
+ for(int it=0;it<160;it++){
+  if(it>=40){ca[x]++;cb[y]++;}
+  for(int i=0;i<n;i++)u[i]+=M[i][y];
+  for(int j=0;j<m;j++)v[j]+=M[x][j];
+  x=std::max_element(u,u+n)-u;y=std::min_element(v,v+m)-v;
+ }
+ double ans=0;for(int i=0;i<n;i++)for(int j=0;j<m;j++)ans+=ca[i]*cb[j]*M[i][j];return ans/14400;
+}
+struct GameMix {std::vector<double> a,b;};
+GameMix solvegame(const std::vector<std::vector<float>>&M){
+ int n=M.size(),m=M[0].size();
+ std::vector<double>u(n,0),v(m,0),ca(n,0),cb(m,0);int x=0,y=0;
+ for(int it=0;it<1200;it++){
+  if(it>=300){ca[x]++;cb[y]++;}
+  for(int j=0;j<n;j++)u[j]+=M[j][y];
+  for(int j=0;j<m;j++)v[j]+=M[x][j];
+  x=std::max_element(u.begin(),u.end())-u.begin();y=std::min_element(v.begin(),v.end())-v.begin();
+ }
+ for(double &x:ca)x/=900;
+ for(double &x:cb)x/=900;
+ return {ca,cb};
+}
+uint64_t code(Orders o){return o.cmd[0]|(uint64_t(o.cmd[1])<<8)|(uint64_t(o.cmd[2])<<16);}
+Orders choose_oracle(const State&s,int side){
+ prepare(s);for(int i=0;i<6;i++)anchor[i]=std::max(-45.f,field[i][s.tank[i].alive?s.tank[i].pos:s.spawn[i]]);auto a=plans(s,side),b=plans(s,1-side);
+ std::unordered_map<uint64_t,float>cache;cache.reserve(4000);
+ auto ev=[&](Orders a,Orders b){
+  uint64_t key=code(a)|(code(b)<<24);auto it=cache.find(key);if(it!=cache.end())return it->second;
+  State z=s;step_as(z,side,a,b);float first=evaluate(z,side);
+  for(int h=0;h<2&&!z.done;h++){Orders u=policy(z,side),v=policy(z,1-side);step_as(z,side,u,v);}
+  float ans=.3f*first+.7f*evaluate(z,side);cache.emplace(key,ans);return ans;
+ };
+ GameMix mix;
+ for(int round=0;round<3;round++){
+  std::vector<std::vector<float>>M(a.size(),std::vector<float>(b.size()));
+  for(int x=0;x<(int)a.size();x++)for(int y=0;y<(int)b.size();y++)M[x][y]=ev(a[x],b[y]);
+  mix=solvegame(M);if(round==2||budget_left()<18)break;
+  std::vector<std::pair<double,Orders>>sa,sb;
+  for(int x=0;x<(int)a.size();x++)if(mix.a[x]>.001)sa.emplace_back(mix.a[x],a[x]);
+  for(int y=0;y<(int)b.size();y++)if(mix.b[y]>.001)sb.emplace_back(mix.b[y],b[y]);
+  auto prep=[](auto&v){std::sort(v.begin(),v.end(),[](auto&a,auto&b){return a.first>b.first;});if(v.size()>6)v.resize(6);double sum=0;for(auto &x:v)sum+=x.first;for(auto &x:v)x.first/=sum;};prep(sa);prep(sb);
+  auto response=[&](int who,Orders best,const std::vector<std::pair<double,Orders>>&support){
+   auto val=[&](Orders o){double v=0;for(auto &[p,e]:support)v+=p*(who==side?ev(o,e):-ev(e,o));return v;};
+   double current=val(best);
+   for(int pass=0;pass<2;pass++)for(int t=0;t<3;t++){
+    if(budget_left()<7)return best;
+    Cmd list[N_CMDS];int n=legal_commands(s,who*3+t,list);Orders old=best;
+    for(int c=0;c<n;c++){Orders trial=old;trial.cmd[t]=list[c];double v=val(trial);if(v>current+.001){current=v;best=trial;}}
+   }
+   return best;
+  };
+  int ai=std::max_element(mix.a.begin(),mix.a.end())-mix.a.begin(),bi=std::max_element(mix.b.begin(),mix.b.end())-mix.b.begin();
+  Orders ar=response(side,a[ai],sb),br=response(1-side,b[bi],sa);
+  if(std::find(a.begin(),a.end(),ar)==a.end())a.push_back(ar);
+  if(std::find(b.begin(),b.end(),br)==b.end())b.push_back(br);
+ }
+ double target=rand01(),sum=0;for(int x=0;x<(int)a.size();x++){sum+=mix.a[x];if(sum>=target)return a[x];}
+ return a.back();
+}
+Orders choose_nested(const State&s,int side){
+ prepare(s);for(int i=0;i<6;i++)anchor[i]=std::max(-45.f,field[i][s.tank[i].alive?s.tank[i].pos:s.spawn[i]]);
+ auto a=plans(s,side),b=plans(s,1-side);
+ int n=a.size(),m=b.size();std::vector<float>matrix(n*m);
+ for(int x=0;x<n;x++)for(int y=0;y<m;y++){
+  if((y&3)==0&&budget_left()<5)return policy(s,side);
+  State z=s;step_as(z,side,a[x],b[y]);float first=evaluate(z,side);
+  matrix[x*m+y]=.15f*first+.85f*subgame(z,side);
+ }
+ std::vector<double>u(n,0),v(m,0),counts(n,0),opp(m,0);int x=0,y=0;
+ for(int it=0;it<220;it++){
+  counts[x]++;opp[y]++;
+  for(int j=0;j<n;j++)u[j]+=matrix[j*m+y];
+  for(int j=0;j<m;j++)v[j]+=matrix[x*m+j];
+  x=std::max_element(u.begin(),u.end())-u.begin();y=std::min_element(v.begin(),v.end())-v.begin();
+ }
+ double target=rand01()*220,acc=0;int chosen=n-1;
+ for(int j=0;j<n;j++){acc+=counts[j];if(acc>target){chosen=j;break;}}
+ return a[chosen];
+}
+Orders choose(const State&s,int side){
+ bool combat=false;
+ for(int i=side*3;i<side*3+3;i++)if(s.tank[i].alive){
+  for(int j=(1-side)*3;j<(1-side)*3+3;j++)if(s.tank[j].alive){
+   int d=md(s.tank[i].pos,s.tank[j].pos);
+   if(d<=3||(d<=6&&clear(s,s.tank[i].pos,s.tank[j].pos)))combat=true;
+  }
+  for(int k=0;k<s.n_bullets;k++)if(md(s.bullet[k].pos,s.tank[i].pos)<=4)combat=true;
+ }
+ return combat?choose_nested(s,side):choose_oracle(s,side);
+}
+}
+void init(const State&s,int me){bot::rng=0x7d2543a71b9ULL^s.wall_hash^(me*987654321ULL);for(int i=0;i<6;i++)bot::previous[i]=-1;}
+Orders decide(const State&s,int me){Orders o=bot::choose(s,me);for(int i=0;i<6;i++)bot::previous[i]=s.tank[i].alive?s.tank[i].pos:-1;return o;}

package/eval/arena/tank/bots/half1/gpt-6.1-sol.cpp

@@ -0,0 +1,78 @@
+// Three coordinated vehicles: rapid upgrade and siege, two flexible defenders.
+// Weighted path fields include the cost of opening brick/steel corridors.
+// All tactical transitions use the authoritative simultaneous-action engine.
+// Opponent response weights come from regret matching; risk tolerance follows
+// its demonstrated upgrade progress. The final choice includes a second turn.
+#include "tank.hpp"
+#include <algorithm>
+#include <cmath>
+#include <queue>
+#include <utility>
+#include <vector>
+using namespace tank;
+namespace {
+constexpr float INF=10000;
+struct Context { const State* root; float attack[6][CELLS],supply[6][MAX_SUPPLY][CELLS],wall[2][CELLS],defend[6][CELLS]; int goal[6],threat[6]; };
+static Context ctx;
+static int priorGoal[6],visits[6][CELLS];
+float walkCost(const State&s,int i,int c){int g=s.grid[c];float v=i%3==FAST?.56f:1.f;if(g==EMPTY)return v;if(g==BRICK||(g==STEEL&&s.tank[i].level>=2))return v+3.4f;return INF;}
+void flood(const State&s,int i,float*dis){using Node=std::pair<float,int>;std::priority_queue<Node,std::vector<Node>,std::greater<Node>>q;for(int y=0;y<s.P.size;y++)for(int x=0;x<s.P.size;x++){int c=cell_of(x,y);if(dis[c]<INF)q.push({dis[c],c});}while(!q.empty()){auto[v,c]=q.top();q.pop();if(v!=dis[c])continue;float cost=walkCost(s,i,c);if(cost>=INF)continue;for(int d=0;d<4;d++){int n=c+DIR_DELTA[d];if(walkCost(s,i,n)>=INF)continue;float z=v+cost;if(z<dis[n]){dis[n]=z;q.push({z,n});}}}}
+void prepare(const State&s){ctx.root=&s;for(int i=0;i<6;i++){float*a=ctx.attack[i];std::fill(a,a+CELLS,INF);int base=s.base_pos[1-i/3];for(int d=0;d<4;d++){float walls=0;int r=0;for(int c=base+DIR_DELTA[d];s.grid[c]!=OUTSIDE;c+=DIR_DELTA[d]){r++;int g=s.grid[c];if(g==BASE0||g==BASE1||(g==STEEL&&s.tank[i].level<2))break;if(g==BRICK||g==STEEL)walls+=3.4f;if(g==EMPTY)a[c]=walls+.85f*r;}}flood(s,i,a);for(int k=0;k<s.n_supply;k++){float*b=ctx.supply[i][k];std::fill(b,b+CELLS,INF);b[s.supply[k]]=0;flood(s,i,b);}}
+int wait=s.turn<10?10-s.turn:20-(s.turn-10)%20;
+for(int seat=0;seat<2;seat++){float best=-1e9;int bg[3]={-1,-1,-1};for(int a=-1;a<s.n_supply;a++)for(int b=-1;b<s.n_supply;b++)for(int c=-1;c<s.n_supply;c++){int gs[3]={a,b,c};if((a>=0&&a==b)||(a>=0&&a==c)||(b>=0&&b==c))continue;float v=0;bool valid=true;for(int t=0;t<3;t++){int i=3*seat+t,k=gs[t];const auto&tk=s.tank[i];int p=tk.alive?tk.pos:s.spawn[i];float av=18-1.35f*ctx.attack[i][p];if(k<0){v+=av*(t==0?2.5f:1.f);continue;}if(tk.level>=2||(t==0&&tk.level>=1)){valid=false;break;}float dis=ctx.supply[i][k][p];int w=(s.star_mask>>k&1)?0:wait;float sv=(tk.level==0?30.f:24.f)-2.4f*dis-2.4f*std::max(0.f,float(w)-dis);if(priorGoal[i]==k)sv+=1.1f;if(!tk.alive)sv-=4;v+=sv*(t==0?2.5f:1.f);}if(valid&&v>best){best=v;for(int t=0;t<3;t++)bg[t]=gs[t];}}for(int t=0;t<3;t++)ctx.goal[3*seat+t]=bg[t];}
+for(int seat=0;seat<2;seat++) {
+ std::vector<std::pair<float,int>> threats;
+ for(int i=3*seat;i<3*seat+3;i++)ctx.threat[i]=-1;
+ for(int j=3*(1-seat);j<3*(1-seat)+3;j++)if(s.tank[j].alive) {
+  int p=s.tank[j].pos,base=s.base_pos[seat],dy=std::abs(cell_y(p)-cell_y(base));float severity=8-dy;
+  if(cell_x(p)==cell_x(base)||cell_y(p)==cell_y(base)) {
+   int de=cell_x(p)==cell_x(base)?(base>p?STRIDE:-STRIDE):(base>p?1:-1);int walls=0;
+   for(int c=p+de;c!=base;c+=de){if(s.grid[c]==BRICK)walls++;if(s.grid[c]==STEEL)walls+=5;}if(walls<=1)severity+=9;
+  }if(dy<8&&severity>0)threats.push_back({severity,j});
+ }std::sort(threats.rbegin(),threats.rend());
+ for(int k=0;k<std::min(2,int(threats.size()));k++){
+  int threat=threats[k].second;if(k>0&&threats[k].first<4)break;
+  int besti=-1;float bestcost=1e9;
+  for(int i=3*seat;i<3*seat+3;i++)if(ctx.goal[i]!=-2){
+   float dis[CELLS];std::fill(dis,dis+CELLS,INF);int target=s.tank[threat].pos;
+   for(int d=0;d<4;d++){float walls=0;for(int c=target+DIR_DELTA[d],r=1;r<=8;c+=DIR_DELTA[d],r++) {
+    int g=s.grid[c];if(g==OUTSIDE||g==BASE0||g==BASE1||(g==STEEL&&s.tank[i].level<2))break;
+    if(g==BRICK||g==STEEL)walls+=3.4f;if(g==EMPTY)dis[c]=walls+.6f*r;
+   }}flood(s,i,dis);int p=s.tank[i].alive?s.tank[i].pos:s.spawn[i];float cost=dis[p];
+   if(!s.tank[i].alive)cost+=respawn_in(s,i);if(ctx.attack[i][p]<2.5f&&s.tank[i].level>=1)cost+=16;if(i%3==FAST)cost+=20;
+   if(cost<bestcost){bestcost=cost;besti=i;std::copy(dis,dis+CELLS,ctx.defend[i]);}
+  }if(besti>=0&&bestcost<20){ctx.goal[besti]=-2;ctx.threat[besti]=threat;}
+ }
+}
+for(int seat=0;seat<2;seat++){std::fill(ctx.wall[seat],ctx.wall[seat]+CELLS,0);for(int i=3*seat;i<3*seat+3;i++){int p=s.tank[i].alive?s.tank[i].pos:s.spawn[i];const float*dis=ctx.goal[i]==-2?ctx.defend[i]:(ctx.goal[i]<0?ctx.attack[i]:ctx.supply[i][ctx.goal[i]]);for(int d=0;d<4;d++){int n=p+DIR_DELTA[d];if(s.grid[n]==BRICK||(s.grid[n]==STEEL&&s.tank[i].level>=2))ctx.wall[seat][n]=std::max(ctx.wall[seat][n],std::max(0.f,dis[p]-dis[n])*.85f);}int base=ctx.goal[i]==-2?s.tank[ctx.threat[i]].pos:s.base_pos[1-seat];if(cell_x(p)==cell_x(base)||cell_y(p)==cell_y(base)){int delta=cell_x(p)==cell_x(base)?(base>p?STRIDE:-STRIDE):(base>p?1:-1);for(int c=p+delta;c!=base;c+=delta){if(s.grid[c]==OUTSIDE||(s.grid[c]==STEEL&&s.tank[i].level<2))break;if(s.grid[c]==BRICK||s.grid[c]==STEEL)ctx.wall[seat][c]=std::max(ctx.wall[seat][c],ctx.goal[i]==-2?12.f:4.5f);}}}}}
+float position(const State&s,int i){const auto&t=s.tank[i];if(!t.alive)return -3.f*respawn_in(s,i);float v=18-1.35f*ctx.attack[i][t.pos];int k=ctx.goal[i];if(k==-2)v=60-4.2f*ctx.defend[i][t.pos];if(k>=0&&t.level<2&&t.level==ctx.root->tank[i].level)v=(t.level==0?30.f:24.f)-2.4f*ctx.supply[i][k][t.pos];v=std::max(-35.f,v);if(t.pos!=ctx.root->tank[i].pos)v-=std::min(2.f,visits[i][t.pos]*.12f);for(int j=3*(1-i/3);j<3*(1-i/3)+3;j++)if(!s.tank[j].alive&&s.spawn[j]==t.pos&&respawn_in(s,j)<=2)v-=280;return v;}
+float evaluation(const State&s,int me){if(s.done)return s.winner<0?0:(s.winner==me?100000.f:-100000.f);float vals[2]={};for(int seat=0;seat<2;seat++){vals[seat]=70.f*s.base_hp[seat]+10.f*s.kills[seat]+1.5f*s.stars_eaten[seat];for(int i=3*seat;i<3*seat+3;i++){const Tank&t=s.tank[i];if(t.alive)vals[seat]+=35+48.f*t.level+18.f*t.hp+position(s,i);else vals[seat]+=position(s,i);}}
+int occ[CELLS];std::fill(occ,occ+CELLS,-1);for(int i=0;i<6;i++)if(s.tank[i].alive)occ[s.tank[i].pos]=i;for(int b=0;b<s.n_bullets;b++){const auto&bl=s.bullet[b];int seat=bl.owner/3;for(int c=bl.pos+DIR_DELTA[bl.dir],r=1;r<=s.P.size+1;c+=DIR_DELTA[bl.dir],r++){int g=s.grid[c];if(g==OUTSIDE)break;if(g==BRICK||g==STEEL){if(g==BRICK||bl.steel)vals[seat]+=ctx.wall[seat][c]/(1+.12f*r);break;}if(g==BASE0||g==BASE1){int target=g-BASE0;vals[target]-=30.f/(1+.18f*r);break;}int j=occ[c];if(j>=0){float danger=(s.tank[j].hp<=1?17.f:6.f)/(1+.30f*r);int exits=0;for(int d=0;d<4;d++)if((d/2)!=(bl.dir/2)&&s.grid[c+DIR_DELTA[d]]==EMPTY&&occ[c+DIR_DELTA[d]]<0)exits++;if(exits==0)danger*=1.8f;vals[j/3]-=danger;break;}}}
+if(s.wall_hash!=ctx.root->wall_hash)for(int c=0;c<CELLS;c++)if((ctx.root->grid[c]==BRICK||ctx.root->grid[c]==STEEL)&&s.grid[c]==EMPTY)for(int seat=0;seat<2;seat++)vals[seat]+=ctx.wall[seat][c];return vals[me]-vals[1-me];}
+struct Choice{Orders o;float value;};
+std::vector<Choice>choices(const State&s,int seat,int limit,const Orders&other){std::vector<std::pair<float,Cmd>>ls[3];for(int t=0;t<3;t++){Cmd legal[N_CMDS];int n=legal_commands(s,3*seat+t,legal);for(int j=0;j<n;j++){Orders o;o.cmd[t]=legal[j];State z=s;step_as(z,seat,o,other);ls[t].push_back({evaluation(z,seat),legal[j]});}std::stable_sort(ls[t].begin(),ls[t].end(),[](auto a,auto b){return a.first>b.first;});if(ls[t].size()>7)ls[t].resize(7);}std::vector<Choice>out;for(auto a:ls[0])for(auto b:ls[1])for(auto c:ls[2]){Orders o;o.cmd[0]=a.second;o.cmd[1]=b.second;o.cmd[2]=c.second;State z=s;step_as(z,seat,o,other);out.push_back({o,evaluation(z,seat)});}std::stable_sort(out.begin(),out.end(),[](const Choice&a,const Choice&b){return a.value>b.value;});if(int(out.size())>limit)out.resize(limit);return out;}
+Orders greedy(const State&s,int seat,const Orders&other){Orders o;for(int pass=0;pass<2;pass++)for(int t=0;t<3;t++){Cmd legal[N_CMDS];int n=legal_commands(s,3*seat+t,legal);float best=-1e9;Cmd bc=0;for(int k=0;k<n;k++){Orders a=o;a.cmd[t]=legal[k];State z=s;step_as(z,seat,a,other);float v=evaluation(z,seat);if(v>best){best=v;bc=legal[k];}}o.cmd[t]=bc;}return o;}
+}
+void init(const State&,int){std::fill(priorGoal,priorGoal+6,-1);for(auto&row:visits)std::fill(row,row+CELLS,0);}
+Orders decide(const State&s,int me){prepare(s);float sophistication=std::clamp((s.stars_eaten[1-me]-1)*.5f,0.f,1.f); float rootRisk=.75f-.45f*sophistication, continuationRisk=.8f-.4f*sophistication;Orders idle;auto enemy=choices(s,1-me,24,idle);auto seeds=enemy;
+for(int b=0;b<std::min(2,int(seeds.size()));b++)for(int t=0;t<3;t++) {
+ Cmd legal[N_CMDS];int n=legal_commands(s,3*(1-me)+t,legal);
+ for(int k=0;k<n;k++){Orders o=seeds[b].o;o.cmd[t]=legal[k];
+  if(std::none_of(enemy.begin(),enemy.end(),[&](const Choice&z){return z.o==o;}))enemy.push_back({o,0});
+ }
+}
+auto mine=choices(s,me,60,enemy[0].o);auto quiet=choices(s,me,10,idle);for(auto a:quiet)if(std::none_of(mine.begin(),mine.end(),[&](const Choice&b){return a.o==b.o;}))mine.push_back(a);struct Ranked{int index;float value;int response;};std::vector<Ranked>rank;
+ int n=mine.size(),m=enemy.size();std::vector<float> matrix(n*m);
+ for(int a=0;a<n;a++)for(int b=0;b<m;b++){State z=s;step_as(z,me,mine[a].o,enemy[b].o);matrix[a*m+b]=evaluation(z,me);}
+ std::vector<float> r1(n),r2(m),p1(n),p2(m),avg2(m),u1(n),u2(m);
+ for(int iter=0;iter<80;iter++) {
+  float sum1=0,sum2=0;for(int a=0;a<n;a++)sum1+=std::max(0.f,r1[a]);for(int b=0;b<m;b++)sum2+=std::max(0.f,r2[b]);
+  for(int a=0;a<n;a++)p1[a]=sum1>1e-5?std::max(0.f,r1[a])/sum1:1.f/n;
+  for(int b=0;b<m;b++){p2[b]=sum2>1e-5?std::max(0.f,r2[b])/sum2:1.f/m;avg2[b]+=p2[b];}
+  std::fill(u1.begin(),u1.end(),0);std::fill(u2.begin(),u2.end(),0);float v=0;
+  for(int a=0;a<n;a++)for(int b=0;b<m;b++){float x=matrix[a*m+b];u1[a]+=p2[b]*x;u2[b]-=p1[a]*x;}
+  for(int a=0;a<n;a++)v+=p1[a]*u1[a];for(int a=0;a<n;a++)r1[a]+=u1[a]-v;for(int b=0;b<m;b++)r2[b]+=u2[b]+v;
+ }
+ for(int a=0;a<n;a++){float worst=1e9,sum=0;int wi=0;for(int b=0;b<m;b++){float v=matrix[a*m+b];if(v<worst){worst=v;wi=b;}sum+=v*avg2[b]/80;}
+ rank.push_back({a,rootRisk*worst+(1-rootRisk)*sum,wi});}
+ std::stable_sort(rank.begin(),rank.end(),[](auto a,auto b){return a.value>b.value;});Orders result=mine[rank[0].index].o;float best=-1e9;for(int k=0;k<std::min(8,int(rank.size()));k++){if(budget_left()<12)break;auto r=rank[k];float worst=1e9,sum=0;int responses[3]={r.response,0,int(enemy.size())>1?1:0};for(int b:responses){if(budget_left()<6)return result;State z=s;step_as(z,me,mine[r.index].o,enemy[b].o);float v=evaluation(z,me);if(!z.done){Orders eo=greedy(z,1-me,idle),mo=greedy(z,me,eo);eo=greedy(z,1-me,mo);mo=greedy(z,me,eo);State q=z;step_as(q,me,mo,eo);v=.35f*v+.65f*evaluation(q,me);}worst=std::min(worst,v);sum+=v;}float value=.8f*(continuationRisk*worst+(1-continuationRisk)*sum/3)+.2f*r.value;if(value>best){best=value;result=mine[r.index].o;}}for(int i=0;i<6;i++){priorGoal[i]=ctx.goal[i];if(s.tank[i].alive)visits[i][s.tank[i].pos]++;}return result;}