From 22aefbddb635e54d4cfa0b00f4bee1ccc2d97bd0 Mon Sep 17 00:00:00 2001
From: Davide Cappellini <signorsasso@gmail.com>
Date: Thu, 17 Sep 2026 23:49:59 +0200
Subject: [PATCH] =?UTF-8?q?feat(BNNBot):=20Hebbian=20weight=20matrix=20wit?=
 =?UTF-8?q?h=20virtual=20bullet=20learning=20=E2=80=94=20870=E2=86=927=20b?=
 =?UTF-8?q?it=20forward=20pass?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 BNNBot_garage/src/BNNBot.nim          | 99 ++++++++++++++++++++++-----
 BNNBot_garage/src/binary_encoding.nim | 27 ++++++++
 BNNBot_garage/src/hebbian.nim         | 51 ++++++++++++++
 3 files changed, 159 insertions(+), 18 deletions(-)
 create mode 100644 BNNBot_garage/src/hebbian.nim

diff --git a/BNNBot_garage/src/BNNBot.nim b/BNNBot_garage/src/BNNBot.nim
index 2c21e3f..6c82d99 100644
--- a/BNNBot_garage/src/BNNBot.nim
+++ b/BNNBot_garage/src/BNNBot.nim
@@ -1,14 +1,22 @@
-# BNNBot — binary encoding data collector.
-# Radar lock on enemy, encodes a 10-tick sliding window (870 bits), prints it.
-# No aiming, no firing — pure scan visualization for BNN research.
+# BNNBot — Hebbian weight matrix with virtual bullet learning.
+# 870-bit input → 7-bit aim angle output via forward pass.
+# Learns from virtual bullets (no real firing) via three-factor Hebbian rule.
 
-import std/[math, os, strutils]
+import std/[math, os, strutils, random]
 import robocode_tankroyale_botapi
 import radar_lock/radar_lock as radar_lock
 import binary_encoding
+import hebbian
 
 const botJsonPath = currentSourcePath().parentDir / "BNNBot.json"
 
+const
+  BULLET_SLOTS  = 50
+  BULLET_SPEED  = 14.0  # power 2
+  EPSILON_START = 0.2
+  EPSILON_MIN   = 0.05
+  EPSILON_DECAY = 0.9995
+
 type
   BNNBot = ref object of Bot
     hasContact:   bool
@@ -24,6 +32,12 @@ type
     hasPrev:      bool
     frameBuffer:  array[WINDOW_SIZE, array[FRAME_BITS, uint8]]
     bufferCount:  int
+    net:          HebbianNet
+    bullets:      array[BULLET_SLOTS, VirtualBullet]
+    bulletHead:   int   # ring-buffer write index
+    virtualHits:  int
+    virtualMiss:  int
+    epsilon:      float
 
 method onScannedBot*(bot: BNNBot, e: ScannedBotEvent) =
   let bx = getX(); let by = getY()
@@ -36,25 +50,22 @@ method onScannedBot*(bot: BNNBot, e: ScannedBotEvent) =
   bot.hasLastPos   = true
   bot.hasContact   = true
 
-  let arenaW  = getArenaWidth().float
-  let arenaH  = getArenaHeight().float
-  let enemyX  = e.x
-  let enemyY  = e.y
+  let arenaW = getArenaWidth().float
+  let arenaH = getArenaHeight().float
 
   let frame = EnemyScanFrame(
     bearing:     bot.enemyBearing,
     distance:    bot.distance,
     velocity:    bot.velocity,
     heading:     bot.heading,
-    enemyWallN:  arenaH - enemyY,
-    enemyWallS:  enemyY,
-    enemyWallE:  arenaW - enemyX,
-    enemyWallW:  enemyX,
+    enemyWallN:  arenaH - e.y,
+    enemyWallS:  e.y,
+    enemyWallE:  arenaW - e.x,
+    enemyWallW:  e.x,
     enemyEnergy: e.energy,
   )
   let encoded = encodeFrame(frame)
 
-  # Shift buffer: 0..8 → 1..9, newest at index 0
   for i in countdown(WINDOW_SIZE - 1, 1):
     bot.frameBuffer[i] = bot.frameBuffer[i - 1]
   bot.frameBuffer[0] = encoded
@@ -62,7 +73,7 @@ method onScannedBot*(bot: BNNBot, e: ScannedBotEvent) =
   if bot.bufferCount < WINDOW_SIZE:
     inc bot.bufferCount
   if bot.bufferCount < WINDOW_SIZE:
-    return  # still filling
+    return
 
   let selfState = SelfState(
     myWallN:  arenaH - by,
@@ -75,10 +86,59 @@ method onScannedBot*(bot: BNNBot, e: ScannedBotEvent) =
   let selfEncoded = encodeSelf(selfState)
   let vec = encodeFullVector(bot.frameBuffer, selfEncoded)
 
+  # ── age & settle existing virtual bullets ────────────────────────────
+  for idx in 0..<BULLET_SLOTS:
+    var b = addr bot.bullets[idx]
+    if not b.active: continue
+    inc b.trace.age
+
+    let bulletDist = b.bulletSpeed * float(b.trace.age)
+    if bulletDist >= b.fireDist or b.trace.age >= TRACE_MAX_AGE:
+      let bulletX   = b.fireX + sin(degToRad(b.aimAngleDeg)) * bulletDist
+      let bulletY   = b.fireY + cos(degToRad(b.aimAngleDeg)) * bulletDist
+      let enemyDist = hypot(bulletX - bot.lastEnemyX, bulletY - bot.lastEnemyY)
+      if enemyDist < 36.0:
+        bot.net.learn(b.trace, HIT_REWARD)
+        inc bot.virtualHits
+      else:
+        bot.net.learn(b.trace, MISS_PENALTY)
+        inc bot.virtualMiss
+      b.active = false
+
+  # ── forward pass → aim angle ─────────────────────────────────────────
+  var outVec = bot.net.forward(vec)
+
+  # epsilon-greedy exploration
+  if rand(1.0) < bot.epsilon:
+    for j in 0..<OUTPUT_BITS:
+      if rand(1.0) < 0.5:
+        outVec[j] = 1'u8 - outVec[j]  # flip bit
+  bot.epsilon = max(EPSILON_MIN, bot.epsilon * EPSILON_DECAY)
+
+  let aimOffset = decodeOutput(outVec)
+
+  # ── store virtual bullet ──────────────────────────────────────────────
+  let slot = bot.bulletHead mod BULLET_SLOTS
+  bot.bulletHead = slot + 1
+  bot.bullets[slot] = VirtualBullet(
+    trace:       EligibilityTrace(input: vec, output: outVec, age: 0, alive: true),
+    fireX:       bx,
+    fireY:       by,
+    aimAngleDeg: bot.enemyBearing + aimOffset,
+    fireDist:    bot.distance,
+    bulletSpeed: BULLET_SPEED,
+    active:      true,
+  )
+
+  # ── stats & echo ─────────────────────────────────────────────────────
   let hamming    = if bot.hasPrev: hammingDistance(bot.prevVec, vec) else: 0
   let similarity = if bot.hasPrev: TOTAL_BITS - hamming else: 0
   let overlap    = if bot.hasPrev: popcount(bitwiseAnd(bot.prevVec, vec)) else: 0
-  echo align($bot.tick, 4), " ", formatBinary(vec), " ", hamming, " ", similarity, " ", overlap
+  echo align($bot.tick, 4), " ", formatBinary(vec), " ",
+       hamming, " ", similarity, " ", overlap, " ",
+       formatFloat(aimOffset, ffDecimal, 2), " ",
+       bot.virtualHits, " ", bot.virtualMiss
+
   bot.prevVec = vec
   bot.hasPrev = true
 
@@ -92,8 +152,7 @@ method onRoundStarted*(bot: BNNBot, e: RoundStartedEvent) =
   bot.tick        = 0
   bot.hasPrev     = false
   bot.bufferCount = 0
-  setTargetSpeed(0.0)
-  setTurnRate(0.0)
+  # net and epsilon persist across rounds (learning carries over)
 
 method onGameStarted*(bot: BNNBot, e: GameStartedEventForBot) =
   discard
@@ -113,5 +172,9 @@ method run*(bot: BNNBot) =
     go()
 
 when isMainModule:
-  var bot = BNNBot()
+  randomize()
+  var bot = BNNBot(
+    net:     initHebbianNet(),
+    epsilon: EPSILON_START,
+  )
   start(bot, botJsonPath)
diff --git a/BNNBot_garage/src/binary_encoding.nim b/BNNBot_garage/src/binary_encoding.nim
index f46c619..fb10d33 100644
--- a/BNNBot_garage/src/binary_encoding.nim
+++ b/BNNBot_garage/src/binary_encoding.nim
@@ -136,3 +136,30 @@ proc hammingDistance*(a, b: BinaryVector): int =
 proc bitwiseAnd*(a, b: BinaryVector): BinaryVector =
   for i in 0..<TOTAL_BITS:
     result[i] = a[i] and b[i]
+
+# Output encoding -------------------------------------------------------
+
+const
+  OUTPUT_BITS* = 7
+  AIM_MIN*     = -60.0
+  AIM_MAX*     =  60.0
+
+type OutputVector* = array[OUTPUT_BITS, uint8]
+
+proc encodeOutput*(angle: float): OutputVector =
+  let clamped = clamp(angle, AIM_MIN, AIM_MAX)
+  let intVal  = int((clamped - AIM_MIN) / (AIM_MAX - AIM_MIN) * 127.0)
+  let gray    = toGray(intVal)
+  for i in 0..<OUTPUT_BITS:
+    result[OUTPUT_BITS - 1 - i] = uint8((gray shr i) and 1)
+
+proc decodeOutput*(vec: OutputVector): float =
+  var val = 0
+  for i in 0..<OUTPUT_BITS:
+    val = (val shl 1) or int(vec[i])
+  var binary = val
+  var mask   = binary shr 1
+  while mask > 0:
+    binary = binary xor mask
+    mask   = mask shr 1
+  result = AIM_MIN + (float(binary) / 127.0) * (AIM_MAX - AIM_MIN)
diff --git a/BNNBot_garage/src/hebbian.nim b/BNNBot_garage/src/hebbian.nim
new file mode 100644
index 0000000..e6d4d01
--- /dev/null
+++ b/BNNBot_garage/src/hebbian.nim
@@ -0,0 +1,51 @@
+import binary_encoding
+import std/math
+
+const
+  N_IN*  = TOTAL_BITS   # 870
+  N_OUT* = OUTPUT_BITS  # 7
+
+  TRACE_MAX_AGE* = 40
+  LEARNING_RATE* = 0.1
+  MISS_PENALTY*  = -0.03
+  HIT_REWARD*    = 0.1
+  W_CLAMP*       = 5.0
+
+type
+  HebbianNet* = object
+    W*: array[N_IN * N_OUT, float]
+
+  EligibilityTrace* = object
+    input*:  BinaryVector
+    output*: OutputVector
+    age*:    int
+    alive*:  bool
+
+  VirtualBullet* = object
+    trace*:       EligibilityTrace
+    fireX*:       float
+    fireY*:       float
+    aimAngleDeg*: float
+    fireDist*:    float
+    bulletSpeed*: float
+    active*:      bool
+
+proc initHebbianNet*(): HebbianNet =
+  discard  # zero-init by default
+
+proc forward*(net: HebbianNet, input: BinaryVector): OutputVector =
+  for j in 0..<N_OUT:
+    var score = 0.0
+    for i in 0..<N_IN:
+      if input[i] == 1:
+        score += net.W[i * N_OUT + j]
+    result[j] = if score > 0.0: 1'u8 else: 0'u8
+
+proc learn*(net: var HebbianNet, trace: EligibilityTrace, reward: float) =
+  let decayedReward = reward * pow(0.95, float(trace.age))
+  for i in 0..<N_IN:
+    if trace.input[i] == 1:
+      for j in 0..<N_OUT:
+        if trace.output[j] == 1:
+          net.W[i * N_OUT + j] += LEARNING_RATE * decayedReward
+          net.W[i * N_OUT + j]  = clamp(net.W[i * N_OUT + j], -W_CLAMP, W_CLAMP)