diff --git a/ModularBot_garage/src/ModularBot.nim b/ModularBot_garage/src/ModularBot.nim index b8fd347..5575499 100644 --- a/ModularBot_garage/src/ModularBot.nim +++ b/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) = diff --git a/common_libs/gun_harness/gun_interface.nim b/common_libs/gun_harness/gun_interface.nim index ce61bc6..427411e 100644 --- a/common_libs/gun_harness/gun_interface.nim +++ b/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. diff --git a/common_libs/movements/minimum_risk.nim b/common_libs/movements/minimum_risk.nim index 05310f8..c5764e0 100644 --- a/common_libs/movements/minimum_risk.nim +++ b/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 diff --git a/common_libs/movements/phantom_meteor.nim b/common_libs/movements/phantom_meteor.nim index 9898b37..fee0992 100644 --- a/common_libs/movements/phantom_meteor.nim +++ b/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..= 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