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 Ereignis game-start ankommen;
  • 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

DatenEreignisHinweis
is, gsroom.on('game-start')Spielbeginn
Tastenroom.on('peer-input') + parseInputFrame()Kommen über WebRTC; werden zu [frame, id, tasten, zähler]
Chatroom.on('chat-message')Mit ungefährem Frame aufgezeichnet
Positionentracker.on('state')Alle 100 ms (3 Frames)
Tore und Spielstandtracker.on('score')Frame und Team jedes Tors
Siegertracker.on('match-winner')
Enderoom.on('game-end')Zeit zum Speichern

Das Format .bkrp

text
"BKRP" (4 Byte)  +  Version (1 Byte = 1)  +  gzip( JSON )

Das JSON hat diese Felder:

FeldInhalt
version, fps1 und 30
startedAtBeginn, in Millisekunden seit 1970
gs, isEinstellungen 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, winnerTeamDauer, Spielstand nach Team-ID (2 Rot, 3 Blau) und Sieger
chat[frame, name, text]
trackdie Spur, die die Website zeichnet (unten)

Die Spur (track, Version 1, Fußball)

FeldInhalt
v, step1 und alle wie viele Frames eine Probe genommen wird (das Beispiel nutzt 3)
nProben pro Entität
entszuerst der Ball ({k:'b'}), dann eine Scheibe pro Spieler ({k:'d', id, team, name})
ddie 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
startFrame, in dem die anfängliche Sperre endet
field, rFeldmaß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

ts
// 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 über winnerTeam und Tore über score. 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 .bkrp in 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 ffmpeg schicken.