KI nutzen
Die KI in deinen Raum bringen
Lass das Raumkonto mit der KI spielen: Beobachtung, Netz, Entscheidung ohne Zickzack, die „Augen“ ohne Verzögerung und ein kompletter Raum „Fordere die KI heraus“.
Hier betritt das Konto, das den Raum hostet, das Feld und spielt mit der KI. Alles läuft in Node, neben dem Raum, ohne Python. Der Code liegt im Beispielprojekt, Ordner src/ia/.
Der schnellste Weg
- Lade das Beispielprojekt und das Modell herunter. Leg
football-1x1.policy.jsonin den Projektordner. - In der
.env:MODO=ia(und, wenn du willst,IA_MODELO=pfad/zum/modell.json). npm run dev, tritt dem Raum bei und fordere die KI heraus.
Wer beitritt, kommt in eine Warteschlange; die KI spielt Blau gegen den Ersten der Warteschlange. Wer die KI schlägt, bleibt; wer verliert, geht ans Ende der Warteschlange.
So funktioniert es, Teil für Teil
„Augen“-ScoreTracker (ohne Verzögerung) ──'state' alle 100 ms──► JogadorIA
│ buildObs() → 39 Zahlen
│ policy.logits() → 18 Noten
│ decide() → Aktion, ohne Zickzack
│ actionToBits() → Tasten (gespiegelt bei Rot)
▼
room.sendInput(tasten) ──► bonk.io-Server ──► Spieler
tracker.recordOwnInput() (die lokale Simulation muss es auch wissen)1. Die Beobachtung: features.ts
Das ist der heikelste Teil: Er muss identisch mit dem Training sein. Fass ihn nicht an, ohne mit den Testfällen zu prüfen.
// features.ts
/**
* Beobachtung und Aktionen der BonkTools-Fußball-KI — genau so, wie sie trainiert wurde.
*
* Jeder Unterschied (eine Skalierung, ein Vorzeichen, ein anders behandeltes fehlendes Feld) lässt die KI schlecht spielen
* OHNE jeden Fehler. Prüfe deine Version mit den Testfällen, die mit dem Modell veröffentlicht sind.
*
* Kanonische Achse: Der Bot "greift immer nach rechts an". Als Rot (greift nach links an) werden x und die
* x-Geschwindigkeiten in der Beobachtung gespiegelt und links/rechts in der Aktion vertauscht.
*
* Beobachtungsversionen (die Policy gibt sie in `obsVersion`/`obsSize` an): v1 = 25 Zahlen; v2 = 39 (v1 + Pfosten,
* Wände, Ball-Tor-Ausrichtung und Ballgeschwindigkeit relativ zum Bot).
*/
export const TEAM_RED = 2;
export const TEAM_BLUE = 3;
const CENTER_X = 33.18;
const CENTER_Y = 22.73;
const HALF_W = 33.0;
const HALF_H = 22.7;
const GOAL_X = 64.0;
const OWN_GOAL_X = 2 * CENTER_X - GOAL_X;
const PLAYER_MAX_SPEED = 11.7;
const BALL_MAX_SPEED = 20.0;
export const LEFT = 1;
export const RIGHT = 2;
export const UP = 4;
export const DOWN = 8;
export const KICK = 16;
const DIRS = [0, UP, UP | RIGHT, RIGHT, DOWN | RIGHT, DOWN, DOWN | LEFT, LEFT, UP | LEFT];
/** 9 Richtungen (inkl. Stillstand) x {kein Schuss, Schuss} — dieselbe Reihenfolge wie im Training. */
export const ACTION_TABLE: readonly number[] = [...DIRS, ...DIRS.map((d) => d | KICK)];
/** Größe der Beobachtung pro Version. 101 = die des per RL trainierten Torwarts (goleiro-rl.ts). */
export const OBS_SIZES: Readonly<Record<number, number>> = { 1: 25, 2: 39, 101: 27 };
export const OBS_SIZE = OBS_SIZES[1]!;
// Geometrie der v2 (kanonische Achse).
const POST_X = 64.09;
const POST_Y_TOP = CENTER_Y - 6.5;
const POST_Y_BOTTOM = CENTER_Y + 6.5;
const PLAYER_X_MIN = 1.0;
const PLAYER_X_MAX = 65.36;
const PLAYER_Y_MIN = 1.0;
const PLAYER_Y_MAX = 44.45;
const BALL_Y_MIN = 7.79;
const BALL_Y_MAX = 37.67;
/** Beobachtungsversion aus der Eingabegröße des Netzes (25 -> 1, 39 -> 2); null, wenn keine. */
export function versionForSize(size: number): number | null {
for (const [v, n] of Object.entries(OBS_SIZES)) if (n === size) return Number(v);
return null;
}
export function mirrorBits(bits: number): number {
let rest = bits & ~(LEFT | RIGHT);
if (bits & LEFT) rest |= RIGHT;
if (bits & RIGHT) rest |= LEFT;
return rest;
}
export function actionToBits(action: number, mirror: boolean): number {
const bits = ACTION_TABLE[action] ?? 0;
return mirror ? mirrorBits(bits) : bits;
}
/** Das Team greift nach links an (Rot) — muss auf die kanonische Achse gespiegelt werden. */
export function teamMirror(team: number): boolean {
return team === TEAM_RED;
}
interface Body {
x: number;
y: number;
xv: number;
yv: number;
kickReady?: boolean;
}
const ZERO: Body = { x: CENTER_X, y: CENTER_Y, xv: 0, yv: 0, kickReady: false };
/** null/undefined und ein LEERES Objekt gelten als fehlend (wie im Python-Training). */
function isBody(v: unknown): v is Body {
return !!v && typeof v === 'object' && Object.keys(v).length > 0;
}
/** Zustand von ScoreTracker/PhysicsSimulator (ball, discs[], ftu). Fehlend = ruhend in der Feldmitte. */
export interface GameStateLike {
ball?: unknown;
discs?: unknown;
ftu?: unknown;
}
function ball(state: GameStateLike): Body {
return isBody(state.ball) ? state.ball : ZERO;
}
function disc(state: GameStateLike, id: number): Body {
const discs = Array.isArray(state.discs) ? state.discs : [];
const d: unknown = id >= 0 && id < discs.length ? discs[id] : null;
return isBody(d) ? d : ZERO;
}
function canon(b: Body, mirror: boolean): [number, number, number, number] {
return mirror ? [2 * CENTER_X - b.x, b.y, -b.xv, b.yv] : [b.x, b.y, b.xv, b.yv];
}
const clip = (v: number): number => Math.min(2, Math.max(-2, v));
/**
* Projiziert den Zustand `leadFrames` Frames (30/s) VORAUS: Positionen += Geschwindigkeit × Zeit (ohne Kollisionen) und die
* Anstoß-Sperruhr (`ftu`) vorgestellt.
*
* Die lokale Simulation des Raums läuft absichtlich 6 Frames (200 ms) hinter der Uhr, damit verspätete Tasten aus dem Netz
* ankommen (und die Auto-Wertung kein Tor ansagt, das eine verspätete Taste rückgängig machen würde). Der Bot entschied über diese Vergangenheit:
* im Simulator verlor die KI mit 200 ms Verzögerung JEDEN Anstoß gegen einen Stürmer, der direkt schießt;
* mit Projektion kassierte sie wieder keine Anstoß-Tore.
*/
export function projectState(state: GameStateLike, leadFrames: number): GameStateLike {
if (!(leadFrames > 0)) return state;
const dt = leadFrames / 30;
const move = (v: unknown): unknown => {
if (!isBody(v)) return v;
const b = v as Body & Record<string, unknown>;
return { ...b, x: b.x + b.xv * dt, y: b.y + b.yv * dt };
};
const out: GameStateLike = { ...state, ball: move(state.ball) };
if (Array.isArray(state.discs)) out.discs = state.discs.map(move);
if (typeof state.ftu === 'number' && state.ftu > 0) out.ftu = Math.max(state.ftu - leadFrames, 0);
return out;
}
function unit(dx: number, dy: number): [number, number] {
const n = Math.hypot(dx, dy);
return n > 1e-6 ? [dx / n, dy / n] : [0, 0];
}
/** Beobachtung (float32 wie in NumPy) aus Sicht von `selfId`, in Version `version` (1 = 25, 2 = 39 Zahlen). */
export function buildObs(
state: GameStateLike,
selfId: number,
oppId: number,
mirror: boolean,
version = 1,
): Float32Array {
const v1 = buildObsV1(state, selfId, oppId, mirror);
if (version === 1) return v1;
if (version !== 2) throw new Error(`versão de observação desconhecida: ${version}`);
const out = new Float32Array(OBS_SIZES[2]!);
out.set(v1);
out.set(extraV2(state, selfId, mirror), v1.length);
return out;
}
function extraV2(state: GameStateLike, selfId: number, mirror: boolean): Float32Array {
const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
const [bx, by, bxv, byv] = canon(ball(state), mirror);
const ownX = 2 * CENTER_X - POST_X;
const [ax, ay] = unit(bx - sx, by - sy);
const [gx, gy] = unit(POST_X - bx, CENTER_Y - by);
const [dx, dy] = unit(sx - bx, sy - by);
const [ox, oy] = unit(ownX - bx, CENTER_Y - by);
const values = [
(POST_X - sx) / HALF_W, (POST_Y_TOP - sy) / HALF_H, (POST_Y_BOTTOM - sy) / HALF_H, (sx - ownX) / HALF_W,
(sx - PLAYER_X_MIN) / HALF_W, (PLAYER_X_MAX - sx) / HALF_W,
(sy - PLAYER_Y_MIN) / HALF_H, (PLAYER_Y_MAX - sy) / HALF_H,
(by - BALL_Y_MIN) / HALF_H, (BALL_Y_MAX - by) / HALF_H,
ax * gx + ay * gy, dx * ox + dy * oy,
(bxv - sxv) / BALL_MAX_SPEED, (byv - syv) / BALL_MAX_SPEED,
];
const out = new Float32Array(values.length);
for (let i = 0; i < values.length; i++) out[i] = clip(Math.fround(values[i]!));
return out;
}
function buildObsV1(state: GameStateLike, selfId: number, oppId: number, mirror: boolean): Float32Array {
const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
const [ox, oy, oxv, oyv] = canon(disc(state, oppId), mirror);
const [bx, by, bxv, byv] = canon(ball(state), mirror);
// Python: `state.get("ftu", -1) or 0` — fehlend wird -1; 0/None werden 0.
const rawFtu = state.ftu === undefined ? -1 : typeof state.ftu === 'number' ? state.ftu : 0;
const px = (x: number): number => (x - CENTER_X) / HALF_W;
const py = (y: number): number => (y - CENTER_Y) / HALF_H;
const dSelf = Math.hypot(bx - sx, by - sy);
const dOpp = Math.hypot(bx - ox, by - oy);
const values = [
px(sx), py(sy), sxv / PLAYER_MAX_SPEED, syv / PLAYER_MAX_SPEED,
px(bx), py(by), bxv / BALL_MAX_SPEED, byv / BALL_MAX_SPEED,
px(ox), py(oy), oxv / PLAYER_MAX_SPEED, oyv / PLAYER_MAX_SPEED,
(bx - sx) / HALF_W, (by - sy) / HALF_H,
(bx - ox) / HALF_W, (by - oy) / HALF_H,
(GOAL_X - bx) / HALF_W, (CENTER_Y - by) / HALF_H,
(bx - OWN_GOAL_X) / HALF_W, (by - CENTER_Y) / HALF_H,
dSelf / HALF_W, dOpp / HALF_W,
disc(state, selfId).kickReady ? 1 : 0,
disc(state, oppId).kickReady ? 1 : 0,
Math.min(Math.max(rawFtu, 0), 120) / 120,
];
// np.array(..., dtype=float32) rundet jeden Wert VOR dem Clip auf float32 (der in float32 vergleicht).
const out = new Float32Array(OBS_SIZE);
for (let i = 0; i < OBS_SIZE; i++) out[i] = clip(Math.fround(values[i]!));
return out;
}2. Das Netz und die Entscheidung: policy.ts
Liest die policy.json, führt die drei Schichten aus und entscheidet Achse für Achse (warum, steht unter Modelle herunterladen).
// policy.ts
import { readFileSync } from 'node:fs';
import { ACTION_TABLE, DOWN, KICK, LEFT, OBS_SIZES, RIGHT, UP, versionForSize } from './features.js';
/**
* Das KI-Netz (die veröffentlichte policy.json) in reinem JS — ohne Python oder PyTorch auf dem Raum-Rechner. Kleines MLP: obs(25 in v1, 39 in v2 — `obsVersion`) -> 256 -> tanh -> 256 -> tanh -> 18 Logits;
* die Aktion ist das Argmax (der wahrscheinlichste Zug). Gewichte als Base64-float32.
*/
export const POLICY_FORMAT = 'bonktools-rl-policy/1';
interface LayerJson {
in: number;
out: number;
w: string;
b: string;
}
export interface PolicyJson {
format: string;
obsSize: number;
/** Beobachtungsversion (features.ts). Fehlt in alten Policies: aus obsSize abgeleitet. */
obsVersion?: number;
actionTable: number[];
activation: string;
layers: LayerJson[];
timesteps?: number;
exportedAt?: string;
}
interface Layer {
inSize: number;
outSize: number;
/** out x in, Zeile für Zeile (gleiches Layout wie PyTorchs `weight`). */
w: Float32Array;
b: Float32Array;
}
function floats(b64: string, expected: number, what: string): Float32Array {
const buf = Buffer.from(b64, 'base64');
if (buf.length !== expected * 4) throw new Error(`política inválida: ${what} tem ${buf.length / 4} valores, esperado ${expected}`);
// Kopiert in einen ausgerichteten Puffer (der Base64-Puffer kann bei beliebigem Offset beginnen).
const out = new Float32Array(expected);
for (let i = 0; i < expected; i++) out[i] = buf.readFloatLE(i * 4);
return out;
}
export class Policy {
readonly timesteps: number;
readonly exportedAt: string;
/** Beobachtungsversion, die dieses Netz erwartet (an `buildObs` übergeben). */
readonly obsVersion: number;
private readonly layers: Layer[];
constructor(json: PolicyJson) {
if (json.format !== 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}`);
const version = json.obsVersion ?? versionForSize(json.obsSize);
if (version === null || OBS_SIZES[version] !== json.obsSize) {
throw new Error(`política espera ${json.obsSize} entradas (versão ${String(json.obsVersion ?? '?')}); a sala não conhece essa observação`);
}
this.obsVersion = version;
if (json.actionTable.length !== ACTION_TABLE.length || json.actionTable.some((v, i) => v !== ACTION_TABLE[i])) {
throw new Error('tabela de ações da política não bate com a da sala (features.ts)');
}
this.layers = json.layers.map((l, i) => ({
inSize: l.in,
outSize: l.out,
w: floats(l.w, l.in * l.out, `camada ${i} (pesos)`),
b: floats(l.b, l.out, `camada ${i} (bias)`),
}));
for (let i = 1; i < this.layers.length; i++) {
if (this.layers[i]!.inSize !== this.layers[i - 1]!.outSize) throw new Error(`política inválida: camada ${i} não encaixa na anterior`);
}
if (this.layers[0]?.inSize !== json.obsSize || this.layers.at(-1)?.outSize !== ACTION_TABLE.length) {
throw new Error('política inválida: entrada/saída não batem com a observação/ações');
}
this.timesteps = json.timesteps ?? 0;
this.exportedAt = json.exportedAt ?? '';
}
static fromFile(file: string): Policy {
return new Policy(JSON.parse(readFileSync(file, 'utf8')) as PolicyJson);
}
/** Logits jeder Aktion (tanh in den verborgenen Schichten, linear in der letzten). */
logits(obs: ArrayLike<number>): Float64Array {
let x: ArrayLike<number> = obs;
for (let li = 0; li < this.layers.length; li++) {
const { inSize, outSize, w, b } = this.layers[li]!;
const y = new Float64Array(outSize);
for (let o = 0; o < outSize; o++) {
let s = b[o]!;
const row = o * inSize;
for (let i = 0; i < inSize; i++) s += w[row + i]! * x[i]!;
y[o] = li < this.layers.length - 1 ? Math.tanh(s) : s;
}
x = y;
}
return x as Float64Array;
}
/** Deterministische Aktion (Index in ACTION_TABLE): reines Argmax. Live wird `decide` genutzt (kein Zickzack). */
act(obs: ArrayLike<number>): number {
const l = this.logits(obs);
let best = 0;
for (let i = 1; i < l.length; i++) if (l[i]! > l[best]!) best = i;
return best;
}
}
/** Schwellen der Achse-für-Achse-Entscheidung (im Simulator gemessen). */
export const AXIS_MARGIN = 0.25;
export const FLIP_MARGIN = 0.7;
function axis(pPos: number, pNeg: number, prev: number): number {
const diff = pPos - pNeg;
const needPos = prev < 0 ? FLIP_MARGIN : AXIS_MARGIN;
const needNeg = prev > 0 ? FLIP_MARGIN : AXIS_MARGIN;
if (diff > needPos) return 1;
if (-diff > needNeg) return -1;
return 0;
}
/**
* Entscheidet den Zug ACHSE FÜR ACHSE aus den Logits
* Das Argmax der 18 Aktionen wechselte bei jeder Entscheidung zwischen fast gleichauf liegendem "diagonal hoch"/"diagonal runter": der Bot
* lief Zickzack und nie geradeaus (42 Wechsel/min in echten Spielen; Menschen ~1). Hier kommt jede Achse
* aus der summierten Wahrscheinlichkeit jeder Seite; Gleichstand = keine Taste auf dieser Achse (geradeaus), und das Umkehren der
* vorherigen Richtung braucht einen größeren Vorsprung (Hysterese). Schuss, wenn P(Schuss) > 0,5.
*/
export function decide(logits: ArrayLike<number>, prevAction: number | null): number {
let max = -Infinity;
for (let i = 0; i < logits.length; i++) max = Math.max(max, logits[i]!);
const p = new Float64Array(logits.length);
let sum = 0;
for (let i = 0; i < logits.length; i++) sum += p[i] = Math.exp(logits[i]! - max);
let up = 0, down = 0, left = 0, right = 0, kick = 0;
for (let i = 0; i < p.length; i++) {
const q = p[i]! / sum;
const b = ACTION_TABLE[i]!;
if (b & UP) up += q;
if (b & DOWN) down += q;
if (b & LEFT) left += q;
if (b & RIGHT) right += q;
if (b & KICK) kick += q;
}
const pb = prevAction === null ? 0 : ACTION_TABLE[prevAction] ?? 0;
const v = axis(down, up, pb & UP ? -1 : pb & DOWN ? 1 : 0); // +1 = unten (y wächst nach unten)
const h = axis(right, left, pb & RIGHT ? 1 : pb & LEFT ? -1 : 0);
let bits = (v > 0 ? DOWN : v < 0 ? UP : 0) | (h > 0 ? RIGHT : h < 0 ? LEFT : 0);
if (kick > 0.5) bits |= KICK;
return ACTION_TABLE.indexOf(bits);
}3. Der Spieler: jogador-ia.ts
// jogador-ia.ts
import type { BonkRoom, ScoreTracker, StateInfo } from 'bonktools';
import { actionToBits, buildObs, projectState, teamMirror } from './features.js';
import { decide, type Policy } from './policy.js';
/**
* Lässt den Bot (das Konto, das den Raum hostet) mit der KI SPIELEN: bei jedem neuen Simulationszustand (100 ms)
* baut er die Beobachtung, führt das Netz aus und drückt die Tasten.
*/
export class JogadorIA {
private partida: { eu: number; adversario: number; espelho: boolean } | null = null;
private ultimasTeclas = -1; // zuletzt gesendete Kombination (nur bei Änderung senden, wie eine echte Tastatur)
private ultimaAcao: number | null = null; // die Achse-für-Achse-Entscheidung vergleicht mit der vorherigen (verhindert Zickzack)
constructor(
private readonly room: BonkRoom,
/** Der ScoreTracker des Raums (Spielstand): die eigene Taste des Bots muss dort hinein. */
private readonly placar: ScoreTracker,
private readonly policy: Policy,
/**
* "Augen" ohne Verzögerung (optional): ein 2. ScoreTracker mit lagFrames 0. Ohne ihn sieht die KI den Zustand
* des Spielstands, der 200 ms in der Vergangenheit liegt, und wir projizieren ihn in die Gegenwart.
*/
private readonly olhos?: ScoreTracker,
/** Meldet jede gesendete Taste (der Replay-Rekorder braucht sie). */
private readonly aoTeclar?: (id: number, k: { i: number; f: number; c: number }) => void,
) {
(olhos ?? placar).on('state', this.aoEstado);
}
/** `time` (Team): 3 = Blau (greift nach rechts an), 2 = Rot (die KI spiegelt das Feld). */
comecar(eu: number, adversario: number, time: number): void {
this.partida = { eu, adversario, espelho: teamMirror(time) };
this.ultimasTeclas = -1;
this.ultimaAcao = null;
}
parar(): void {
this.partida = null;
this.enviar(0); // lässt alle Tasten los
}
private readonly aoEstado = ({ state }: StateInfo): void => {
const p = this.partida;
if (!p || !state || typeof state !== 'object') return;
// ohne "Augen" ist der Zustand 6 Frames (200 ms) zurück: auf jetzt projizieren
const visto = this.olhos ? state : projectState(state, 6);
const obs = buildObs(visto, p.eu, p.adversario, p.espelho, this.policy.obsVersion);
const acao = decide(this.policy.logits(obs), this.ultimaAcao);
this.ultimaAcao = acao;
this.enviar(actionToBits(acao, p.espelho));
};
private enviar(teclas: number): void {
if (teclas === this.ultimasTeclas || this.partida === null && teclas !== 0) return;
this.ultimasTeclas = teclas;
const eu = this.partida?.eu ?? this.room.state.myId;
if (eu === null) return;
const k = this.room.sendInput(teclas);
// Der Server schickt dem Host seine eigene Taste nicht zurück: ohne das würde die lokale Simulation
// den Bot für stillstehend halten und die KI "sähe" ein anderes Spiel als das echte.
this.placar.recordOwnInput(eu, k.i, k.f, k.c);
this.olhos?.recordOwnInput(eu, k.i, k.f, k.c);
this.aoTeclar?.(eu, k);
}
destroy(): void {
(this.olhos ?? this.placar).off('state', this.aoEstado);
this.partida = null;
}
}Drei Details, die den Unterschied machen:
recordOwnInput. Der Server schickt dem Host seine eigene Taste nicht zurück. Ohne sie in der lokalen Simulation zu registrieren, hielte diese den Bot für stillstehend, und die KI „sähe“ ein anderes Spiel als das echte.- Sendet eine Taste nur, wenn sie sich ändert, wie eine echte Tastatur. Alle 100 ms zu senden bläht den Verlauf auf, den Spieler bekommen, die mitten im Spiel beitreten.
- Lässt am Ende alles los (
parar(), „anhalten“, sendet 0); sonst läuft die Scheibe des Bots im nächsten Spiel von allein weiter.
4. Die „Augen“: warum zwei ScoreTracker
Der ScoreTracker des Spielstands läuft absichtlich 200 ms hinter der Uhr: Er wartet auf verspätete Tasten aus dem Netz, damit er nie ein Tor ansagt, das nicht passiert ist. Super für den Spielstand, schlecht zum Spielen: Die KI würde über die Vergangenheit entscheiden.
Deshalb erstellt der Raum „Fordere die KI heraus“ einen zweiten ScoreTracker mit lagFrames: 0: die „Augen“. Er simuliert bis zum aktuellen Moment und geht zurück und rechnet den Abschnitt neu, wenn eine verspätete Taste ankommt.
| Raum-Einstellung | Trainiere mit | Gemessenes Ergebnis (100 Spielzüge gegen das stärkste Skript) |
|---|---|---|
Mit „Augen“ (lagFrames: 0), ohne Projektion | --visao agora (Standard) | 95 Tore, 2 Gegentore |
Nur der Spielstand (200 ms zurück) + projectState(zustand, 6) | --visao atrasada | 68 Tore, 13 Gegentore |
5. Der Raum „Fordere die KI heraus“: sala-ia.ts
// sala-ia.ts
import { ScoreTracker, TEAM_BLUE, TEAM_RED, TEAM_SPEC, type BonkRoom } from 'bonktools';
import { falar } from '../chat.js';
import { JogadorIA } from './jogador-ia.js';
import { Policy } from './policy.js';
/** Raum "Fordere die KI heraus": Die KI spielt Blau und jeder Spieler der Warteschlange spielt gegen sie. Wer gewinnt, bleibt. */
export class SalaIA {
private readonly placar: ScoreTracker;
private readonly olhos: ScoreTracker;
private readonly ia: JogadorIA;
private fila: number[] = [];
private adversario: number | null = null;
private timer: NodeJS.Timeout | null = null;
constructor(private readonly room: BonkRoom, arquivoModelo = 'football-1x1.policy.json') {
this.placar = new ScoreTracker(room, { cacheDir: '.cache/bonk-client' });
this.olhos = new ScoreTracker(room, { cacheDir: '.cache/bonk-client', lagFrames: 0 });
this.ia = new JogadorIA(room, this.placar, Policy.fromFile(arquivoModelo), this.olhos);
room.on('player-join', (p) => {
this.fila.push(p.id);
falar(room, `${p.userName}, você está na fila para desafiar a IA (posição ${this.fila.length})`);
this.proxima();
});
room.on('player-leave', (p) => {
this.fila = this.fila.filter((id) => id !== p.id);
if (p.id === this.adversario) this.encerrar(null);
});
this.placar.on('score', ({ scores }) => falar(room, `IA ${scores[TEAM_BLUE]} x ${scores[TEAM_RED]} desafiante`));
this.placar.on('match-winner', ({ team }) => {
falar(room, team === TEAM_BLUE ? 'a IA venceu!' : 'você venceu a IA!');
this.timer = setTimeout(() => this.encerrar(team), 4_000); // nach dem Siegbildschirm
});
void this.placar.start();
void this.olhos.start();
room.lockTeams();
}
private proxima(): void {
const eu = this.room.state.myId;
if (this.adversario !== null || !this.fila.length || eu === null) return;
const adv = this.fila[0]!;
this.adversario = adv;
for (const id of this.room.state.players.keys()) {
this.room.setTeam(id, id === eu ? TEAM_BLUE : id === adv ? TEAM_RED : TEAM_SPEC);
}
setTimeout(async () => {
const escalacao: Array<{ id: number; team: number } | null> = [];
escalacao[eu] = { id: eu, team: TEAM_BLUE };
escalacao[adv] = { id: adv, team: TEAM_RED };
const is = await this.placar.buildInitialState(escalacao);
if (!is || this.adversario !== adv) return void this.encerrar(null);
this.room.startGame({ is });
this.ia.comecar(eu, adv, TEAM_BLUE);
}, 1_000); // gibt den Teamwechseln Zeit, beim Server anzukommen
}
/** Spielende. `vencedor` (Sieger) null = abgebrochen. Wer gegen die KI verloren hat, geht ans Ende der Warteschlange. */
private encerrar(vencedor: number | null): void {
const adv = this.adversario;
this.adversario = null;
this.ia.parar();
this.room.stopGame();
this.room.emit('game-end', { type: 'GAME_END' });
if (adv !== null && vencedor === TEAM_BLUE && this.fila.includes(adv)) {
this.fila = [...this.fila.filter((id) => id !== adv), adv];
}
setTimeout(() => this.proxima(), 2_000);
}
destroy(): void {
if (this.timer) clearTimeout(this.timer);
this.ia.destroy();
this.placar.stop();
this.olhos.stop();
}
}Um aufs Feld zu gehen, setzt sich der Bot in ein Team (room.setTeam(eu, TEAM_BLUE)), und der Anfangszustand wird mit ihm in der Aufstellung erzeugt, wie bei jedem Spieler.
Die Spiele der KI aufzeichnen
Wenn du auch den Rekorder nutzt, gib ihm die Tasten des Bots (peer-input liefert die des Hosts selbst nicht):
const gravador = new Gravador(room, placar);
const ia = new JogadorIA(room, placar, policy, olhos, (id, tecla) => gravador.teclaPropria(id, tecla));Das Modell wechseln, ohne den Raum neu zu starten
In den BonkTools-Räumen wurde das Modell bei vollem Raum gewechselt: Jede Minute prüfte der Bot das Dateidatum und lud bei einer Änderung das neue (und behielt das alte, wenn das neue kaputt war). Eine gute Idee, wenn du oft trainierst und aktualisierst:
let mtime = 0;
setInterval(() => {
const m = statSync(arquivo).mtimeMs;
if (m === mtime) return;
try { policy = Policy.fromFile(arquivo); mtime = m; } catch { /* ungültige Datei: das aktuelle behalten */ }
}, 60_000);Ideen
- Einstellbare Schwierigkeit: Ersetze mit Wahrscheinlichkeit p die Entscheidung durch eine zufällige Aktion oder halte die vorherige Taste einen Tick länger. So bekommt der Skript-Gegner im Training sein „Können“.
- 2v2 mit KI: Zwei
JogadorIAfunktionieren nicht auf demselben Konto (ein Konto = ein Spieler). Für zwei Bots verbinde ein zweites Konto mitjoinRoom()und gib ihm seinen eigenenJogadorIA. Die anderen Modelle (Torwart, Mbappa) findest du unter Modelle herunterladen. - Mit den Spielen deines Raums trainieren: Zeichne die Spiele gegen Menschen auf und nutze die echten Spielzüge als Trainingsszenarien. Das hat unserer KI beim Verteidigen am meisten geholfen (siehe Was wir gelernt haben).