DeepSeek V3.2 vs Grok 4.6

1+function tick(me, opp, ring, mem) {
2+  var order = { fwd: 0, side: 0, action: null };
3+  
4+  // Initialize memory
5+  if (!mem.init) {
6+    mem.init = true;
7+    mem.lastOppAction = null;
8+    mem.oppActionHistory = [];
9+    mem.myCombos = 0;
10+    mem.rangeHistory = [];
11+    mem.defenseSuccess = 0;
12+    mem.aggression = 0.6;
13+    mem.strikeQueue = [];
14+    mem.staminaCritical = false;
15+    mem.ropeDanger = false;
16+    mem.lastHitTaken = 0;
17+    mem.counterOpportunities = 0;
18+    mem.attackPattern = ["jab", "cross", "hook"];
19+    mem.patternIdx = 0;
20+    mem.evasionPattern = ["slip_left", "slip_right", "duck"];
21+    mem.evadeIdx = 0;
22+    mem.state = "neutral"; // neutral, attacking, defending, countering
23+  }
24+  
25+  // Update opponent tracking
26+  if (opp.move !== mem.lastOppAction && opp.state === "attacking") {
27+    mem.oppActionHistory.push({move: opp.move, time: ring.time});
28+    if (mem.oppActionHistory.length > 8) mem.oppActionHistory.shift();
29+    mem.lastOppAction = opp.move;
30+  }
31+  
32+  // Track range
33+  mem.rangeHistory.push(opp.distance);
34+  if (mem.rangeHistory.length > 15) mem.rangeHistory.shift();
35+  
36+  // Situation analysis
37+  const isHurt = me.hurt || me.hp < 50;
38+  const isFresh = me.stamina > 75 && me.hp > 85;
39+  const isTired = me.stamina < 20;
40+  mem.ropeDanger = me.spaceBehind < 0.5;
41+  const opponentOpen = opp.state === "attacking" && opp.phase === "recovery" && opp.framesLeft > 8;
42+  const opponentStarting = opp.state === "attacking" && opp.phase === "startup";
43+  
44+  // Adaptive strategy
45+  if (isHurt || isTired || mem.ropeDanger) {
46+    mem.aggression = Math.max(0.2, mem.aggression - 0.15);
47+    mem.state = "defending";
48+  } else if (isFresh && (opp.hurt || opponentOpen)) {
49+    mem.aggression = Math.min(0.9, mem.aggression + 0.15);
50+    mem.state = "attacking";
51+  }
52+  
53+  // Range calculations
54+  const jabRange = me.reach * 1.1;
55+  const crossRange = jabRange * 1.15;
56+  const hookRange = jabRange * 0.9;
57+  
58+  // Dynamic range control
59+  const targetRange = (() => {
60+    if (mem.aggression > 0.7) return jabRange - 0.15; // Pressure
61+    if (mem.aggression < 0.3) return jabRange + 0.25; // Safety
62+    return jabRange; // Boxing range
63+  })();
64+  
65+  // Movement control
66+  if (opp.distance > targetRange + 0.15) {
67+    order.fwd = Math.min(0.9, (opp.distance - targetRange) * 1.5);
68+  } else if (opp.distance < targetRange - 0.15) {
69+    order.fwd = Math.max(-0.8, -(targetRange - opp.distance) * 1.5);
70+  }
71+  
72+  // Circle movement - strategic positioning
73+  const circleBase = (ring.time % 3 === 0) ? 0.4 : -0.3;
74+  order.side = circleBase * (1 + 0.3 * Math.sin(ring.time * 2));
75+  
76+  // Rope escape priority
77+  if (mem.ropeDanger) {
78+    order.side = (me.facing > 0) ? 0.9 : -0.9;
79+    order.fwd = 0.8;
80+    mem.state = "defending";
81+  }
82+  
83+  // DEFENSE SYSTEM - Intelligent reaction
84+  if (opponentStarting) {
85+    const attack = opp.move;
86+    
87+    // Specialized defense for each attack type
88+    if (attack === "low_kick") {
89+      if (me.canAct) {
90+        order.action = "block_low";
91+        mem.defenseSuccess++;
92+        mem.strikeQueue.push("cross"); // Immediate counter
93+        return order;
94+      }
95+    } 
96+    else if (attack === "roundhouse") {
97+      if (opp.distance < 1.4 && me.canAct) {
98+        order.action = "duck";
99+        mem.defenseSuccess++;
100+        if (opp.distance < crossRange) {
101+          mem.strikeQueue.push("cross");
102+        }
103+        return order;
104+      } else {
105+        order.fwd = -1; // Get out of range
106+        return order;
107+      }
108+    }
109+    else if (attack === "teep") {
110+      if (opp.distance < 1.5 && me.canAct) {
111+        order.action = "sidestep_left";
112+        mem.defenseSuccess++;
113+        if (opp.distance < crossRange) {
114+          mem.strikeQueue.push("hook");
115+        }
116+        return order;
117+      }
118+    }
119+    else {
120+      // For punches - mixed defense
121+      if (me.canAct) {
122+        if (mem.defenseSuccess % 3 === 0 && attack !== "hook") {
123+          // Block occasionally
124+          order.action = "block_high";
125+        } else {
126+          // Usually evade
127+          if (mem.evadeIdx >= mem.evasionPattern.length) mem.evadeIdx = 0;
128+          order.action = mem.evasionPattern[mem.evadeIdx];
129+          mem.evadeIdx++;
130+        }
131+        mem.defenseSuccess++;
132+        
133+        // Quick counter if in range
134+        if (opp.distance < crossRange && attack !== "hook") {
135+          mem.strikeQueue.push("cross");
136+        }
137+        return order;
138+      }
139+    }
140+  }
141+  
142+  // Process counter queue
143+  if (mem.strikeQueue.length > 0 && me.canAct) {
144+    order.action = mem.strikeQueue.shift();
145+    mem.lastMoveTime = ring.time;
146+    return order;
147+  }
148+  
149+  // OFFENSIVE SYSTEM - Calculated aggression
150+  if (me.canAct && !isTired && mem.aggression > 0.3) {
151+    const readyToAttack = (
152+      me.stamina > 25 &&
153+      !isHurt &&
154+      opp.state !== "attacking" &&
155+      opp.phase !== "startup" &&
156+      (ring.time - (mem.lastMoveTime || 0) > 0.3)
157+    );
158+    
159+    if (readyToAttack) {
160+      // Range-based attack selection
161+      if (opp.distance < hookRange && mem.aggression > 0.6) {
162+        // Close power shots
163+        const powerMoves = ["hook", "uppercut", "body_hook"];
164+        const move = powerMoves[Math.floor(Math.random() * powerMoves.length)];
165+        order.action = move;
166+        mem.lastMoveTime = ring.time;
167+        mem.myCombos++;
168+        
169+      } else if (opp.distance < jabRange && mem.aggression > 0.4) {
170+        // Boxing combinations
171+        if (mem.patternIdx >= mem.attackPattern.length) {
172+          mem.patternIdx = 0;
173+          // Rotate patterns
174+          const patterns = [
175+            ["jab", "cross"],
176+            ["jab", "cross", "hook"],
177+            ["jab", "body_hook", "hook"],
178+            ["cross", "hook"]
179+          ];
180+          mem.attackPattern = patterns[Math.floor(Math.random() * patterns.length)];
181+        }
182+        
183+        order.action = mem.attackPattern[mem.patternIdx];
184+        mem.patternIdx++;
185+        mem.lastMoveTime = ring.time;
186+        mem.myCombos++;
187+        
188+      } else if (opp.distance > jabRange - 0.1 && opp.distance < jabRange * 1.3) {
189+        // Long range - probes and distance management
190+        if (Math.random() < 0.6) {
191+          order.action = "teep";
192+          mem.lastMoveTime = ring.time;
193+          mem.myCombos++;
194+        }
195+      }
196+      
197+      // Combo extensions
198+      if (me.lastLanded && me.canCancelInto.length > 0) {
199+        const extensions = {
200+          "jab": ["cross", "hook"],
201+          "cross": ["hook", "body_hook"],
202+          "hook": ["cross"],
203+          "teep": ["cross", "jab"]
204+        };
205+        
206+        if (extensions[me.lastLanded] && Math.random() < 0.6) {
207+          const options = extensions[me.lastLanded];
208+          mem.strikeQueue.push(options[Math.floor(Math.random() * options.length)]);
209+        }
210+      }
211+    }
212+  }
213+  
214+  // Stamina management
215+  if (me.stamina < 30) {
216+    order.fwd *= 0.6;
217+    order.side *= 0.6;
218+    if (opp.distance < 1.6 && me.canAct && opp.state !== "attacking") {
219+      order.action = "block_high";
220+    }
221+  }
222+  
223+  // Emergency recovery
224+  if (isHurt && me.hp < 35) {
225+    order.fwd = -1;
226+    order.side = 0;
227+    if (opp.distance < 2.0 && me.canAct) {
228+      order.action = "block_high";
229+    }
230+  }
231+  
232+  return order;
233+}

1+function tick(me, opp, ring, mem) {
2+  var o = { fwd: 0, side: 0, action: null };
3+  if (!mem.i) {
4+    mem.i = 1;
5+    mem.k = 1;
6+    mem.flipAt = 2.3;
7+    mem.prevD = opp.distance || 2;
8+    mem.burst = -1;
9+    mem.kickT = -3;
10+    mem.logT = 0;
11+    mem.wasAtk = -1;
12+  }
13+
14+  var d = opp.distance;
15+  var t = ring.time;
16+  var reach = me.reach || 1.06;
17+  var stam = me.stamina;
18+  var ropes = me.spaceBehind < 1.0;
19+  var can = me.canCancelInto || [];
20+  var mv = opp.move || "";
21+  var st = opp.state;
22+  var ph = opp.phase;
23+  var closing = mem.prevD - d > 0.03;
24+  mem.prevD = d;
25+
26+  if (t > mem.flipAt) {
27+    mem.k *= -1;
28+    mem.flipAt = t + 1.8;
29+  }
30+  o.side = mem.k * (ropes ? 1 : 0.48);
31+
32+  if (t - mem.logT > 12) {
33+    log("t=" + (t | 0) + " d=" + d.toFixed(2) + " hp=" + (me.hp | 0) + "/" + (opp.hp | 0) + " st=" + (stam | 0) + " rb=" + me.spaceBehind.toFixed(1) + " " + st + "/" + mv);
34+    mem.logT = t;
35+  }
36+
37+  if (st === "down" || st === "getting_up") {
38+    o.fwd = d < 1.5 ? -0.05 : 0.25;
39+    return o;
40+  }
41+
42+  if (me.hurt || me.stun > 50) {
43+    o.action = "block_high";
44+    o.fwd = ropes ? 0.75 : -0.55;
45+    o.side = mem.k;
46+    return o;
47+  }
48+
49+  if (st === "attacking") mem.wasAtk = t;
50+
51+  var start = st === "attacking" && ph === "startup";
52+  var rec = st === "attacking" && ph === "recovery";
53+  var kill = opp.hurt || opp.hp < 20;
54+  var winning = me.hp > opp.hp + 10 && ring.timeLeft < 20;
55+  var interval = stam > 42 ? 0.48 : stam > 28 ? 0.7 : 1.05;
56+  if (winning) interval += 0.35;
57+  if (kill) interval = 0.38;
58+  var wantAtk = (t - mem.burst >= interval) && stam > 15 && d <= reach + 0.07 && d > 0.57;
59+
60+  if (can.length) {
61+    if (d < 0.84 && can.indexOf("uppercut") >= 0 && (opp.guard === "high" || mv === "duck")) {
62+      o.action = "uppercut";
63+      return o;
64+    }
65+    if (d < 0.8 && can.indexOf("body_hook") >= 0 && opp.guard === "high") {
66+      o.action = "body_hook";
67+      return o;
68+    }
69+    if (can.indexOf("cross") >= 0 && d > 0.55 && d < reach + 0.16) {
70+      o.action = "cross";
71+      return o;
72+    }
73+    if (can.indexOf("hook") >= 0 && d < 0.96) {
74+      o.action = "hook";
75+      return o;
76+    }
77+    if (can.indexOf("body_hook") >= 0 && d < 0.82) {
78+      o.action = "body_hook";
79+      return o;
80+    }
81+  }
82+
83+  if (start) {
84+    if (mv === "roundhouse") {
85+      if (d < reach && d > 0.6 && me.canAct && stam > 8) {
86+        o.action = "jab";
87+        mem.burst = t;
88+        return o;
89+      }
90+      o.action = ropes ? (mem.k > 0 ? "sidestep_right" : "sidestep_left") : "dash_back";
91+      o.fwd = ropes ? 0.6 : -1;
92+      o.side = mem.k;
93+      return o;
94+    }
95+    if (mv === "teep") {
96+      o.action = mem.k > 0 ? "sidestep_right" : "sidestep_left";
97+      o.side = mem.k;
98+      o.fwd = 0.45;
99+      return o;
100+    }
101+    if (mv === "low_kick" || mv === "body_hook" || mv === "knee") {
102+      o.action = "block_low";
103+      o.fwd = ropes ? 0.5 : 0;
104+      return o;
105+    }
106+    if (mv === "hook") {
107+      o.action = opp.stance === "southpaw" ? "slip_right" : "slip_left";
108+      return o;
109+    }
110+    if (mv === "uppercut") {
111+      o.action = "block_high";
112+      o.fwd = ropes ? 0.3 : -0.2;
113+      return o;
114+    }
115+    if (mv === "cross") {
116+      o.action = "block_high";
117+      return o;
118+    }
119+  }
120+
121+  if (ropes) {
122+    o.fwd = 0.95;
123+    o.side = mem.k;
124+  } else if (d > reach + 0.06) {
125+    o.fwd = 1;
126+  } else if (d < 0.66) {
127+    o.fwd = -0.7;
128+  } else if (d < reach - 0.2) {
129+    o.fwd = -0.32;
130+  } else {
131+    o.fwd = 0.1;
132+  }
133+
134+  if (!me.canAct) return o;
135+
136+  if (stam < 12) {
137+    o.action = "block_high";
138+    o.fwd = ropes ? 0.6 : -0.22;
139+    return o;
140+  }
141+
142+  if (ropes && d > 0.88 && d < 1.4 && stam > 14 && !wantAtk) {
143+    o.action = mem.k > 0 ? "sidestep_right" : "sidestep_left";
144+    return o;
145+  }
146+
147+  if (rec && (mv === "cross" || mv === "hook" || mv === "roundhouse" || mv === "teep" || mv === "low_kick" || mv === "uppercut" || mv === "knee" || mv === "body_hook")) {
148+    if (d < 0.86) {
149+      o.action = "hook";
150+      o.fwd = 0.5;
151+      mem.burst = t;
152+      return o;
153+    }
154+    if (d <= reach + 0.12) {
155+      o.action = stam > 22 ? "cross" : "jab";
156+      o.fwd = 0.35;
157+      mem.burst = t;
158+      return o;
159+    }
160+  }
161+
162+  if (d > reach + 0.22) {
163+    if (stam > 38 && d > 1.5) o.action = "dash_forward";
164+    return o;
165+  }
166+
167+  if (d < 0.64) {
168+    o.action = opp.guard === "high" ? "body_hook" : (opp.guard === "low" ? "hook" : "knee");
169+    mem.burst = t;
170+    return o;
171+  }
172+
173+  if (kill && stam > 16 && d < 1.05 && d > 0.6) {
174+    o.action = d < 0.9 ? "hook" : "cross";
175+    o.fwd = 0.4;
176+    mem.burst = t;
177+    return o;
178+  }
179+
180+  if (closing && d > 0.88 && d < 1.24 && stam > 34 && t - mem.kickT > 2.8) {
181+    o.action = "teep";
182+    mem.kickT = t;
183+    mem.burst = t;
184+    return o;
185+  }
186+
187+  if (wantAtk) {
188+    if (opp.guard === "high" && d > 0.7 && d < 0.96 && stam > 26 && t - mem.kickT > 2.1) {
189+      o.action = "low_kick";
190+      mem.kickT = t;
191+      mem.burst = t;
192+      return o;
193+    }
194+    if (opp.guard === "low" && d < 0.95 && stam > 22) {
195+      o.action = "hook";
196+      mem.burst = t;
197+      return o;
198+    }
199+    o.action = "jab";
200+    mem.burst = t;
201+    return o;
202+  }
203+
204+  if (d < reach + 0.18) o.action = "block_high";
205+  return o;
206+}