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

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

ModularBot_garage/src/ModularBot.nim

@@ -88,6 +88,10 @@ proc printConfig(bot: ModularBot, changed: string = "") =
   echo CLR_ROUND & "[config]" & CLR_RST & " " & gunColor & "gun=" & gunName & CLR_RST & " | " & CLR_MOVE & "move=phantom_meteor" & CLR_RST & " | " & radarColor & "radar=" & radarName & CLR_RST & " | enemies=" & $bot.enemyTracker.allAlive().len & " target=#" & $bot.currentTargetId
 
 proc buildState(bot: ModularBot, ex, ey, espeed, eheading, eenergy: float): WorldState =
+  var ei: seq[EnemyInfo]
+  for es in bot.enemyTracker.allAlive():
+    ei.add EnemyInfo(id: es.id, x: es.x, y: es.y,
+                     heading: es.heading, speed: es.speed, energy: es.energy)
   WorldState(
     enemyX:       ex,
     enemyY:       ey,
@@ -103,6 +107,7 @@ proc buildState(bot: ModularBot, ex, ey, espeed, eheading, eenergy: float): Worl
     arenaWidth:  getArenaWidth().float,
     arenaHeight: getArenaHeight().float,
     tick:        bot.tick,
+    enemies:     ei,
   )
 
 method onScannedBot*(bot: ModularBot, e: ScannedBotEvent) =

common_libs/gun_harness/gun_interface.nim

@@ -7,9 +7,14 @@ import std/math
 const BotRadius* = 18.0  ## hit detection radius in px
 
 type
+  EnemyInfo* = object
+    id*:                      int
+    x*, y*:                   float
+    heading*, speed*, energy*: float
+
   WorldState* = object
     ## All raw data given to every gun every tick.
-    # Enemy
+    # Enemy (current TARGET)
     enemyX*, enemyY*:         float
     enemySpeed*, enemyHeading*: float
     # Self
@@ -22,6 +27,8 @@ type
     arenaWidth*, arenaHeight*: float
     # Meta
     tick*:                    int
+    # All alive enemies (for movement modules)
+    enemies*:                 seq[EnemyInfo]
 
   GunPrediction* = object
     ## Absolute (x, y) where the gun predicts the enemy will be.

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
+  # Use all alive enemies; fall back to single target when seq is empty
-  let threats = [vec2(ws.enemyX, ws.enemyY)]
+  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] =
+proc detectFire(eng: var GravityEngine, id: int, energy: float64): tuple[fired: bool; power: float64] =
-  let drop = eng.prevEnemyEnergy - energy
+  let prev = eng.prevEnemyEnergy.getOrDefault(id, 100.0)
-  eng.prevEnemyEnergy = energy
+  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.
+  # Priority 3: repulsion from ALL enemies; attraction only toward nearest.
-  # Linear ramp over ±150px so the transition is smooth, not a hard switch.
+  # ponytail: linear ramp per enemy, attraction only toward nearest to avoid being pulled into a crowd
-  # ponytail: linear ramp, tune rampWidth if distance oscillates
+  if not hasClose and enemies.len > 0:
-  let de = dist(enemyPos, botPos)
-  if not hasClose and de > 100.0:
     const rampWidth = 150.0
-    let distErr = de - PreferredDist          # >0 = too far, <0 = too close
+    # Find nearest enemy for possible attraction
-    let t = clamp(distErr / rampWidth, -1.0, 1.0)
+    var nearestDist = Inf
-    # t > 0 → attract toward enemy; t < 0 → repel away
+    var nearestIdx  = 0
-    let dir = if t >= 0.0: normalize(enemyPos - botPos)
+    for i, ep in enemies:
-              else:         normalize(botPos - enemyPos)
+      let d = dist(ep, botPos)
-    total = total + dir * (KEnemy * abs(t))
+      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(-1, ws.enemyEnergy)
-    discard m.engine.detectFire(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+)
+  # Threat centroid (inverse-distance weighted) for perpendicular direction.
-  let enemyBearingRad = arctan2(enemyPos.y - botPos.y, enemyPos.x - botPos.x)
+  # 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°)
+  # Two perpendicular directions to centroid bearing (±90°)
-  let perpCCW = vec2(-sin(enemyBearingRad),  cos(enemyBearingRad))  # +90°
+  let perpCCW = vec2(-sin(centroidBearingRad),  cos(centroidBearingRad))  # +90°
-  let perpCW  = vec2( sin(enemyBearingRad), -cos(enemyBearingRad))  # -90°
+  let perpCW  = vec2( sin(centroidBearingRad), -cos(centroidBearingRad))  # -90°
 
   # Pick perpendicular direction that aligns with force vector
   let fn = force.normalize