KI nutzen
Modelle herunterladen
Alle von BonkTools trainierten Modelle (Fußball und Mbappa; Stürmer, Verteidiger und Torwart), die Dateiformate und die Testfälle zum Prüfen deiner Implementierung.
Downloads
Fußball
| Modell | Datei | Testfälle | Status |
|---|---|---|---|
| Stürmer / 1v1 (182 Millionen Schritte, Beobachtung v2) | football-1x1.policy.json | Fälle | Das Modell aus den 1v1-Räumen und der Stürmer im 2v2-Raum |
| Torwart (22,4 Millionen Schritte, Beobachtung „gk1“) | football-goleiro.policy.json | Fälle | Experimentell: Im Simulator kassiert er weniger Tore als unser regelbasierter Torwart (8,2 % gegenüber 11,5 % der Spielzüge), kam aber nie in den Raum (dort spielte der regelbasierte Torwart) |
Mbappa (Karte „Mbappa Clean“, klassische Engine)
| Modell | Datei | Testfälle | Status |
|---|---|---|---|
| Stürmer (53,6 Millionen Schritte, Beobachtung v3) | mbappa-atacante.policy.json | Fälle | Das Modell aus dem Mbappa-1v1-Raum und der Stürmer im 2v2 |
| Torwart (200 Tausend Schritte, Beobachtung v3) | mbappa-goleiro.policy.json | Fälle | Experimentell: Netz für den Torwart des 2v2-Raums. Blieb im Test und kam nicht in den Raum (dort nutzte der Torwart das Netz des Stürmers + Sicherheitsregeln) |
| Verteidiger (4,5 Millionen Schritte, Beobachtung v1) | mbappa-defensor.policy.json | Fälle | Experimentell: Spezialist, nur auf Abwehrsituationen trainiert, um im Duo mit dem Stürmer zu spielen. Hat das Duo nicht verbessert und blieb nicht im Raum |
Schnell loslegen
| Datei | Was es ist |
|---|---|
| sala-exemplo.zip | Fertiger Raum mit dem Modus „Fordere die KI heraus“ (MODO=ia) mit dem Fußball-Stürmer; enthält auch den Code der anderen Modelle (src/ia/) |
| ia-kit.zip | Python-Trainingskit, um dein eigenes zu trainieren |
Lizenz: MIT. Nutzen, ändern und weitergeben erlaubt; behalte nur den Lizenzhinweis bei und gib dich nicht als mit bonk.io verbunden aus.
Fußball: Stürmer / 1v1
Das Format policy.json
{
"format": "bonktools-rl-policy/1",
"obsSize": 39,
"obsVersion": 2,
"actionTable": [0, 4, 6, 2, 10, 8, 9, 1, 5, 16, 20, 22, 18, 26, 24, 25, 17, 21],
"activation": "tanh",
"layers": [
{ "in": 39, "out": 256, "w": "<base64>", "b": "<base64>" },
{ "in": 256, "out": 256, "w": "<base64>", "b": "<base64>" },
{ "in": 256, "out": 18, "w": "<base64>", "b": "<base64>" }
],
"timesteps": 182053103,
"exportedAt": "2026-09-29T16:48:34Z"
}| Feld | Bedeutung |
|---|---|
obsSize, obsVersion | Wie viele Zahlen das Netz erwartet (39 = Beobachtungsversion 2) |
actionTable | Die 18 Aktionen als bonk.io-Tasten: links 1, rechts 2, hoch 4, runter 8, Schuss 16 |
layers | Die Schichten: w sind die Gewichte (out × in, Zeile für Zeile) und b der Bias, als Little-Endian-float32, Base64-kodiert |
activation | tanh in den verborgenen Schichten; die letzte ist linear (sie liefert 18 „Noten“, die Logits) |
Für jede Schicht: y = W·x + b, und tanh(y), wenn es nicht die letzte ist. Die 18 Endnoten sagen, wie sehr die KI jede Aktion „will“.
Testfälle
{
"state": { "ball": {...}, "discs": [null, {...}, {...}], "ftu": 37 },
"selfId": 1, "oppId": 2, "mirror": false,
"obs": [0.12, -0.4, ...], // die 39 erwarteten Zahlen
"logits": [1.23, -0.5, ...], // die 18 erwarteten Noten
"prev": 5, // vorherige Entscheidung (oder null)
"decided": 3, // die Achse für Achse entschiedene Aktion
"bits": 2 // die zu drückenden Tasten (bei mirror schon gespiegelt)
}Bau die Beobachtung aus state, führ das Netz aus, entscheide mit prev und vergleiche. Die Beobachtung muss exakt übereinstimmen (die Werte werden vor der ±2-Grenze auf float32 gerundet); die Noten bis zur 4. Nachkommastelle.
Als Stürmer im 2v2
Dasselbe Modell spielte im 2v2-Raum als Stürmer (die KI neben einem Torwart). Es sieht das Spiel als 1v1: Bei jeder Entscheidung ist der „Gegner“ der Mensch, der dem Ball am nächsten ist. Mit dem Ball in der eigenen Hälfte hielt eine einfache Regel den Stürmer vorne, ohne dem Torwart den Ball streitig zu machen.
Fußball: Torwart
Gleiches Format (bonktools-rl-policy/1) und gleiche Entscheidung Achse für Achse, aber mit einer anderen Beobachtung: „gk1“ (obsVersion 101, 27 Zahlen), auf der Achse des Torwarts (das eigene Tor ist links). Sie enthält den Torwart, den Ball, die beiden Gegner, die dem Ball am nächsten sind, den Mitspieler (den Stürmer) und die Vorhersage, wo der Ball die Torlinie kreuzt.
// goleiro-rl.ts
import { teamMirror } from './features.js';
/**
* "gk1"-Beobachtung des per RL trainierten Fußball-TORWARTS (obsVersion 101, 27 Zahlen), genau wie im Training.
* Prüfe mit den Testfällen, die mit dem Modell veröffentlicht sind. Kanonische Achse des Torwarts (das EIGENE Tor ist links).
*/
export const GK_OBS_VERSION = 101;
export const GK_OBS_SIZE = 27;
const CENTER_X = 33.18;
const CENTER_Y = 22.73;
const LINE_X = 2 * CENTER_X - 64.0 + 1.6; // Torwartlinie, 1,6 vor dem eigenen Tor
const HALF_W = 33.0;
const HALF_H = 22.7;
const PLAYER_MAX_SPEED = 11.7;
const BALL_MAX_SPEED = 20.0;
interface Body { x: number; y: number; xv?: number; yv?: number; kickReady?: boolean }
export interface GkState { ball?: Body | null; discs?: Array<Body | null | undefined> | null }
export function gkObs(state: GkState, gk: number, team: number, humans: number[], bot: number | null): Float64Array {
const m = teamMirror(team);
const get = (i: number | null): Body | null => (i !== null && i >= 0 ? state.discs?.[i] ?? null : null);
const c = (b: Body | null | undefined): [number, number, number, number] =>
!b ? [CENTER_X, CENTER_Y, 0, 0] : m ? [2 * CENTER_X - b.x, b.y, -(b.xv ?? 0), b.yv ?? 0] : [b.x, b.y, b.xv ?? 0, b.yv ?? 0];
const me = get(gk);
const [sx, sy, sxv, syv] = c(me);
const [bx, by, bxv, byv] = c(state.ball);
const px = (x: number): number => (x - CENTER_X) / HALF_W;
const py = (y: number): number => (y - CENTER_Y) / HALF_H;
const o: number[] = [px(sx), py(sy), sxv / PLAYER_MAX_SPEED, syv / PLAYER_MAX_SPEED, me?.kickReady ? 1 : 0,
px(bx), py(by), bxv / BALL_MAX_SPEED, byv / BALL_MAX_SPEED,
(bx - sx) / 10, (by - sy) / 10, Math.min(Math.hypot(bx - sx, by - sy), 40) / 10];
const hs = humans.map((h) => {
const [hx, hy, hxv, hyv] = c(get(h));
return [Math.hypot(hx - bx, hy - by), hx, hy, hxv, hyv] as const;
});
hs.sort((a, b) => a[0] - b[0]);
while (hs.length < 2) hs.push([40, CENTER_X + 20, CENTER_Y, 0, 0]);
for (const [d, hx, hy, hxv, hyv] of hs.slice(0, 2)) {
o.push((hx - bx) / 10, (hy - by) / 10, hxv / PLAYER_MAX_SPEED, hyv / PLAYER_MAX_SPEED, Math.min(d, 40) / 10);
}
const [tx, ty] = c(get(bot));
o.push(px(tx), py(ty));
const cross = predictCross(bx, by, bxv, byv, Math.max(sx, LINE_X));
if (cross) o.push(1, (cross[0] - CENTER_Y) / HALF_H, Math.min(cross[1], 3) / 3);
else o.push(0, 0, 1);
return Float64Array.from(o, (v) => Math.max(-5, Math.min(5, Math.fround(v))));
}
const BALL_Y_MIN = 7.79;
const BALL_Y_MAX = 37.67;
/** Spiegelt y an den Wänden oben/unten (der Ball prallt ab). */
function reflectY(y: number): number {
const lo = BALL_Y_MIN, span = BALL_Y_MAX - BALL_Y_MIN;
const t = (((y - lo) % (2 * span)) + 2 * span) % (2 * span);
return lo + (t <= span ? t : 2 * span - t);
}
/** (y, Zeit), zu der der Ball auf dem Weg zum Tor x = xLine kreuzt; null, wenn er nicht kommt. */
export function predictCross(bx: number, by: number, bxv: number, byv: number, xLine: number): [number, number] | null {
if (bxv > -1.0 || bx <= xLine) return null;
const t = (bx - xLine) / -bxv;
return [reflectY(by + byv * t), t];
}Zum Spielen: decide(policy.logits(gkObs(zustand, torwartId, team, gegnerIds, mitspielerId)), vorherige) und actionToBits(aktion, teamMirror(team)), mit derselben policy.ts wie beim Stürmer.
Die Testfälle enthalten state, gk, team, humans (Gegner), bot (Mitspieler), obs, logits, prev, decided und bits.
Mbappa: Stürmer, Torwart und Verteidiger
Mbappa ist ein anderes Spiel: die Karte „Mbappa Clean“ auf der klassischen Engine von bonk.io (Seitenansicht, Schwerkraft, Springen, ein sehr springender Ball, Käfigtore). Das Rezept ist dasselbe (PPO, Lehrplan, Self-Play, echte Physik), aber mit anderer Beobachtung und anderen Aktionen.
Das Format bonktools-rl-mbappa/1
Wie bei Fußball, mit zwei Unterschieden:
actionsstattactionTable: 18 Tripel[horizontal, vertikal, schwer]. Horizontal: 0 nichts, 1 ←, 2 →. Vertikal: 0 nichts, 1 ↑ (springen), 2 ↓ (in der Luft schnell fallen). Schwer: X halten.- Entscheidung per Argmax (die Aktion mit der höchsten Note), einmal alle 100 ms.
| Version | Zahlen | Was sie sieht |
|---|---|---|
| v1 (der Verteidiger) | 26 | Ball, ich und der Gegner (Position, Geschwindigkeit, am Boden, schwer, lebendig) und der Ball relativ zu mir, zum Gegner und zu beiden Käfigen |
| v2 | 38 | v1 + wo der Ball landet, Ballvorhersage bei 0,3 s und 0,6 s und ein Gedächtnis (Tasten der vorherigen Entscheidung, wie lange ↑ gehalten wird, wie lange in der Luft) |
| v3 (Stürmer und Torwart) | 43 | v2 + beide X-Anzeigen, ob der Gegner schwer ist und ob der Ball auf einem der Käfige liegt |
Kanonische Achse: Der Agent greift immer nach rechts an. Bei Mbappa wird Blau gespiegelt (beim Fußball Rot).
Der Code
// mbappa.ts
import { readFileSync } from 'node:fs';
/**
* Die Mbappa-KI (Karte "Mbappa Clean", klassische bonk.io-Engine) in reinem JS: die exakte Trainingsbeobachtung
* (v1: 26 Zahlen; v2: 38, mit Ballvorhersage und Gedächtnis; v3: 43, + beide X-Anzeigen, das X des Gegners und der Ball
* auf einem der Käfige) und das Netz (tanh-MLP, Argmax). Prüfe mit den Testfällen, die mit jedem
* Modell veröffentlicht sind: eine andere Beobachtung ließe den Bot ohne jeden Fehler schlecht spielen.
*/
/** Zustand der klassischen Engine: Positionen in Spieleinheiten, y wächst nach unten. */
export interface ClassicState {
ball: { x: number; y: number; xv: number; yv: number };
/** `heavy` = X gehalten; `stamina` = X-Anzeige (0..1000: verbraucht 10/Frame beim Halten, lädt 5 nach). */
discs: Record<string, { x: number; y: number; xv: number; yv: number; team: number; heavy: boolean; stamina?: number }>;
scores: (number | null)[];
ftu: number;
}
export const MBAPPA_POLICY_FORMAT = 'bonktools-rl-mbappa/1';
const TEAM_BLUE = 3;
const MIRROR = 73.0;
const GROUND = 43.1;
const LEFT_LINE = 8.9;
const RIGHT_LINE = 64.1;
const ATTACK: [number, number] = [RIGHT_LINE + 1.5, 40.0];
const DEFEND: [number, number] = [LEFT_LINE - 1.5, 40.0];
const LEFT = 1, RIGHT = 2, UP = 4, DOWN = 8, HEAVY = 16;
const FPS = 30;
const BALL_GROUND = 43.4;
const BALL_GRAVITY = 20.0;
export const MBAPPA_OBS_SIZES: Record<number, number> = { 1: 26, 2: 38, 3: 43 };
const STAMINA_MAX = 1000;
const ROOF_X = 9.5, ROOF_Y = 34.6; // Ball auf dem Dach des linken Käfigs (kanonische Achse)
/** X-Anzeige (0..1); ohne das Feld voll (wie im Training). */
const staminaOf = (d: { stamina?: number }): number => Math.min(Math.max((typeof d.stamina === 'number' ? d.stamina : STAMINA_MAX) / STAMINA_MAX, 0), 1);
/** Spielergedächtnis (v2): Tasten des letzten Schritts, Frames mit gehaltenem ↑, Frames in der Luft. */
export interface MbappaMemory {
keys: number;
upFrames: number;
airFrames: number;
}
export const newMemory = (): MbappaMemory => ({ keys: 0, upFrames: 0, airFrames: 0 });
export function updateMemory(m: MbappaMemory, keys: number, frames: number, airborne: boolean): void {
m.keys = keys;
m.upFrames = keys & UP ? m.upFrames + frames : 0;
m.airFrames = airborne ? m.airFrames + frames : 0;
}
type Body = { x: number; y: number; xv: number; yv: number };
const predictBall = (b: Body, t: number): [number, number] => [b.x + b.xv * t, Math.min(b.y + b.yv * t + 0.5 * BALL_GRAVITY * t * t, BALL_GROUND)];
function landingTime(b: Body): number {
const dy = BALL_GROUND - b.y;
if (dy <= 0) return 0;
return (-b.yv + Math.sqrt(b.yv * b.yv + 2 * BALL_GRAVITY * dy)) / BALL_GRAVITY;
}
const canon = (x: number, xv: number, mirrored: boolean): [number, number] => (mirrored ? [MIRROR - x, -xv] : [x, xv]);
export const onGround = (d: { y: number; yv: number }): boolean => d.y >= GROUND - 0.15 && Math.abs(d.yv) < 0.5;
const clip = (v: number): number => Math.max(-5, Math.min(5, v));
/** Beobachtung aus Sicht von `me` (Team `team`), auf der kanonischen Achse (der Agent greift immer nach rechts an). */
export function buildObs(state: ClassicState, me: number, opp: number, team: number, mem: MbappaMemory | null = null, version = 1): number[] {
const mirrored = team === TEAM_BLUE;
const b = state.ball;
const [bx, bxv] = canon(b.x, b.xv, mirrored);
const by = b.y, byv = b.yv;
const d = state.discs[String(me)];
const o = state.discs[String(opp)];
const W = 36.5, H = 10.0, V = 30.0;
let mx: number, mxv: number, my: number, myv: number, mheavy: number, mground: number;
if (d) {
[mx, mxv] = canon(d.x, d.xv, mirrored);
my = d.y; myv = d.yv; mheavy = d.heavy ? 1 : 0; mground = onGround(d) ? 1 : 0;
} else {
mx = bx; mxv = 0; my = GROUND; myv = 0; mheavy = 0; mground = 1;
}
let ox: number, oxv: number, oy: number, oyv: number, oground: number, alive: number;
if (o) {
[ox, oxv] = canon(o.x, o.xv, mirrored);
oy = o.y; oyv = o.yv; oground = onGround(o) ? 1 : 0; alive = 1;
} else {
ox = MIRROR - mx; oxv = 0; oy = GROUND; oyv = 0; oground = 1; alive = 0;
}
const [ax, ay] = ATTACK;
const [dx, dy] = DEFEND;
const base = [
(bx - 36.5) / W, (by - GROUND) / H, bxv / V, byv / V,
(mx - 36.5) / W, (my - GROUND) / H, mxv / V, myv / V, mheavy, mground,
(bx - mx) / W, (by - my) / H, (bxv - mxv) / V, (byv - myv) / V,
(ox - mx) / W, (oy - my) / H, oxv / V, oyv / V, oground, alive,
(ox - bx) / W, (oy - by) / H,
(ax - bx) / W, (ay - by) / H,
(dx - bx) / W, (dy - by) / H,
];
if (version >= 2) {
const cb = { x: bx, y: by, xv: bxv, yv: byv };
const tLand = landingTime(cb);
const [lx] = predictBall(cb, tLand);
const [p3x, p3y] = predictBall(cb, 0.3);
const [p6x, p6y] = predictBall(cb, 0.6);
const m = mem ?? newMemory();
let left = !!(m.keys & LEFT), right = !!(m.keys & RIGHT);
if (mirrored) [left, right] = [right, left];
base.push(
(lx - mx) / W, Math.min(tLand, 3.0) / 1.5,
(p3x - mx) / W, (p3y - my) / H, (p6x - mx) / W, (p6y - my) / H,
(right ? 1 : 0) - (left ? 1 : 0), m.keys & UP ? 1 : 0, m.keys & DOWN ? 1 : 0, m.keys & HEAVY ? 1 : 0,
Math.min(m.upFrames / FPS, 1.0), Math.min(m.airFrames / FPS, 2.0) / 2.0,
);
}
if (version >= 3) {
base.push(
d ? staminaOf(d) : 0, o ? staminaOf(o) : 0, o && o.heavy ? 1 : 0,
bx < ROOF_X && by < ROOF_Y ? 1 : 0, bx > MIRROR - ROOF_X && by < ROOF_Y ? 1 : 0,
);
}
return base.map((v) => clip(Math.fround(v)));
}
/** Spieltasten für den Zug (kanonische Achse; gespiegelt: ← und → tauschen). */
export function keysFor(action: number, actions: readonly (readonly [number, number, boolean | number])[], mirrored: boolean): number {
const [h, v, heavy] = actions[action]!;
let k = 0;
if (h === 1) k |= mirrored ? RIGHT : LEFT;
else if (h === 2) k |= mirrored ? LEFT : RIGHT;
if (v === 1) k |= UP;
else if (v === 2) k |= DOWN;
if (heavy) k |= HEAVY;
return k;
}
interface LayerJson {
in: number;
out: number;
w: string;
b: string;
}
export interface MbappaPolicyJson {
format: string;
obsSize: number;
obsVersion?: number;
actions: [number, number, boolean][];
activation: string;
layers: LayerJson[];
timesteps?: number;
exportedAt?: string;
}
function floats(b64: string, n: number): Float32Array {
const buf = Buffer.from(b64, 'base64');
if (buf.length !== n * 4) throw new Error(`política inválida: ${buf.length / 4} valores, esperado ${n}`);
const out = new Float32Array(n);
for (let i = 0; i < n; i++) out[i] = buf.readFloatLE(i * 4);
return out;
}
export class MbappaPolicy {
readonly actions: [number, number, boolean][];
readonly timesteps: number;
readonly obsVersion: number;
private readonly layers: { in: number; out: number; w: Float32Array; b: Float32Array }[];
private mem = newMemory();
private lastKeys: number | null = null;
constructor(json: MbappaPolicyJson) {
if (json.format !== MBAPPA_POLICY_FORMAT) throw new Error(`formato de política desconhecido: ${String(json.format)}`);
if (json.activation !== 'tanh') throw new Error(`ativação não suportada: ${json.activation}`);
this.actions = json.actions;
this.timesteps = json.timesteps ?? 0;
const byOrder = Object.entries(MBAPPA_OBS_SIZES).find(([, n]) => n === json.obsSize)?.[0];
this.obsVersion = json.obsVersion ?? Number(byOrder ?? 1);
if (MBAPPA_OBS_SIZES[this.obsVersion] !== json.obsSize) throw new Error(`política com ${json.obsSize} entradas: observação desconhecida`);
this.layers = json.layers.map((l) => ({ in: l.in, out: l.out, w: floats(l.w, l.in * l.out), b: floats(l.b, l.out) }));
if (this.layers[0]?.in !== json.obsSize) throw new Error('política inválida: a primeira camada não bate com obsSize');
}
static load(path: string): MbappaPolicy {
return new MbappaPolicy(JSON.parse(readFileSync(path, 'utf8')) as MbappaPolicyJson);
}
/** Der wahrscheinlichste Zug (Argmax der Logits). */
act(obs: readonly number[]): number {
let x = Float32Array.from(obs);
this.layers.forEach((l, li) => {
const y = new Float32Array(l.out);
for (let o = 0; o < l.out; o++) {
let s = l.b[o]!;
const row = o * l.in;
for (let i = 0; i < l.in; i++) s += l.w[row + i]! * x[i]!;
y[o] = li < this.layers.length - 1 ? Math.tanh(s) : s;
}
x = y;
});
let best = 0;
for (let i = 1; i < x.length; i++) if (x[i]! > x[best]!) best = i;
return best;
}
/** Neues Spiel: setzt das Gedächtnis zurück. */
resetMemory(): void {
this.mem = newMemory();
this.lastKeys = null;
}
/**
* Die TATSÄCHLICH gesendeten Tasten in diesem Schritt, wenn der Nutzer des Netzes dessen Zug ersetzt hat (Mbappa-2v2-Raum: der
* Stürmer überlässt den Spielzug dem Torwart): das Gedächtnis des nächsten Schritts speichert, was der Spieler tat, wie im Training.
*/
noteKeys(keys: number): void {
this.lastKeys = keys;
}
/**
* Tasten für `me` (Team `team`) in diesem Zustand, aufgerufen alle `frames` Frames (100 ms = 3, der Trainingsschritt): das
* Gedächtnis speichert die Tasten der vorherigen Entscheidung und ob der Spieler gerade in der Luft ist (wie im Training).
*/
keys(state: ClassicState, me: number, opp: number, team: number, frames = 3): number {
if (this.obsVersion >= 2 && this.lastKeys !== null) {
const d = state.discs[String(me)];
updateMemory(this.mem, this.lastKeys, frames, !!d && !onGround(d));
}
const k = keysFor(this.act(buildObs(state, me, opp, team, this.mem, this.obsVersion)), this.actions, team === TEAM_BLUE);
this.lastKeys = k;
return k;
}
}Verwendung: policy.keys(zustand, ich, gegner, team) alle 3 Frames (100 ms) liefert die zu drückenden Tasten und kümmert sich selbst um das Gedächtnis. Ruf bei jedem neuen Spiel resetMemory() auf.
Mbappa-Testfälle
Jeder Fall enthält state (Format ClassicState), me, opp, team, mem ([tasten, framesMitHochGehalten, framesInDerLuft]), obs, action (das Argmax) und bits (die Tasten). Bau die Beobachtung mit buildObs(state, me, opp, team, {keys, upFrames, airFrames}, version), führ act() aus und vergleiche.