feat(SNNBot): upgrade bot API, fix debug overlay and aiming lines
- Upgrade to robocode_tankroyale_botapi v1.0.7 (SVG viewBox fix) - Fix Y-axis mirror in aiming line toXY helper - Resize debug panel to half arena width/height - Replace neuron boxes with barcode-style spike lines - Thickness-encoded weight connections (all 216 lines) - Add aiming line legend (top-left, white text) - Dynamic aiming line length (distance + 50px overshoot)
This commit is contained in:
@@ -0,0 +1,292 @@
|
||||
# SNNBot — SNN core + aiming loop prototype (issue #152).
|
||||
# 36-input population-coded → 6 LIF hidden → 1 membrane-readout output.
|
||||
# No movement, no firing, no learning. Proves plumbing.
|
||||
#
|
||||
# State machine:
|
||||
# DECIDE → feed bearing into SNN, store targetAngle, → WAITING
|
||||
# WAITING → aimTo() each tick; when error < 2° → EVALUATE
|
||||
# EVALUATE → measure error, compute reward, log, → DECIDE
|
||||
|
||||
import std/[math, random, os]
|
||||
import robocode_tankroyale_botapi
|
||||
import radar_lock/radar_lock as radar_lock
|
||||
|
||||
# ── Constants ──────────────────────────────────────────────────────────────────
|
||||
|
||||
const botJsonPath = currentSourcePath().parentDir / "SNNBot.json"
|
||||
|
||||
const
|
||||
N_IN = 36 # input neurons (10°-wide bands, -180..+180)
|
||||
N_HID = 6 # hidden LIF neurons
|
||||
BAND_DEG = 10.0 # degrees per input band
|
||||
LEAK = 0.9 # LIF membrane leak factor
|
||||
THRESH = 1.0 # LIF spike threshold
|
||||
MAX_GUN_TURN = 20.0 # max gun turn per tick (degrees)
|
||||
AIM_TOL = 2.0 # arrive tolerance (degrees)
|
||||
|
||||
# ── SNN types ─────────────────────────────────────────────────────────────────
|
||||
|
||||
type
|
||||
SNN = object
|
||||
wih: array[N_IN * N_HID, float] # 36×6 input→hidden weights
|
||||
who: array[N_HID, float] # 6×1 hidden→output weights
|
||||
vHid: array[N_HID, float] # hidden membrane potentials
|
||||
vOut: float # output membrane potential (readout)
|
||||
|
||||
proc initSNN(snn: var SNN) =
|
||||
# ponytail: uniform random init, fine until STDP training added in #155
|
||||
randomize()
|
||||
for w in snn.wih.mitems: w = rand(1.0) - 0.5
|
||||
for w in snn.who.mitems: w = rand(1.0) - 0.5
|
||||
|
||||
proc encodeInput(bearing: float): array[N_IN, float] =
|
||||
## Population-code bearing into N_IN neurons.
|
||||
## Each neuron owns a 10° band centred at -175, -165, …, +175.
|
||||
## The band that contains the bearing fires 1.0; both neighbours get
|
||||
## linear interpolation for smoother encoding.
|
||||
let norm = ((bearing + 180.0) / BAND_DEG) # 0..36
|
||||
let lo = int(norm) mod N_IN
|
||||
let hi = (lo + 1) mod N_IN
|
||||
let frac = norm - float(int(norm)) # fractional position in band
|
||||
result[lo] = 1.0 - frac
|
||||
result[hi] = frac
|
||||
|
||||
proc forward(snn: var SNN, inputs: array[N_IN, float]): float =
|
||||
## One SNN tick. Returns target angle in degrees (-180..+180).
|
||||
# Hidden layer: LIF update
|
||||
var spikes: array[N_HID, float]
|
||||
for h in 0 ..< N_HID:
|
||||
var wsum = 0.0
|
||||
for i in 0 ..< N_IN:
|
||||
wsum += inputs[i] * snn.wih[i * N_HID + h]
|
||||
snn.vHid[h] = LEAK * snn.vHid[h] + wsum
|
||||
if snn.vHid[h] >= THRESH:
|
||||
spikes[h] = 1.0
|
||||
snn.vHid[h] = 0.0
|
||||
else:
|
||||
spikes[h] = 0.0
|
||||
|
||||
# Output layer: membrane readout (no threshold)
|
||||
var osum = 0.0
|
||||
for h in 0 ..< N_HID:
|
||||
osum += spikes[h] * snn.who[h]
|
||||
snn.vOut = LEAK * snn.vOut + osum
|
||||
|
||||
# Scale vOut to [-180, +180]. vOut is unbounded so clamp after tanh-like squash.
|
||||
# ponytail: simple linear scale; replace with proper output neuron tuning in #155
|
||||
result = tanh(snn.vOut) * 180.0
|
||||
|
||||
# ── Bot state machine ─────────────────────────────────────────────────────────
|
||||
|
||||
type
|
||||
Phase = enum DECIDE, WAITING, EVALUATE
|
||||
|
||||
SNNBot = ref object of Bot
|
||||
snn: SNN
|
||||
phase: Phase
|
||||
targetAngle: float # SNN output (absolute bearing)
|
||||
enemyBearing: float # last known enemy bearing
|
||||
enemyDist: float # last known distance to enemy
|
||||
hasContact: bool
|
||||
tick: int
|
||||
|
||||
# ── aimTo helper ──────────────────────────────────────────────────────────────
|
||||
|
||||
proc aimTo(targetAngle, gunDir: float) {.inline.} =
|
||||
let delta = normalizeRelativeAngle(targetAngle - gunDir)
|
||||
setGunTurnRate(delta.clamp(-MAX_GUN_TURN, MAX_GUN_TURN))
|
||||
|
||||
# ── Debug overlay ─────────────────────────────────────────────────────────────
|
||||
|
||||
proc drawOverlay(bot: SNNBot, myX, myY, gunDir, enemyBearing, targetAngle: float) =
|
||||
let LINE_LEN = bot.enemyDist + 50.0
|
||||
# Convert degree bearing to SVG direction (SVG y-axis is inverted; 0=east, CCW+)
|
||||
template toXY(bearing, len: float): (float, float) =
|
||||
(myX + cos(degToRad(bearing)) * len,
|
||||
myY + sin(degToRad(bearing)) * len)
|
||||
|
||||
# Green: enemy direction (truth)
|
||||
setStrokeColor(GREEN)
|
||||
setStrokeWidth(2.0)
|
||||
let (ex, ey) = toXY(enemyBearing, LINE_LEN)
|
||||
drawLine(myX, myY, ex, ey)
|
||||
|
||||
# Red: gun direction
|
||||
setStrokeColor(RED)
|
||||
let (gx, gy) = toXY(gunDir, LINE_LEN)
|
||||
drawLine(myX, myY, gx, gy)
|
||||
|
||||
# Yellow: SNN target angle
|
||||
setStrokeColor(YELLOW)
|
||||
let (tx, ty) = toXY(targetAngle, LINE_LEN)
|
||||
drawLine(myX, myY, tx, ty)
|
||||
|
||||
# ── Neuron panel — barcode style (top-left corner at 10,10) ──────────────
|
||||
const
|
||||
PX = 10.0 # panel x
|
||||
PY = 10.0 # panel y
|
||||
let
|
||||
panelW = getArenaWidth().float / 2.0
|
||||
panelH = getArenaHeight().float / 2.0
|
||||
CH = (panelH - PY - 20.0) / 7.0 # row height (same formula as before)
|
||||
LAYER_V = CH * 2.0 # inter-layer gap
|
||||
IN_W = panelW # input layer spans full panel width
|
||||
IN_STEP = IN_W / float(N_IN) # spacing between input lines
|
||||
HID_STEP = IN_W / float(N_HID) # spacing between hidden lines
|
||||
# Anchor x of each hidden line — centred within IN_W
|
||||
HID_OFF = 0.0
|
||||
|
||||
# Input layer: vertical line per neuron, visible when activation > 0
|
||||
let inputs = encodeInput(normalizeRelativeAngle(enemyBearing - gunDir))
|
||||
setStrokeWidth(1.0)
|
||||
for i in 0 ..< N_IN:
|
||||
let alpha = uint8(inputs[i] * 255.0)
|
||||
if alpha > 0:
|
||||
let lx = PX + (float(i) + 0.5) * IN_STEP
|
||||
setStrokeColor(fromRgba(0, 200, 255, alpha))
|
||||
drawLine(lx, PY, lx, PY + CH)
|
||||
|
||||
# Hidden layer: vertical line per neuron, visible when spiking
|
||||
let hidY = PY + CH + LAYER_V
|
||||
setStrokeWidth(1.5)
|
||||
for h in 0 ..< N_HID:
|
||||
let v = bot.snn.vHid[h].clamp(0.0, THRESH) / THRESH
|
||||
if v > 0.0:
|
||||
let lx = PX + HID_OFF + (float(h) + 0.5) * HID_STEP
|
||||
let alpha = uint8(v * 255.0)
|
||||
setStrokeColor(fromRgba(255, 140, 0, alpha))
|
||||
drawLine(lx, hidY, lx, hidY + CH)
|
||||
|
||||
# Weight lines: input → hidden (sample every 4th input to avoid clutter)
|
||||
# Fixed light-blue color; thickness proportional to normalized weight magnitude.
|
||||
var maxAbsWih = 0.0
|
||||
for w in bot.snn.wih: maxAbsWih = max(maxAbsWih, abs(w))
|
||||
setStrokeColor(fromRgba(180, 220, 255, 180))
|
||||
for i in 0 ..< N_IN:
|
||||
let ix = PX + (float(i) + 0.5) * IN_STEP
|
||||
let iy = PY + CH
|
||||
for h in 0 ..< N_HID:
|
||||
let hx = PX + HID_OFF + (float(h) + 0.5) * HID_STEP
|
||||
let hy = hidY
|
||||
let w = bot.snn.wih[i * N_HID + h]
|
||||
let norm = if maxAbsWih > 0.0: abs(w) / maxAbsWih else: 0.0
|
||||
setStrokeWidth(0.5 + norm * 2.5)
|
||||
drawLine(ix, iy, hx, hy)
|
||||
|
||||
# Output neuron: single vertical line centred in panel, visible when active
|
||||
let outY = hidY + CH + LAYER_V
|
||||
let outV = (tanh(bot.snn.vOut) + 1.0) / 2.0 # 0..1 for display
|
||||
if outV > 0.0:
|
||||
let lx = PX + IN_W / 2.0
|
||||
let alpha = uint8(outV * 255.0)
|
||||
setStrokeColor(fromRgba(200, 0, 255, alpha))
|
||||
setStrokeWidth(2.0)
|
||||
drawLine(lx, outY, lx, outY + CH)
|
||||
|
||||
# ── Aiming-line legend ────────────────────────────────────────────────────
|
||||
# Arena Y=0 is bottom; top = getArenaHeight(). LEG_Y is the bottom edge of
|
||||
# the legend block so it sits near the top of the screen.
|
||||
const
|
||||
LEG_X = 10.0 # left margin
|
||||
LEG_SQ = 8.0 # coloured square side
|
||||
LEG_GAP = 4.0 # gap between square and text
|
||||
LEG_ROW = 14.0 # row height
|
||||
LEG_PAD = 6.0 # inner padding of background rect
|
||||
let LEG_Y = getArenaHeight().float - 60.0 # near top of arena
|
||||
|
||||
# Semi-transparent background
|
||||
setFillColor(fromRgba(0, 0, 0, 160))
|
||||
fillRectangle(LEG_X - LEG_PAD,
|
||||
LEG_Y - LEG_PAD,
|
||||
LEG_SQ + LEG_GAP + 80.0 + LEG_PAD,
|
||||
3.0 * LEG_ROW + LEG_PAD)
|
||||
|
||||
# Row 0 — Green: Enemy bearing
|
||||
setFillColor(GREEN)
|
||||
fillRectangle(LEG_X, LEG_Y, LEG_SQ, LEG_SQ)
|
||||
setFillColor(WHITE)
|
||||
drawText("Enemy bearing", LEG_X + LEG_SQ + LEG_GAP, LEG_Y + LEG_SQ)
|
||||
|
||||
# Row 1 — Red: Gun direction
|
||||
setFillColor(RED)
|
||||
fillRectangle(LEG_X, LEG_Y + LEG_ROW, LEG_SQ, LEG_SQ)
|
||||
setFillColor(WHITE)
|
||||
drawText("Gun direction", LEG_X + LEG_SQ + LEG_GAP, LEG_Y + LEG_ROW + LEG_SQ)
|
||||
|
||||
# Row 2 — Yellow: SNN target
|
||||
setFillColor(YELLOW)
|
||||
fillRectangle(LEG_X, LEG_Y + 2.0 * LEG_ROW, LEG_SQ, LEG_SQ)
|
||||
setFillColor(WHITE)
|
||||
drawText("SNN target", LEG_X + LEG_SQ + LEG_GAP, LEG_Y + 2.0 * LEG_ROW + LEG_SQ)
|
||||
|
||||
# ── Event handlers ────────────────────────────────────────────────────────────
|
||||
|
||||
method onScannedBot*(bot: SNNBot, e: ScannedBotEvent) =
|
||||
let bx = getX(); let by = getY()
|
||||
bot.enemyBearing = directionTo(bx, by, e.x, e.y)
|
||||
bot.enemyDist = distanceTo(bx, by, e.x, e.y)
|
||||
bot.hasContact = true
|
||||
|
||||
method onRoundStarted*(bot: SNNBot, e: RoundStartedEvent) =
|
||||
setAdjustGunForBodyTurn(true)
|
||||
setAdjustRadarForBodyTurn(true)
|
||||
setAdjustRadarForGunTurn(true)
|
||||
radar_lock.init()
|
||||
bot.hasContact = false
|
||||
bot.phase = DECIDE
|
||||
bot.tick = 0
|
||||
setTargetSpeed(0.0)
|
||||
setTurnRate(0.0)
|
||||
|
||||
method onGameStarted*(bot: SNNBot, e: GameStartedEventForBot) =
|
||||
initSNN(bot.snn)
|
||||
|
||||
# ── Main loop ─────────────────────────────────────────────────────────────────
|
||||
|
||||
method run*(bot: SNNBot) =
|
||||
while isRunning():
|
||||
inc bot.tick
|
||||
setTargetSpeed(0.0)
|
||||
setTurnRate(0.0)
|
||||
|
||||
if not bot.hasContact:
|
||||
setRadarTurnRate(45.0)
|
||||
go()
|
||||
continue
|
||||
|
||||
let myX = getX()
|
||||
let myY = getY()
|
||||
let gunDir = getGunDirection()
|
||||
|
||||
case bot.phase
|
||||
of DECIDE:
|
||||
let relBearing = normalizeRelativeAngle(bot.enemyBearing - gunDir)
|
||||
let inputs = encodeInput(relBearing)
|
||||
bot.targetAngle = bot.snn.forward(inputs)
|
||||
bot.phase = WAITING
|
||||
|
||||
of WAITING:
|
||||
aimTo(bot.targetAngle, gunDir)
|
||||
let err = abs(normalizeRelativeAngle(bot.targetAngle - gunDir))
|
||||
if err < AIM_TOL:
|
||||
bot.phase = EVALUATE
|
||||
|
||||
of EVALUATE:
|
||||
let err = abs(normalizeRelativeAngle(gunDir - bot.enemyBearing))
|
||||
let reward = 1.0 / (1.0 + err)
|
||||
echo "tick=" & $bot.tick & " error=" & $err & "° reward=" & $reward
|
||||
bot.phase = DECIDE
|
||||
|
||||
# Radar lock
|
||||
setRadarTurnRate(radar_lock.doRadar(getRadarDirection(), bot.enemyBearing))
|
||||
|
||||
# Debug overlay
|
||||
drawOverlay(bot, myX, myY, gunDir, bot.enemyBearing, bot.targetAngle)
|
||||
|
||||
go()
|
||||
|
||||
# ── Entry point ───────────────────────────────────────────────────────────────
|
||||
|
||||
when isMainModule:
|
||||
var bot = SNNBot(phase: DECIDE)
|
||||
start(bot, botJsonPath)
|
||||
Reference in New Issue
Block a user