SirStone/SirRoboGarage
1
0
Fork 0
Code Issues 28 Pull Requests Actions Projects Releases Wiki Activity

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

Browse Source 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Davide Cappellini
2026-09-20 12:28:27 +02:00
parent f06b263ae5
commit ae9a5fec6d
4 changed files with 87 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common_libs/gun_harness/gun_interface.nim
+8 -1
View File
@@ -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 -5
View File
@@ -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
+67 -30
View File
@@ -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