dsh-eval-guard 0.2.2 → 0.3.0

package/eval/arena/tank/workspace/history/20261017-193652-e34c0f45539a-gpt-6_1-sol.cpp

@@ -0,0 +1,87 @@
+// Final second-half bot. Rapid upgrade and siege, two flexible defenders.
+// Supply assignment distinguishes travel from waiting, including before turn 10.
+// A destructible cell can itself be a future firing position: seed its ray cost
+// BEFORE charging for that wall, then charge demolition when walking into it.
+// Enemy-occupied firing cells are excluded, and blockers add siege-ray cost.
+// Distant shots at mobile tanks have exponentially declining expected value.
+// 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});}}}}
+// Goals: -1 attacks the base; -2 intercepts an assigned threat; 0..2 seek supplies.
+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;int j=tank_at(s,c);
+if((g==EMPTY||g==BRICK||g==STEEL)&&(j<0||j==i))a[c]=walls+.85f*r;
+if(g==BRICK||g==STEEL)walls+=3.4f;
+if(j>=0&&j!=i)walls+=j/3==i/3?2.f:5.f+1.5f*s.tank[j].hp;}}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-(s.turn<10?.7f:2.4f)*std::max(0.f,float(w)-dis)-.6f*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?25.f:12.f)*std::pow(.55f,float(r-1));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=std::max(danger,(s.tank[j].hp<=1?20.f:10.f)/(1+.25f*r));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;}

package/eval/arena/tank/workspace/history/20261017-193654-c026348ce96e-opus-5_5.cpp

@@ -0,0 +1,476 @@
+// 策略：每辆车逐条枚举合法命令，用 tank::step 精确前推一回合（对手取三种模型：不动 / 见线就打 /
+// 预判我落点开炮），再做第二层"是否存在安全应对"的检查；局面评估 = 基地血量差 + 坦克得失 + 到目标的距离场。
+// 目标：攻击手走到离敌方基地 2 格内的炮位；敌人逼近我方基地时最近的车转为猎杀。
+#include "tank.hpp"
+#include <queue>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+
+using namespace tank;
+
+#define FIXED_PASSES 0
+
+static const int INF = 100000;
+static int ME, OP;
+static int atkField[2][CELLS];      // atkField[seat]：seat 方去打对方基地的代价场
+static int huntField[3][CELLS];     // 针对敌方第 k 辆车的猎杀场
+static int starField[CELLS];
+static int goalOf[3];               // 0 = 攻击，1..3 = 猎杀敌车 k-1，4 = 吃星
+static const int* goalField[3];
+
+// 调参
+static int FAR_ATK = 1000, FAR_K = 5, HUNT_KEEP = 4;
+static double L2 = 0.5;
+static int PREP_T1 = 10, PREP_T = 4, PREP_LIM1 = 9, PREP_LIM = 5, PREP_N1 = 3, PREP_N = 3;
+static int BRICK_K = 2;
+static int W_HUNT = 14, W_HUNT_HOT = 40;
+static int W_STEP = 10, V_BASE = 100, V_MYBASE = 110, V_DEATH = 400, V_UNSAFE = 150, V_KILL = 20, V_KILLY = 12;
+static int V_HP = 40, V_LEVEL = 120, B_BRICK = 6, B_FAR = 5, B_FARSTILL = 15, B_BASEFAR = 8;
+static double M_STAY = 0.55, M_THREAT = 0.45, M_ANT = 0.0;
+
+static int danger[CELLS];            // 敌车视线内的格子，寻路时加代价
+static bool useDanger = false;
+static int wStep[3] = {10, 10, 10};
+static int DANGER_NEAR = 0, DANGER_FAR = 0;
+static uint8_t lane[CELLS];          // 敌方炮线（打我基地的线、飞行中的敌弹前方）
+static void dijkstra(const State& s, int* f, bool useLane = false) {
+    typedef std::pair<int, int> PI;
+    std::priority_queue<PI, std::vector<PI>, std::greater<PI>> pq;
+    for (int c = 0; c < CELLS; ++c) if (f[c] < INF) pq.push({f[c], c});
+    while (!pq.empty()) {
+        PI p = pq.top(); pq.pop();
+        if (p.first > f[p.second]) continue;
+        for (int d = 0; d < 4; ++d) {
+            int n = p.second + DIR_DELTA[d];
+            uint8_t g = s.grid[n];
+            int w;
+            if (g == EMPTY) w = 1; else if (g == BRICK) w = 3; else continue;
+            if (useLane && lane[n]) w += 8;
+            if (useDanger) w += danger[n];
+            if (f[n] > p.first + w) { f[n] = p.first + w; pq.push({f[n], n}); }
+        }
+    }
+}
+
+static bool buildAtk(const State& s, int seat, int* f, int only = -1) {
+    for (int c = 0; c < CELLS; ++c) f[c] = INF;
+    int B = s.base_pos[1 - seat];
+    bool any = false;
+    for (int d = 0; d < 4; ++d) {
+        if (only >= 0 && d != only) continue;
+        int bricks = 0;
+        for (int k = 1; k <= 9; ++k) {
+            int c = B + k * DIR_DELTA[d];
+            uint8_t g = s.grid[c];
+            int far = k > 2 ? (k - 2) * 2 : 0;
+            if (g == EMPTY) { f[c] = std::min(f[c], 2 * bricks + far); any = true; }
+            else if (g == BRICK) { f[c] = std::min(f[c], 2 * bricks + far + 2); ++bricks; any = true; }
+            else if (g == WATER) continue;
+            else break;
+        }
+    }
+    useDanger = only >= 0;
+    dijkstra(s, f);
+    useDanger = false;
+    return any;
+}
+static int sideField[3][CELLS];
+static bool sideOk[3];
+static int sideOf[3] = {-1, -1, -1};
+static int lastBest[3] = {INF, INF, INF}, stuckCnt[3];
+static int sidePen[3][3], sidePenUntil[3][3];
+
+static void buildHunt(const State& s, int e, int* f) {
+    for (int c = 0; c < CELLS; ++c) f[c] = INF;
+    int P = s.tank[e].pos;
+    for (int d = 0; d < 4; ++d) {
+        for (int k = 1; k <= 7; ++k) {
+            int c = P + k * DIR_DELTA[d];
+            uint8_t g = s.grid[c];
+            if (g == EMPTY) { if (!lane[c]) f[c] = (k == 1 ? 2 : (k == 2 ? 0 : (k - 2))); }
+            else if (g == WATER) continue;
+            else break;
+        }
+    }
+    dijkstra(s, f, true);
+}
+
+static void buildLane(const State& s) {
+    memset(lane, 0, sizeof lane);
+    memset(danger, 0, sizeof danger);
+    for (int t = 0; t < 3; ++t) {
+        int e = tank_id(OP, t);
+        if (!s.tank[e].alive) continue;
+        for (int d = 0; d < 4; ++d)
+            for (int k = 1; k <= 5; ++k) {
+                int c = s.tank[e].pos + k * DIR_DELTA[d];
+                if (s.grid[c] != EMPTY && s.grid[c] != WATER) break;
+                danger[c] += k <= 2 ? DANGER_NEAR : DANGER_FAR;
+            }
+    }
+    for (int t = 0; t < 3; ++t) {
+        int e = tank_id(OP, t);
+        if (!s.tank[e].alive) continue;
+        for (int d = 0; d < 4; ++d) {
+            int k = 1; bool hit = false;
+            for (; k <= 14; ++k) {
+                uint8_t g = s.grid[s.tank[e].pos + k * DIR_DELTA[d]];
+                if (g == BASE0 + ME) { hit = true; break; }
+                if (g != EMPTY && g != WATER && g != BRICK) break;
+            }
+            if (hit) for (int j = 1; j < k; ++j) lane[s.tank[e].pos + j * DIR_DELTA[d]] = 1;
+        }
+    }
+    for (int b = 0; b < s.n_bullets; ++b) {
+        if (seat_of(s.bullet[b].owner) == ME) continue;
+        for (int k = 1; k <= 6; ++k) {
+            int c = s.bullet[b].pos + k * DIR_DELTA[s.bullet[b].dir];
+            if (s.grid[c] != EMPTY && s.grid[c] != WATER) break;
+            lane[c] = 1;
+        }
+    }
+}
+
+// 敌车 e（任意一方的车）"见线就打"的命令：打 foe 方的车或基地
+static Cmd threatCmd(const State& s, int e) {
+    const Tank& t = s.tank[e];
+    if (!t.alive || !can_fire(s, e)) return STAY;
+    int side = seat_of(e);
+    int best = -1, bestP = 0;
+    for (int d = 0; d < 4; ++d) {
+        int bricks = 0;
+        for (int k = 1; k <= 14; ++k) {
+            int c = t.pos + k * DIR_DELTA[d];
+            uint8_t g = s.grid[c];
+            if (g == WATER) continue;
+            if (g == BRICK) { ++bricks; continue; }
+            if (g == BASE0 + (1 - side)) { int p = 20 - bricks; if (p > bestP) { bestP = p; best = d; } break; }
+            if (g != EMPTY) break;
+            int v = tank_at(s, c);
+            if (v >= 0) {
+                if (seat_of(v) != side && bricks == 0 && k <= 8) { int p = 100 - k; if (p > bestP) { bestP = p; best = d; } }
+                break;
+            }
+        }
+    }
+    return best < 0 ? STAY : cmd_fire(best);
+}
+
+static Orders threatOrders(const State& s, int side) {
+    Orders o;
+    for (int t = 0; t < 3; ++t) o.cmd[t] = threatCmd(s, tank_id(side, t));
+    return o;
+}
+
+static int destOf(const State& s, int i, Cmd c) {
+    int p = s.tank[i].pos;
+    auto go = [&](int d) { int n = p + DIR_DELTA[d]; if (s.grid[n] == EMPTY && tank_at(s, n) < 0) p = n; };
+    if (is_move(c)) go(c - 1);
+    else if (is_move2(c)) { go((c - 9) / 4); go((c - 9) % 4); }
+    return p;
+}
+
+// 预判模型：能开炮的敌车朝我车 i 的落点（2 格内同线）开炮
+static Orders anticipateOrders(const State& s, int side, int i, int dest) {
+    Orders o = threatOrders(s, side);
+    for (int t = 0; t < 3; ++t) {
+        int e = tank_id(side, t);
+        if (!s.tank[e].alive || !can_fire(s, e)) continue;
+        for (int d = 0; d < 4; ++d) {
+            for (int k = 1; k <= 2; ++k) {
+                int c = s.tank[e].pos + k * DIR_DELTA[d];
+                uint8_t g = s.grid[c];
+                if (g != EMPTY && g != WATER) break;
+                if (c == dest) { o.cmd[t] = cmd_fire(d); break; }
+                int v = tank_at(s, c);
+                if (v >= 0 && v != i) break;
+            }
+        }
+    }
+    return o;
+}
+
+static double evalState(const State& s0, const State& s) {
+    double v = 0;
+    if (s.done) {
+        if (s.winner == ME) v += 100000; else if (s.winner == OP) v -= 100000;
+    }
+    v += V_BASE * (s0.base_hp[OP] - s.base_hp[OP]);
+    v -= V_MYBASE * (s0.base_hp[ME] - s.base_hp[ME]);
+    for (int t = 0; t < 3; ++t) {
+        int i = tank_id(ME, t), e = tank_id(OP, t);
+        const Tank& a0 = s0.tank[i]; const Tank& a = s.tank[i];
+        if (a0.alive) {
+            if (!a.alive) v -= V_DEATH + 60 * a0.level;
+            else {
+                int dh = a.hp - 2 * (a.level - a0.level) - a0.hp;
+                v += V_HP * dh;
+                v += V_LEVEL * (a.level - a0.level);
+                int f = goalField[t][a.pos];
+                if (f >= INF) f = 60;
+                v -= wStep[t] * f;
+            }
+        }
+        const Tank& b0 = s0.tank[e]; const Tank& b = s.tank[e];
+        if (b0.alive) {
+            if (!b.alive) {
+                int dy = std::abs(cell_y(b0.pos) - cell_y(s.spawn[e]));
+                v += V_KILL + V_KILLY * dy + 60 * b0.level;
+            } else {
+                int dh = b.hp - 2 * (b.level - b0.level) - b0.hp;
+                v -= V_HP * dh;
+                v -= V_LEVEL * (b.level - b0.level);
+            }
+        }
+    }
+    return v;
+}
+
+// 命令本身的启发加分（前推一回合看不到的远期收益）
+static double cmdBonus(const State& s, int i, Cmd c, const int* field) {
+    if (!is_fire(c)) return 0;
+    int d = c - 5;
+    const Tank& t = s.tank[i];
+    for (int k = 1; k <= 14; ++k) {
+        int cc = t.pos + k * DIR_DELTA[d];
+        uint8_t g = s.grid[cc];
+        if (g == WATER) continue;
+        if (g == BRICK) {
+            if (k <= BRICK_K && field[cc] <= field[t.pos] && field[cc] < INF) return B_BRICK;
+            // 炮线后面是敌方基地
+            for (int kk = k + 1; kk <= 14; ++kk) {
+                uint8_t g2 = s.grid[t.pos + kk * DIR_DELTA[d]];
+                if (g2 == BASE0 + OP) return B_BRICK;
+                if (g2 != EMPTY && g2 != WATER && g2 != BRICK) break;
+            }
+            return -3;
+        }
+        if (g == BASE0 + OP) return k > 2 ? B_BASEFAR : 0;
+        if (g == BASE0 + ME) return -400;
+        if (g != EMPTY) return -3;
+        int v = tank_at(s, cc);
+        if (v >= 0) {
+            if (seat_of(v) == ME) return -300;
+            if (k <= 2) return 0;
+            if (field[t.pos] <= FAR_ATK && k > FAR_K) return -3;
+            bool still = s.tank[v].last_fire >= s.turn - 1;
+            return (still ? B_FARSTILL : B_FAR) - k;
+        }
+    }
+    return -3;
+}
+
+static bool safeNext(const State& s1, int i) {
+    const Tank& t = s1.tank[i];
+    if (!t.alive) return true;
+    Orders eo = threatOrders(s1, OP);
+    Cmd list[N_CMDS];
+    int n = legal_commands(s1, i, list);
+    for (int k = 0; k < n; ++k) {
+        State s2 = s1;
+        Orders mo; mo.cmd[type_of(i)] = list[k];
+        step_as(s2, ME, mo, eo);
+        if (s2.tank[i].alive && s2.tank[i].hp >= t.hp) return true;
+        if (s2.done && s2.winner == ME) return true;
+    }
+    return false;
+}
+
+void init(const State& s, int me) { ME = me; OP = 1 - me; }
+
+Orders decide(const State& s, int me) {
+    ME = me; OP = 1 - me;
+    Orders orders;
+    buildAtk(s, ME, atkField[ME]);
+    buildAtk(s, OP, atkField[OP]);
+    buildLane(s);
+
+    // 吃星场
+    bool anyStar = false;
+    for (int c = 0; c < CELLS; ++c) starField[c] = INF;
+    for (int k = 0; k < s.n_supply; ++k) if (s.star_mask >> k & 1) { starField[s.supply[k]] = 0; anyStar = true; }
+    if (anyStar) dijkstra(s, starField);
+
+    // 三个方向的炮位分配：尽量一车一个方向，避免挤在同一条路上互相挡
+    {
+        const int sd[3] = {ME == 0 ? DOWN : UP, LEFT, RIGHT};
+        for (int k = 0; k < 3; ++k) sideOk[k] = buildAtk(s, ME, sideField[k], sd[k]);
+        for (int t = 0; t < 3; ++t) {
+            int i = tank_id(ME, t);
+            if (!s.tank[i].alive) { stuckCnt[t] = 0; lastBest[t] = INF; continue; }
+            if (sideOf[t] >= 0) {
+                int f = sideField[sideOf[t]][s.tank[i].pos];
+                if (f < lastBest[t]) { lastBest[t] = f; stuckCnt[t] = 0; }
+                else if (f > 0 && ++stuckCnt[t] >= 8) {
+                    sidePen[t][sideOf[t]] = 25; sidePenUntil[t][sideOf[t]] = s.turn + 30;
+                    stuckCnt[t] = 0; lastBest[t] = INF;
+                }
+            }
+        }
+        int bestTot = INF, bestA[3] = {0, 0, 0};
+        for (int a = 0; a < 27; ++a) {
+            int as[3] = {a % 3, a / 3 % 3, a / 9};
+            int tot = 0, cnt[3] = {0, 0, 0};
+            for (int t = 0; t < 3; ++t) {
+                int i = tank_id(ME, t);
+                int k = as[t];
+                if (!sideOk[k]) { tot += 1000; continue; }
+                cnt[k]++;
+                int pos = s.tank[i].alive ? s.tank[i].pos : s.spawn[i];
+                int f = sideField[k][pos]; if (f >= INF) f = 200;
+                if (t == FAST) f = (f + 1) / 2;
+                if (s.turn < sidePenUntil[t][k]) f += sidePen[t][k];
+                if (k != sideOf[t]) f += 3;
+                tot += f;
+            }
+            for (int k = 0; k < 3; ++k) if (cnt[k] > 1) tot += 12 * (cnt[k] - 1);
+            if (tot < bestTot) { bestTot = tot; for (int t = 0; t < 3; ++t) bestA[t] = as[t]; }
+        }
+        for (int t = 0; t < 3; ++t) {
+            if (bestA[t] != sideOf[t]) { sideOf[t] = bestA[t]; stuckCnt[t] = 0; lastBest[t] = INF; }
+            goalOf[t] = 0;
+            goalField[t] = sideOk[sideOf[t]] ? sideField[sideOf[t]] : atkField[ME];
+        }
+    }
+
+    // 猎杀分配
+    for (int t = 0; t < 3; ++t) wStep[t] = W_STEP;
+    bool huntBuilt[3] = {false, false, false};
+    int order[3] = {0, 1, 2};
+    std::sort(order, order + 3, [&](int a, int b) {
+        int ea = tank_id(OP, a), eb = tank_id(OP, b);
+        int fa = s.tank[ea].alive ? atkField[OP][s.tank[ea].pos] : INF;
+        int fb = s.tank[eb].alive ? atkField[OP][s.tank[eb].pos] : INF;
+        return fa < fb;
+    });
+    bool used[3] = {false, false, false};
+    int nHunt = 0;
+    for (int oi = 0; oi < 3; ++oi) {
+        int k = order[oi], e = tank_id(OP, k);
+        if (!s.tank[e].alive) continue;
+        int thr = atkField[OP][s.tank[e].pos];
+        if (thr > 7) continue;
+        buildHunt(s, e, huntField[k]); huntBuilt[k] = true;
+        int best = -1, bd = INF;
+        for (int t = 0; t < 3; ++t) {
+            int i = tank_id(ME, t);
+            if (used[t] || !s.tank[i].alive) continue;
+            int dd = huntField[k][s.tank[i].pos];
+            if (t == FAST) dd = (dd + 1) / 2;
+            if (goalField[t][s.tank[i].pos] <= HUNT_KEEP && dd > 2) continue;
+            if (dd < bd) { bd = dd; best = t; }
+        }
+        if (best >= 0 && bd <= 14 && nHunt < (s.base_hp[ME] > s.base_hp[OP] + 6 ? 0 : 1)) { ++nHunt; used[best] = true; goalOf[best] = 1 + k; goalField[best] = huntField[k]; wStep[best] = thr <= 1 ? W_HUNT_HOT : W_HUNT; }
+    }
+    // 出星前抢占补给点（每批出星前 PREP_T 回合起）
+    {
+        int W = s.turn < 10 ? 10 : 10 + ((s.turn - 10 + 19) / 20) * 20;
+        bool first = W == 10;
+        if (W - s.turn <= (first ? PREP_T1 : PREP_T) && W <= 290) {
+            static int spf[MAX_SUPPLY][CELLS];
+            for (int k = 0; k < s.n_supply; ++k) {
+                for (int c = 0; c < CELLS; ++c) spf[k][c] = INF;
+                spf[k][s.supply[k]] = 0;
+                dijkstra(s, spf[k]);
+            }
+            int lim = first ? PREP_LIM1 : PREP_LIM;
+            int maxN = first ? PREP_N1 : PREP_N;
+            int bestTot = INF, bestA[3] = {-1, -1, -1};
+            // 每辆车选一个补给点或不去（-1）
+            for (int a = 0; a < 64; ++a) {
+                int as[3] = {a % 4 - 1, a / 4 % 4 - 1, a / 16 % 4 - 1};
+                int tot = 0, cnt = 0; bool ok = true;
+                for (int t = 0; t < 3 && ok; ++t) {
+                    int k = as[t];
+                    if (k < 0) { tot += lim + 1; continue; }
+                    int i = tank_id(ME, t);
+                    if (k >= s.n_supply || !s.tank[i].alive || goalOf[t] != 0 || s.tank[i].level >= 2) { ok = false; break; }
+                    for (int u = 0; u < t; ++u) if (as[u] == k) ok = false;
+                    int d = spf[k][s.tank[i].pos];
+                    if (t == FAST) d = (d + 1) / 2;
+                    if (d > lim) ok = false;
+                    tot += d; ++cnt;
+                }
+                if (!ok || cnt > maxN) continue;
+                if (tot < bestTot) { bestTot = tot; for (int t = 0; t < 3; ++t) bestA[t] = as[t]; }
+            }
+            static int prepF[3][CELLS];
+            for (int t = 0; t < 3; ++t) if (bestA[t] >= 0) {
+                memcpy(prepF[t], spf[bestA[t]], sizeof prepF[t]);
+                goalOf[t] = 4; goalField[t] = prepF[t];
+            }
+        }
+    }
+    // 吃星：星近就顺路吃
+    if (anyStar) {
+        for (int t = 0; t < 3; ++t) {
+            int i = tank_id(ME, t);
+            if (!s.tank[i].alive || goalOf[t] != 0 || s.tank[i].level >= 2) continue;
+            int sd = starField[s.tank[i].pos];
+            int lim = s.tank[i].level == 0 ? 5 : 3;
+            if (sd <= lim && goalField[t][s.tank[i].pos] > 0) { goalOf[t] = 4; goalField[t] = starField; }
+        }
+    }
+
+    const int seq[3] = {FIRE, ARMOR, FAST};
+    int passes = 0;
+    for (int pass = 0; pass < 2; ++pass) {
+        if (pass > 0) {
+            if (FIXED_PASSES ? pass >= FIXED_PASSES : budget_left() < 25) break;
+        }
+        ++passes;
+        bool changed = false;
+        for (int si = 0; si < 3; ++si) {
+            int t = seq[si], i = tank_id(ME, t);
+            if (!s.tank[i].alive) continue;
+            Cmd list[N_CMDS];
+            int n = legal_commands(s, i, list);
+            bool cf = can_fire(s, i);
+            Orders eStay, eThr = threatOrders(s, OP);
+            double bestV = -1e18; Cmd bestC = STAY;
+            for (int k = 0; k < n; ++k) {
+                Cmd c = list[k];
+                if (is_fire(c) && !cf) continue;
+                Orders mo = orders; mo.cmd[t] = c;
+                double v = cmdBonus(s, i, c, goalField[t]);
+                Orders eAnt = anticipateOrders(s, OP, i, destOf(s, i, c));
+                const Orders* models[3] = {&eStay, &eThr, &eAnt};
+                const double wts[3] = {M_STAY, M_THREAT, M_ANT};
+                for (int m = 0; m < 3; ++m) {
+                    State s1 = s;
+                    step_as(s1, ME, mo, *models[m]);
+                    double ev = evalState(s, s1);
+                    if (wts[m] <= 0) continue;
+                    if (!s1.done && s1.tank[i].alive && L2 > 0) {
+                        Cmd l2[N_CMDS];
+                        int n2 = legal_commands(s1, i, l2);
+                        bool cf2 = can_fire(s1, i);
+                        Orders e2; if (m >= 1) e2 = threatOrders(s1, OP);
+                        double b2 = -1e18;
+                        for (int k2 = 0; k2 < n2; ++k2) {
+                            if (is_fire(l2[k2]) && !cf2) continue;
+                            State s2 = s1;
+                            Orders m2; m2.cmd[t] = l2[k2];
+                            step_as(s2, ME, m2, e2);
+                            double e = evalState(s, s2) + cmdBonus(s1, i, l2[k2], goalField[t]);
+                            if (e > b2) b2 = e;
+                        }
+                        ev = (1 - L2) * ev + L2 * b2;
+                    }
+                    if (!s1.done && s1.tank[i].alive && !safeNext(s1, i)) ev -= V_UNSAFE;
+                    v += wts[m] * ev;
+                }
+                if (v > bestV) { bestV = v; bestC = c; }
+            }
+            if (bestC != orders.cmd[t]) changed = true;
+            orders.cmd[t] = bestC;
+        }
+        if (!changed) break;
+    }
+#ifdef DBG
+    for (int t = 0; t < 3; ++t) { int i = tank_id(ME, t); fprintf(stderr, "t%d goal%d side%d f%d w%d | ", t, goalOf[t], sideOf[t], s.tank[i].alive ? goalField[t][s.tank[i].pos] : -1, wStep[t]); }
+    fputc(10, stderr);
+#endif
+    return orders;
+}