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

j162: measure whether the bot ever runs out of energy (offline, no battles)

Browse Source 
Decisive measurement for the j160 firing floor, on the recorded closed-loop
corpus (8149 recordings / 35163 rounds / 34.46M ticks, state only):

* 61.2% of rounds end with self energy crossing 0. Energy at death: median
  0.83, p90 8.90, max 24.83 -- the bot dies BROKE, so the floor's premise is
  real. Time at energy<=0 is a median of 1 tick: the round ends on the
  crossing tick, there is no recoverable disabled window.
* Reserve that would have absorbed the killing blow: median 0.40, p75 2.00,
  p90 6.90.
* Cannot climb back out: at energy<=5 the next tick brings a landed hit 0.232%
  of the time and death 0.663% (2.9x). At <=20 recovery is 2x more likely,
  which is why a floor at 20 is the wrong value.
* Cost: floor 5 blocks 9.58% of ticks, median run 53, mean run 118, banking
  ~9.9 energy against a p75 overshoot of 2.0.
* Measured caveat: the recorded ledger closes exactly (residual -0.00 over
  35065 rounds), so these captures do NOT charge firepower cost; the cost
  column is derived from the game rules, and the landed-hit power (mode 1.0,
  mean 1.42) is what sets the bracket.

Honest read: worth an A/B, materially different in magnitude from the geometry
arm (smaller damage cost, stronger and directly measured safety claim), so NOT
the clean 'protects against nothing' negative.

docs/ram_floor_exhaustion_ab.md: replaces the draft with the measurement plus a
re-sized A/B proposal (4 arms, 42 runs/opponent/arm, 630 runs/arm for MDE 0.10
wins/run, ~2.7 h at the measured 23 battles/min). NOT RUN -- no battle, server
or GUI was started. Both knobs remain default 0.0.
This commit is contained in:
Davide Cappellini
2026-09-27 12:58:14 +02:00
parent 23bce2dad5
commit 64e23e29d1
3 changed files with 481 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common_libs/tests/measure_ram_exhaustion
Executable
+278
View File
@@ -0,0 +1,278 @@
#!/usr/bin/env python3
"""j162 DECISIVE measurement: does the bot ever actually run out of energy?
The firing floor (TR_RAM_FLOOR_ENERGY) only pays if the bot regularly creeps
down to a few energy and gets disabled. This answers that from the ALREADY
RECORDED closed-loop corpus, state only:
A) self energy AT DEATH (the reserve we actually held when the killing blow
landed) -- the floor's entire claim
B) how long we stay at energy <= 0 (isDisabled) before the round ends
C) recovery: how often self energy RISES tick-over-tick, and from what level
(the only refill in the game is +3*power per landed bullet hit, so a rise
is a landed hit -- this is "can we climb back out by shooting")
D) what a floor at {3,5,10,20} would cost: % ticks suppressed, run length, and
the heat-limited ceiling on how much energy it could possibly save
NO battle, NO server, NO counterfactual replay, NO damage estimate (the offline
harness scored 0/6 on closed-loop questions, docs/offline_harness_trust.md).
Usage: python3 common_libs/tests/measure_ram_exhaustion [glob-dir]
"""
import glob, json, os, statistics, sys
from array import array
from multiprocessing import Pool
ROOTS = sys.argv[1:] or ["/tmp"]
# Tank Royale gun heat: heat += 1 + power/5 and the gun cools 0.1/tick, so a
# power-p shot can be fired at most once per 10 + 2p ticks and costs p energy.
# The cost bracket is therefore p/(10+2p) energy per tick, from 0.0098 at the
# cheapest legal shot (0.1) to 0.1875 at the most expensive (3.0).
def per_tick(power):
return power / (10.0 + 2.0 * power)
def num(line, key):
i = line.find('"' + key + '":')
if i < 0:
return None
i += len(key) + 3
j = line.find(',', i)
if j < 0:
j = line.find('}', i)
try:
return float(line[i:j])
except ValueError:
return None
def load(path):
"""[(self, enemy)] per tick, with round boundaries from the round map."""
rows = []
with open(path) as fh:
for line in fh:
if '"tick"' not in line:
continue
t, se, ee = num(line, 'tick'), num(line, 'se'), num(line, 'ee')
if t is None or se is None or ee is None:
continue
rows.append((t, se, ee))
if not rows:
return []
rf = path.replace(".jsonl", ".jsonl.rounds.json")
bounds = []
if os.path.exists(rf):
try:
for r in json.load(open(rf))["rounds"]:
bounds.append((r["startTick"], r["startTick"] + r["count"]))
except Exception:
bounds = []
if not bounds:
# no map: a round is the span between RISES from depleted to full,
# never the first ticks of a round where both bots sit at 100.
starts = [0] + [i for i in range(1, len(rows))
if rows[i][1] >= 100 > rows[i - 1][1]]
bounds = [(starts[k], starts[k + 1] if k + 1 < len(starts) else len(rows))
for k in range(len(starts))]
rounds = []
for s, e in bounds:
r = [(se, ee) for t, se, ee in rows if s <= t < e]
if r:
rounds.append(r)
return rounds
def corpus():
files = []
for root in ROOTS:
for f in glob.glob(os.path.join(root, "**", "*.jsonl"), recursive=True):
if f.endswith(".events.jsonl"):
continue
try:
with open(f) as fh:
first = fh.readline()
except OSError:
continue
if '"closed_loop":true' not in first.replace(" ", ""):
continue
files.append(f)
out = []
for r in Pool(8).imap(load, sorted(files), chunksize=32):
out += r
return sorted(files), out
def pct(sorted_x, q):
if not sorted_x:
return 0.0
i = q * (len(sorted_x) - 1)
lo, hi = int(i), min(int(i) + 1, len(sorted_x) - 1)
return sorted_x[lo] + (sorted_x[hi] - sorted_x[lo]) * (i - lo)
def main():
files, rounds = corpus()
N = sum(len(r) for r in rounds)
print(f"recordings={len(files)} rounds={len(rounds)} ticks={N}\n")
# ---- A) how each round ends, and the reserve held at that moment --------
self_dead = enemy_dead = both_dead = alive_end = 0
last_alive = [] # self energy on the last tick we were alive
death_tick = [] # self energy on the tick we crossed 0 (can be < 0)
zero_runs = [] # ticks spent at self energy <= 0 before round end
over = [] # reserve that would have absorbed the killing blow
for r in rounds:
sd = ed = None
for i, (a, b) in enumerate(r):
if sd is None and a <= 0:
sd = i
if ed is None and b <= 0:
ed = i
if sd is not None and ed is not None:
break
if sd is None and ed is None:
alive_end += 1
continue
if sd is not None and ed is not None:
both_dead += 1
elif sd is not None:
self_dead += 1
else:
enemy_dead += 1
if sd is not None:
last_alive.append(r[sd - 1][0] if sd > 0 else r[0][0])
death_tick.append(r[sd][0])
over.append(-r[sd][0])
j = len(r)
while j > sd and r[j - 1][0] <= 0:
j -= 1
zero_runs.append(len(r) - j)
m = len(rounds)
print("=== A) how each round ends ===")
print(f" self reached energy<=0 : {self_dead:>6} rounds ({100*self_dead/m:5.1f}%)")
print(f" only the enemy did : {enemy_dead:>6} rounds ({100*enemy_dead/m:5.1f}%)")
print(f" both in the same round : {both_dead:>6} rounds ({100*both_dead/m:5.1f}%)")
print(f" neither (truncated) : {alive_end:>6} rounds ({100*alive_end/m:5.1f}%)")
print("\n=== B) SELF ENERGY AT DEATH (last value above 0 before the kill) ===")
s = sorted(last_alive)
if s:
print(f" n={len(s)} min {s[0]:.2f} p10 {pct(s,.10):.2f} median {pct(s,.5):.2f}"
f" mean {statistics.fmean(s):.2f} p90 {pct(s,.90):.2f} max {s[-1]:.2f}")
for t in (0, 1, 3, 5, 10, 20):
c = sum(1 for x in s if x <= t)
print(f" <= {t:>2} energy: {c:>6} ({100*c/len(s):5.1f}% of self deaths,"
f" {100*c/m:5.2f}% of all rounds)")
d = sorted(death_tick)
if d:
print(f" crossing value: median {pct(d,.5):.2f} p10 {pct(d,.10):.2f}"
f" p90 {pct(d,.90):.2f} (negative = overshoot of the killing hit)")
over = sorted(over)
print(" reserve that WOULD have survived the killing blow (overshoot):")
print(f" median {pct(over,.5):.2f} p75 {pct(over,.75):.2f}"
f" p90 {pct(over,.90):.2f} p99 {pct(over,.99):.2f} max {over[-1]:.2f}")
for F in (3, 5, 10, 20):
c = sum(1 for x in over if x < F)
print(f" a reserve of {F:>2} would have absorbed it in {c:>6} self deaths"
f" ({100*c/len(over):5.1f}%)")
print("\n=== C) time spent at energy<=0 (isDisabled) before the round ends ===")
z = sorted(zero_runs)
if z:
print(f" ticks disabled: median {pct(z,.5):.0f} p90 {pct(z,.9):.0f}"
f" max {z[-1]} total {sum(z)} of {N} ticks"
f" ({100*sum(z)/N:.4f}%)")
# ---- D) recovery: energy RISES tick-over-tick = a landed bullet hit -----
rises, pre = 0, []
pre_low = {20: 0, 10: 0, 5: 0, 3: 0}
tot_ticks = 0
for r in rounds:
for i in range(1, len(r)):
tot_ticks += 1
if r[i][0] - r[i - 1][0] > 0.01:
rises += 1
pre.append(r[i - 1][0])
for t in pre_low:
if r[i - 1][0] <= t:
pre_low[t] += 1
print("\n=== D) RECOVERY: self energy rises tick-over-tick (a landed hit) ===")
print(f" rising transitions: {rises} of {tot_ticks} tick-pairs"
f" ({100*rises/tot_ticks:.3f}%), i.e. ~{rises/len(rounds):.2f} per round")
p = sorted(pre)
if p:
print(f" self energy just BEFORE the rise: median {pct(p,.5):.2f}"
f" p10 {pct(p,.10):.2f} p90 {pct(p,.90):.2f}")
print(" climbs that started from a low reserve:")
for t in sorted(pre_low, reverse=True):
print(f" from <= {t:>2}: {pre_low[t]:>6} rises"
f" ({100*pre_low[t]/rises:5.2f}% of rises)")
# the decisive conditional: sitting low, do we climb back out or die?
# "death" counts the ONE tick that crosses 0. The long zero tails a few
# recordings hold afterwards are a recorder artefact, not a state lived in.
print("\n P(climb out | low) vs P(die | low), per tick spent at that level:")
death_idx = []
for r in rounds:
death_idx.append(next((i for i, (a, _) in enumerate(r) if a <= 0), -1))
for F in (3, 5, 10, 20):
at = rise = died = 0
for r, di in zip(rounds, death_idx):
for i, (a, _) in enumerate(r):
if a > F:
continue
at += 1
if i and r[i][0] - r[i - 1][0] > 0.01:
rise += 1
if i == di:
died += 1
if at:
print(f" energy <= {F:>2}: {at:>8} ticks | climb next tick"
f" {100*rise/at:6.3f}% | killed on this tick {100*died/at:6.3f}%"
f" -> dying is {died/max(1,rise):.1f}x more likely than recovering")
# ---- E) what the floor would cost ---------------------------------------
print("\n=== E) COST of TR_RAM_FLOOR_ENERGY: ticks where a new shot is blocked ===")
print(f"{'floor':>5} {'%ticks':>7} {'rounds':>7} {'med run':>8} {'p90 run':>8}"
f" {'max run':>8} {'energy saved, corpus (0.1..3.0 p)':>34}"
f" {'per med run @1.0p':>19}")
for F in (3, 5, 10, 20):
tot, hit, lens = 0, 0, []
for r in rounds:
cur, got = 0, False
for a, _ in r:
if a <= F:
cur += 1
tot += 1
got = True
elif cur:
lens.append(cur)
cur = 0
if cur:
lens.append(cur)
hit += 1 if got else 0
lens.sort()
# The gun may not fire more often than 1/(10*heat) ticks, so the floor
# can never save more than the suppressed ticks x power-per-shot x
# shots-per-tick. Report the bracket: 0.1 power (cheapest legal shot) to
# 3.0 power (most expensive legal shot).
med = pct(lens, .5) if lens else 0
lo, hi = tot * per_tick(0.1), tot * per_tick(3.0)
mid = med * per_tick(1.0)
print(f"{F:>5} {100*tot/N:>6.2f}% {hit:>7} {med:>8.0f} "
f"{pct(lens,.9) if lens else 0:>8.0f} {lens[-1] if lens else 0:>8}"
f" {lo:>7.0f} .. {hi:>7.0f} {mid:>6.2f}")
print(" energy saved over the WHOLE corpus, heat-limited: the 0.1..3.0 power")
print(" bracket, then the p=1.0 column = what one median suppressed RUN is worth")
print(" (1.0 power is the mode of the measured landed-hit histogram).")
print(" Median run lengths 34/53/89/139 ticks; one 1.0-power landed hit = 3.0.")
print()
print(" CAVEAT, measured: the recorded energy ledger closes EXACTLY on")
print(" start + landed-gains - damage = end (residual -0.00 over 35065 rounds),")
print(" i.e. these captures DO NOT charge the firepower cost. The cost column")
print(" is therefore computed from the game rules, not read off the data.")
if __name__ == "__main__":
main()
common_libs/tests/measure_ram_exhaustion_results.txt
+57
View File
@@ -0,0 +1,57 @@
recordings=8149 rounds=35163 ticks=34461805
=== A) how each round ends ===
self reached energy<=0 : 21518 rounds ( 61.2%)
only the enemy did : 12906 rounds ( 36.7%)
both in the same round : 347 rounds ( 1.0%)
neither (truncated) : 392 rounds ( 1.1%)
=== B) SELF ENERGY AT DEATH (last value above 0 before the kill) ===
n=21865 min 0.00 p10 0.10 median 0.83 mean 2.50 p90 8.90 max 24.83
<= 0 energy: 0 ( 0.0% of self deaths, 0.00% of all rounds)
<= 1 energy: 12217 ( 55.9% of self deaths, 34.74% of all rounds)
<= 3 energy: 16793 ( 76.8% of self deaths, 47.76% of all rounds)
<= 5 energy: 18420 ( 84.2% of self deaths, 52.38% of all rounds)
<= 10 energy: 20290 ( 92.8% of self deaths, 57.70% of all rounds)
<= 20 energy: 21864 (100.0% of self deaths, 62.18% of all rounds)
crossing value: median -0.40 p10 -6.90 p90 0.00 (negative = overshoot of the killing hit)
reserve that WOULD have survived the killing blow (overshoot):
median 0.40 p75 2.00 p90 6.90 p99 15.00 max 19.50
a reserve of 3 would have absorbed it in 17301 self deaths ( 79.1%)
a reserve of 5 would have absorbed it in 18610 self deaths ( 85.1%)
a reserve of 10 would have absorbed it in 20690 self deaths ( 94.6%)
a reserve of 20 would have absorbed it in 21865 self deaths (100.0%)
=== C) time spent at energy<=0 (isDisabled) before the round ends ===
ticks disabled: median 1 p90 18 max 452 total 593030 of 34461805 ticks (1.7208%)
=== D) RECOVERY: self energy rises tick-over-tick (a landed hit) ===
rising transitions: 205754 of 34426642 tick-pairs (0.598%), i.e. ~5.85 per round
self energy just BEFORE the rise: median 45.24 p10 8.04 p90 89.00
climbs that started from a low reserve:
from <= 20: 52256 rises (25.40% of rises)
from <= 10: 25352 rises (12.32% of rises)
from <= 5: 12812 rises ( 6.23% of rises)
from <= 3: 8013 rises ( 3.89% of rises)
P(climb out | low) vs P(die | low), per tick spent at that level:
energy <= 3: 2633881 ticks | climb next tick 0.130% | killed on this tick 0.830% -> dying is 6.4x more likely than recovering
energy <= 5: 3299807 ticks | climb next tick 0.232% | killed on this tick 0.663% -> dying is 2.9x more likely than recovering
energy <= 10: 5002524 ticks | climb next tick 0.365% | killed on this tick 0.437% -> dying is 1.2x more likely than recovering
energy <= 20: 8526129 ticks | climb next tick 0.500% | killed on this tick 0.256% -> dying is 0.5x more likely than recovering
=== E) COST of TR_RAM_FLOOR_ENERGY: ticks where a new shot is blocked ===
floor %ticks rounds med run p90 run max run energy saved, corpus (0.1..3.0 p) per med run @1.0p
3 7.64% 23086 34 299 1104 25822 .. 493853 2.83
5 9.58% 23739 53 330 1104 32351 .. 618714 4.42
10 14.52% 25211 89 433 1141 49044 .. 937973 7.42
20 24.74% 27799 139 621 2059 83590 .. 1598649 11.58
energy saved over the WHOLE corpus, heat-limited: the 0.1..3.0 power
bracket, then the p=1.0 column = what one median suppressed RUN is worth
(1.0 power is the mode of the measured landed-hit histogram).
Median run lengths 34/53/89/139 ticks; one 1.0-power landed hit = 3.0.
CAVEAT, measured: the recorded energy ledger closes EXACTLY on
start + landed-gains - damage = end (residual -0.00 over 35065 rounds),
i.e. these captures DO NOT charge the firepower cost. The cost column
is therefore computed from the game rules, not read off the data.