Eigener Raum
Spiele aufzeichnen (Rec)
Zeichne jedes Spiel in einer .bkrp-Datei von wenigen KB auf und schau es auf unserer Website an, mit Zeitleiste, Toren und Chat.
Ein „Rec“ zeichnet die Spiele deines Raums auf, damit du sie später ansehen kannst: ein umstrittenes Tor klären, einen schönen Spielzug behalten, ein Finale zeigen. Die Datei rec.ts im Beispielprojekt zeichnet jedes Spiel in replays/<datum>.bkrp auf, und diese Datei öffnet sich direkt auf unserer Website:
bonktools.com.br/de/replays/abrir — zieh die Datei auf die Seite. Nichts wird hochgeladen: Die Datei wird in deinem Browser gelesen. Du kannst das Spiel sogar als MP4-Video exportieren.
Wie ein Replay in wenige KB passt
bonk.io ist deterministisch: Mit demselben Anfangszustand und denselben Tasten liefert die Physik immer dasselbe Ergebnis. Wir müssen also kein Video aufzeichnen, sondern nur:
- den Anfangszustand des Spiels (
is) und die Einstellungen (gs), die im Ereignisgame-startankommen; - die Tasten jedes Spielers, mit dem Frame, in dem sie gedrückt wurden;
- den Chat des Spiels.
Damit die Website das Spiel zeichnen kann, ohne die Physik im Browser auszuführen, speichern wir außerdem die Spur: die Positionen von Ball und Spielern über die Zeit, entnommen der ScoreTracker-Simulation, die der Raum für den Spielstand ohnehin ausführt.
Woher was kommt
| Daten | Ereignis | Hinweis |
|---|---|---|
is, gs | room.on('game-start') | Spielbeginn |
| Tasten | room.on('peer-input') + parseInputFrame() | Kommen über WebRTC; werden zu [frame, id, tasten, zähler] |
| Chat | room.on('chat-message') | Mit ungefährem Frame aufgezeichnet |
| Positionen | tracker.on('state') | Alle 100 ms (3 Frames) |
| Tore und Spielstand | tracker.on('score') | Frame und Team jedes Tors |
| Sieger | tracker.on('match-winner') | |
| Ende | room.on('game-end') | Zeit zum Speichern |
Das Format .bkrp
"BKRP" (4 Byte) + Version (1 Byte = 1) + gzip( JSON )Das JSON hat diese Felder:
| Feld | Inhalt |
|---|---|
version, fps | 1 und 30 |
startedAt | Beginn, in Millisekunden seit 1970 |
gs, is | Einstellungen und Anfangszustand des Spiels |
players | { id, name, team, guest, level } jedes Spielers |
inputs | [frame, id, tasten, zähler], sortiert nach Frame und Zähler. Tasten: links 1, rechts 2, hoch 4, runter 8, Schuss 16, Spezial 32 |
durationFrames, scores, winnerTeam | Dauer, Spielstand nach Team-ID (2 Rot, 3 Blau) und Sieger |
chat | [frame, name, text] |
track | die Spur, die die Website zeichnet (unten) |
Die Spur (track, Version 1, Fußball)
| Feld | Inhalt |
|---|---|
v, step | 1 und alle wie viele Frames eine Probe genommen wird (das Beispiel nutzt 3) |
n | Proben pro Entität |
ents | zuerst der Ball ({k:'b'}), dann eine Scheibe pro Spieler ({k:'d', id, team, name}) |
d | die Positionen: für jede Entität n Paare (x, y) in Hundertsteln, jeder Wert als Differenz zum vorherigen, kodiert als Zigzag + Varint und dann in Base64 |
goals | [frame, team] jedes Tors |
start | Frame, in dem die anfängliche Sperre endet |
field, r | Feldmaße (aus dem Anfangszustand) und Radien von Scheibe und Ball |
Kleine Differenzen belegen je 1 oder 2 Byte: Ein 3-Minuten-Spiel passt in ein paar Dutzend KB.
Der vollständige Code
// rec.ts
import { mkdirSync, writeFileSync } from 'node:fs';
import path from 'node:path';
import { gzipSync } from 'node:zlib';
import {
decodeInitialState, parseInputFrame,
type BonkRoom, type ChatMessagePacket, type GameStartPacket, type MatchWinnerInfo,
type PeerInputEvent, type ScoreInfo, type ScoreTracker, type StateInfo,
} from 'bonktools';
type Corpo = { x: number; y: number } | null | undefined;
type Estado = { ball?: Corpo; discs?: Corpo[] | null; ftu?: number };
/** Was in die .bkrp kommt (dasselbe Format wie in den BonkTools-Räumen: die Website öffnet sie und der Player zeichnet sie). */
interface Replay {
version: 1;
startedAt: number;
fps: 30;
gs: unknown;
is: string;
players: { id: number; name: string; team: number; guest: boolean; level: number }[];
inputs: [number, number, number, number][]; // [Frame, Spieler-ID, Tasten, Zähler]
durationFrames: number;
scores: number[];
winnerTeam: number | null;
clientHash: string | null;
track: unknown;
chat: [number, string | null, string][];
}
/**
* Zeichnet jedes Spiel in `pasta/<Datum>.bkrp` auf.
*
* Das Spiel ist deterministisch: Anfangszustand (is) + Einstellungen (gs) + Tasten jedes Spielers reichen,
* um alles nachzuspielen. Zusätzlich speichern wir die "Spur" (Positionen von Ball und Scheiben) aus der
* ScoreTracker-Simulation, damit die Website das Spiel nur zeichnen muss.
*/
export class Gravador {
private atual: Replay | null = null;
private amostras = new Map<number, Estado>(); // Frame -> Zustand
private gols: [number, number][] = [];
constructor(
private readonly room: BonkRoom,
private readonly tracker: ScoreTracker,
private readonly pasta = 'replays',
) {
room.on('game-start', this.aoComecar);
room.on('peer-input', this.aoTeclar);
room.on('chat-message', this.aoFalar);
room.on('game-end', this.salvar);
tracker.on('state', this.aoSimular);
tracker.on('score', this.aoGol);
tracker.on('match-winner', this.aoVencer);
}
private readonly aoComecar = (p: GameStartPacket): void => {
if (!p.is) return;
this.amostras.clear();
this.gols = [];
this.atual = {
version: 1, startedAt: Date.now(), fps: 30, gs: p.gs ?? null, is: p.is,
players: [...this.room.state.players.values()].map((j) => ({ id: j.id, name: j.userName, team: j.team, guest: j.guest, level: j.level })),
inputs: [], durationFrames: 0, scores: [], winnerTeam: null, clientHash: null, track: null, chat: [],
};
};
// Die Tasten der Spieler kommen über WebRTC; jedes Paket wird zu [Frame, ID, Tasten, Zähler].
private readonly aoTeclar = (ev: PeerInputEvent): void => {
const k = parseInputFrame(ev.data);
if (k && this.atual) this.atual.inputs.push([k.f, ev.playerId, k.i, k.c]);
};
private readonly aoFalar = (m: ChatMessagePacket): void => {
if (!this.atual) return;
const nome = this.room.state.players.get(m.id)?.userName ?? null;
this.atual.chat.push([this.ultimoFrame(), nome, m.message.slice(0, 500)]);
};
private readonly aoSimular = (info: StateInfo): void => {
if (this.atual) this.amostras.set(info.frame, info.state as Estado);
};
private readonly aoGol = (s: ScoreInfo): void => {
this.gols.push([s.frame, s.team]);
if (this.atual) this.atual.scores = s.scores;
};
private readonly aoVencer = (w: MatchWinnerInfo): void => {
if (this.atual) this.atual.winnerTeam = w.team;
};
/** Der Bot, der SPIELT (die KI), muss auch seine eigenen Tasten aufzeichnen: der Server schickt sie dem Host nicht zurück. */
teclaPropria(id: number, k: { i: number; f: number; c: number }): void {
this.atual?.inputs.push([k.f, id, k.i, k.c]);
}
private ultimoFrame(): number {
let f = -1;
for (const k of this.amostras.keys()) f = Math.max(f, k);
return f;
}
private readonly salvar = (): void => {
const r = this.atual;
this.atual = null;
if (!r || this.amostras.size < 10) return; // Spiel, das gar nicht richtig begann
r.durationFrames = this.ultimoFrame();
r.inputs.sort((a, b) => a[0] - b[0] || a[3] - b[3] || a[1] - b[1]);
r.track = this.trilha(r);
const corpo = gzipSync(Buffer.from(JSON.stringify(r)), { level: 9 });
const arquivo = Buffer.concat([Buffer.from('BKRP'), Buffer.from([1]), corpo]); // Signatur + Version + gzip(JSON)
mkdirSync(this.pasta, { recursive: true });
const nome = path.join(this.pasta, `${new Date(r.startedAt).toISOString().replace(/[:.]/g, '-')}.bkrp`);
writeFileSync(nome, arquivo);
console.log(`[rec] partida salva: ${nome} (${(arquivo.length / 1024).toFixed(0)} KB)`);
};
/** Spur v1 (Fußball): Positionen alle `step` Frames, in Hundertsteln, als Zigzag-Varint-Differenzen. */
private trilha(r: Replay): unknown {
const step = 3; // der ScoreTracker läuft in 100-ms-Schritten = 3 Frames
const frames = [...this.amostras.keys()].sort((a, b) => a - b);
const ultimo = frames.at(-1)!;
const naoEspec = r.players.filter((p) => p.team > 0);
const ents = [{ k: 'b' }, ...naoEspec.map((p) => ({ k: 'd', id: p.id, team: p.team, name: p.name.slice(0, 32) }))];
// neueste Probe bis Frame f
let i = 0;
const em = (f: number): Estado => {
while (i + 1 < frames.length && frames[i + 1]! <= f) i++;
return this.amostras.get(frames[i]!)!;
};
const valores: number[] = [];
const serie = (pega: (e: Estado) => Corpo) => {
i = 0;
let px = 0, py = 0, ult = { x: 0, y: 0 };
for (let f = 0; f <= ultimo; f += step) {
const p = pega(em(f)) ?? ult;
ult = p;
const x = Math.round(p.x * 100), y = Math.round(p.y * 100);
valores.push(x - px, y - py);
px = x;
py = y;
}
};
serie((e) => e.ball);
for (const p of naoEspec) serie((e) => e.discs?.[p.id]);
const ini = decodeInitialState(r.is) as unknown as Record<string, unknown>;
const num = (k: string, padrao: number) => (typeof ini[k] === 'number' ? (ini[k] as number) : padrao);
const comeco = frames.find((f) => (this.amostras.get(f)!.ftu ?? 0) <= 0) ?? 0;
return {
v: 1, step, n: Math.floor(ultimo / step) + 1, ents, d: varints(valores).toString('base64'),
goals: this.gols, start: comeco,
field: { ppm: num('ppm', 11), goalHeight: num('goalHeight', 13), border: num('borderThickness', 5),
xInner: num('borderThicknessXInner', 25), yInner: num('borderThicknessYInner', 70), w: 730, h: 500 },
r: { disc: 1.06, ball: 0.7 },
};
}
destroy(): void {
this.room.off('game-start', this.aoComecar);
this.room.off('peer-input', this.aoTeclar);
this.room.off('chat-message', this.aoFalar);
this.room.off('game-end', this.salvar);
this.tracker.off('state', this.aoSimular);
this.tracker.off('score', this.aoGol);
this.tracker.off('match-winner', this.aoVencer);
}
}
/** Vorzeichenbehaftete Ganzzahlen -> Zigzag -> Varint (7 Bit pro Byte). */
function varints(valores: number[]): Buffer {
const out: number[] = [];
for (const v of valores) {
let z = v >= 0 ? v * 2 : -v * 2 - 1;
while (z >= 128) {
out.push((z % 128) | 128);
z = Math.floor(z / 128);
}
out.push(z);
}
return Buffer.from(out);
}Weiterführend
- Statistiken und Rangliste. Dieselben Ereignisse liefern alles für ein
!status: Zähle Siege überwinnerTeamund Tore überscore. Der „Torschütze“ ist der Spieler des treffenden Teams, der den Ball zuletzt berührt hat; du findest ihn über die Spur (die Scheibe, die in den Frames vor dem Tor dem Ball am nächsten war). Speichere es in einer JSON-Datei oder in SQLite. - Replays veröffentlichen. Schick die
.bkrpin einen Discord-Kanal (siehe Discord-Integration) oder auf deine eigene Website. - Replay als Video auf Discord. Die Website exportiert MP4 im Browser; auf einem Server kannst du die Frames aus der Spur zeichnen und durch
ffmpegschicken.