feat(movement): multi-enemy awareness — phantom meteor + minimum risk track all enemies

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

common_libs/movements/minimum_risk.nim

@@ -7,9 +7,6 @@ import std/math
 import gun_harness/gun_interface
 import movement_harness/movement_interface
 
-# TODO: WorldState only carries one enemy. Extend WorldState with a seq of
-# threat positions (enemies) and update scoreCandidates to iterate all of them.
-# For now we treat the single enemy as the only threat point.
 
 const
   CandidateRadius = 150.0   # px radius for ring candidates
@@ -80,8 +77,13 @@ proc recalcTarget(m: var MinimumRiskModule, ws: WorldState) =
   let w   = ws.arenaWidth
   let h   = ws.arenaHeight
 
-  # Single threat for now; TODO: replace with ws.enemies when available
-  let threats = [vec2(ws.enemyX, ws.enemyY)]
+  # Use all alive enemies; fall back to single target when seq is empty
+  var threats: seq[Vec2]
+  if ws.enemies.len > 0:
+    for ei in ws.enemies:
+      threats.add vec2(ei.x, ei.y)
+  else:
+    threats.add vec2(ws.enemyX, ws.enemyY)
 
   # Build candidates: ring + random (deterministic via tick-seeded offsets)
   var best     = bot          # fallback: stay put

common_libs/movements/phantom_meteor.nim

@@ -3,7 +3,7 @@
 ## Fire detection, phantom bullets, waves, and danger histogram are all internal.
 ## All angles in radians internally; interface outputs degrees for bot API.
 
-import std/math
+import std/[math, tables]
 import gun_harness/gun_interface
 import movement_harness/movement_interface
 import movement_harness/gunheat_tracker
@@ -53,7 +53,7 @@ type
     histogram:       DangerHistogram
     phantoms:        seq[PhantomBullet]
     waves:           seq[Wave]
-    prevEnemyEnergy: float64
+    prevEnemyEnergy: Table[int, float64]  # keyed by enemy id; id=-1 for legacy single-enemy
 
 # ── Gravity engine internals ──────────────────────────────────────────────────
 
@@ -74,16 +74,17 @@ const
 proc initEngine(): GravityEngine =
   var h: DangerHistogram
   for i in 0..<NumBins: h.bins[i] = 1.0
-  GravityEngine(histogram: h, phantoms: @[], waves: @[], prevEnemyEnergy: 100.0)
+  GravityEngine(histogram: h, phantoms: @[], waves: @[], prevEnemyEnergy: {-1: 100.0}.toTable)
 
 proc gfToBin(gf: float64): int =
   int(((gf.clamp(-1.0,1.0) + 1.0) / 2.0 * float64(NumBins-1)).round).clamp(0, NumBins-1)
 
 proc mea(speed: float64): float64 = arcsin(min(8.0/speed, 1.0))
 
-proc detectFire(eng: var GravityEngine, energy: float64): tuple[fired: bool; power: float64] =
-  let drop = eng.prevEnemyEnergy - energy
-  eng.prevEnemyEnergy = energy
+proc detectFire(eng: var GravityEngine, id: int, energy: float64): tuple[fired: bool; power: float64] =
+  let prev = eng.prevEnemyEnergy.getOrDefault(id, 100.0)
+  let drop = prev - energy
+  eng.prevEnemyEnergy[id] = energy
   if drop >= 0.1 and drop <= 3.0: (true, drop) else: (false, 0.0)
 
 proc spawnPhantoms(eng: var GravityEngine, enemyPos, botPos: Vec2, bspeed: float64) =
@@ -133,7 +134,7 @@ proc tickWaves(eng: var GravityEngine, botPos: Vec2) =
     else:
       inc i
 
-proc computeForces(eng: GravityEngine, botPos, enemyPos: Vec2, arenaW, arenaH: float64): Vec2 =
+proc computeForces(eng: GravityEngine, botPos: Vec2, enemies: openArray[Vec2], arenaW, arenaH: float64): Vec2 =
   var total = vec2(0.0, 0.0)
 
   # Priority 1: nearby phantoms
@@ -156,18 +157,29 @@ proc computeForces(eng: GravityEngine, botPos, enemyPos: Vec2, arenaW, arenaH: f
     let wm = sqrt(ex*ex + ey*ey)
     if wm > 0.1: total = total + normalize(vec2(ex, ey)) * 500.0
 
-  # Priority 3: distance to enemy — symmetric attraction/repulsion around PreferredDist.
-  # Linear ramp over ±150px so the transition is smooth, not a hard switch.
-  # ponytail: linear ramp, tune rampWidth if distance oscillates
-  let de = dist(enemyPos, botPos)
-  if not hasClose and de > 100.0:
+  # Priority 3: repulsion from ALL enemies; attraction only toward nearest.
+  # ponytail: linear ramp per enemy, attraction only toward nearest to avoid being pulled into a crowd
+  if not hasClose and enemies.len > 0:
     const rampWidth = 150.0
-    let distErr = de - PreferredDist          # >0 = too far, <0 = too close
-    let t = clamp(distErr / rampWidth, -1.0, 1.0)
-    # t > 0 → attract toward enemy; t < 0 → repel away
-    let dir = if t >= 0.0: normalize(enemyPos - botPos)
-              else:         normalize(botPos - enemyPos)
-    total = total + dir * (KEnemy * abs(t))
+    # Find nearest enemy for possible attraction
+    var nearestDist = Inf
+    var nearestIdx  = 0
+    for i, ep in enemies:
+      let d = dist(ep, botPos)
+      if d < nearestDist:
+        nearestDist = d
+        nearestIdx  = i
+    for i, ep in enemies:
+      let de = dist(ep, botPos)
+      if de <= 100.0: continue
+      let distErr = de - PreferredDist
+      let t = clamp(distErr / rampWidth, -1.0, 1.0)
+      if t < 0.0:
+        # Too close → repel from this enemy
+        total = total + normalize(botPos - ep) * (KEnemy * abs(t))
+      elif i == nearestIdx:
+        # Too far from nearest only → mild attraction
+        total = total + normalize(ep - botPos) * (KEnemy * t)
 
   # Priority 4: weak wall repulsion
   let dL = max(botPos.x,         WallMinDist)
@@ -191,13 +203,21 @@ proc resetRound*(m: var PhantomMeteorModule) =
   ## Clear per-round transients (phantoms, waves, energy baseline), keep histogram.
   m.engine.phantoms        = @[]
   m.engine.waves           = @[]
-  m.engine.prevEnemyEnergy = 100.0
+  m.engine.prevEnemyEnergy = {-1: 100.0}.toTable
   m.gunheat.resetRound()
 
 proc computeMove*(m: var PhantomMeteorModule, ws: WorldState): MoveCommand =
   let botPos   = vec2(ws.selfX, ws.selfY)
   let enemyPos = vec2(ws.enemyX, ws.enemyY)
 
+  # Build enemies Vec2 seq (falls back to single target when ws.enemies is empty)
+  var enemyVecs: seq[Vec2]
+  if ws.enemies.len > 0:
+    for ei in ws.enemies:
+      enemyVecs.add vec2(ei.x, ei.y)
+  else:
+    enemyVecs.add enemyPos
+
   # ── Ram override ─────────────────────────────────────────────────────────────
   let ramDist        = dist(botPos, enemyPos)
   let ramFinisher    = ramDist < 300.0 and ws.enemyEnergy < 20.0 and ws.selfEnergy > ws.enemyEnergy
@@ -218,7 +238,7 @@ proc computeMove*(m: var PhantomMeteorModule, ws: WorldState): MoveCommand =
   m.engine.tickPhantoms()
   m.engine.tickWaves(botPos)
 
-  # Fire detection via gunheat tracker (1-2 ticks earlier than energy drop).
+  # Fire detection via gunheat tracker for the primary target (1-2 ticks earlier than energy drop).
   var spawnedThisTick = false
   for ev in m.gunheat.tick(ws):
     let bspeed = 20.0 - 3.0 * ev.bulletPower
@@ -233,29 +253,46 @@ proc computeMove*(m: var PhantomMeteorModule, ws: WorldState): MoveCommand =
         m.engine.spawnPhantoms(evPos, botPos, bspeed)
         m.engine.spawnWave(evPos, botPos, bspeed)
         spawnedThisTick = true
-  # Fallback: energy-drop detection (fires if gunheat tracker missed it).
+
+  # Energy-drop fallback for primary target; also sync prevEnergy so non-target check is clean.
   if not spawnedThisTick:
-    let (fired, power) = m.engine.detectFire(ws.enemyEnergy)
+    let (fired, power) = m.engine.detectFire(-1, ws.enemyEnergy)
     if fired:
       let bspeed = 20.0 - 3.0 * power
       m.engine.spawnPhantoms(enemyPos, botPos, bspeed)
       m.engine.spawnWave(enemyPos, botPos, bspeed)
   else:
-    # Keep prevEnemyEnergy in sync so energy-drop fallback stays coherent.
-    discard m.engine.detectFire(ws.enemyEnergy)
+    discard m.engine.detectFire(-1, ws.enemyEnergy)
+
+  # Energy-drop detection for non-target enemies (raw energy comparison; no gunheat needed)
+  for ei in ws.enemies:
+    if ei.id == -1: continue  # skip sentinel
+    let (fired, power) = m.engine.detectFire(ei.id, ei.energy)
+    if fired:
+      let bspeed = 20.0 - 3.0 * power
+      let epos   = vec2(ei.x, ei.y)
+      m.engine.spawnPhantoms(epos, botPos, bspeed)
+      m.engine.spawnWave(epos, botPos, bspeed)
 
   # Compute force vector
-  let force = m.engine.computeForces(botPos, enemyPos, ws.arenaWidth, ws.arenaHeight)
+  let force = m.engine.computeForces(botPos, enemyVecs, ws.arenaWidth, ws.arenaHeight)
 
   if force.magnitude < 1e-9:
     return (speed: 0.0, turnRate: 0.0)
 
-  # Enemy bearing (radians, math convention: 0=East, CCW+)
-  let enemyBearingRad = arctan2(enemyPos.y - botPos.y, enemyPos.x - botPos.x)
+  # Threat centroid (inverse-distance weighted) for perpendicular direction.
+  # With 1 enemy this equals the single enemy bearing — identical to prior behavior.
+  var cx = 0.0; var cy = 0.0; var wsum = 0.0
+  for ep in enemyVecs:
+    let d = max(dist(ep, botPos), 1.0)
+    let w = 1.0 / d
+    cx += ep.x * w; cy += ep.y * w; wsum += w
+  let centroid = if wsum > 1e-9: vec2(cx/wsum, cy/wsum) else: enemyPos
+  let centroidBearingRad = arctan2(centroid.y - botPos.y, centroid.x - botPos.x)
 
-  # Two perpendicular directions to enemy bearing (±90°)
-  let perpCCW = vec2(-sin(enemyBearingRad),  cos(enemyBearingRad))  # +90°
-  let perpCW  = vec2( sin(enemyBearingRad), -cos(enemyBearingRad))  # -90°
+  # Two perpendicular directions to centroid bearing (±90°)
+  let perpCCW = vec2(-sin(centroidBearingRad),  cos(centroidBearingRad))  # +90°
+  let perpCW  = vec2( sin(centroidBearingRad), -cos(centroidBearingRad))  # -90°
 
   # Pick perpendicular direction that aligns with force vector
   let fn = force.normalize