Crea tu sala

Grabar partidas (rec)

Graba cada partida en un archivo .bkrp de pocos KB y mírala en nuestro sitio, con línea de tiempo, goles y chat.

Un "rec" graba las partidas de tu sala para verlas después: resolver la duda de un gol, guardar una jugada bonita, mostrar una final. El rec.ts del proyecto de ejemplo graba cada partida en replays/<fecha>.bkrp, y ese archivo se abre directamente en nuestro sitio:

bonktools.com.br/es/replays/abrir — arrastra el archivo a la página. No se envía nada: el archivo se lee en tu navegador. Incluso puedes exportar la partida como video MP4.

Cómo un replay cabe en pocos KB

bonk.io es determinista: con el mismo estado inicial y las mismas teclas, la física da siempre el mismo resultado. Así que no necesitamos grabar un video, solo:

  • el estado inicial de la partida (is) y la configuración (gs), que llegan en el evento game-start;
  • las teclas de cada jugador, con el cuadro (frame) en que se pulsaron;
  • el chat de la partida.

Para que el sitio dibuje la partida sin ejecutar la física en el navegador, también guardamos la pista: las posiciones de la pelota y de cada jugador a lo largo del tiempo, tomadas de la simulación del ScoreTracker que la sala ya ejecuta para el marcador.

De dónde sale cada cosa

DatoEventoNota
is, gsroom.on('game-start')Inicio de la partida
Teclasroom.on('peer-input') + parseInputFrame()Llegan por WebRTC; se vuelven [frame, id, teclas, contador]
Chatroom.on('chat-message')Grabado con el cuadro aproximado
Posicionestracker.on('state')Cada 100 ms (3 cuadros)
Goles y marcadortracker.on('score')Cuadro y equipo de cada gol
Ganadortracker.on('match-winner')
Finroom.on('game-end')Hora de guardar

El formato .bkrp

text
"BKRP" (4 bytes)  +  versión (1 byte = 1)  +  gzip( JSON )

El JSON tiene estos campos:

CampoContenido
version, fps1 y 30
startedAtinicio, en milisegundos desde 1970
gs, isconfiguración y estado inicial de la partida
players{ id, name, team, guest, level } de cada uno
inputs[frame, id, teclas, contador], ordenados por frame y contador. Teclas: izquierda 1, derecha 2, arriba 4, abajo 8, tiro 16, especial 32
durationFrames, scores, winnerTeamduración, marcador por id de equipo (2 rojo, 3 azul) y ganador
chat[frame, nombre, texto]
trackla pista para que el sitio dibuje (abajo)

La pista (track, versión 1, fútbol)

CampoContenido
v, step1 y cada cuántos cuadros hay una muestra (el ejemplo usa 3)
nmuestras por entidad
entsla pelota primero ({k:'b'}), luego un disco por jugador ({k:'d', id, team, name})
dlas posiciones: para cada entidad, n pares (x, y) en centésimas, cada valor como diferencia del anterior, codificados en zigzag + varint y luego en base64
goals[frame, equipo] de cada gol
startcuadro en que termina el congelamiento inicial
field, rmedidas del campo (del estado inicial) y radios del disco y de la pelota

Las diferencias pequeñas ocupan 1 o 2 bytes cada una: una partida de 3 minutos cabe en unas pocas decenas de KB.

El código completo

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 };

/** Lo que va dentro del .bkrp (el mismo formato de las salas de BonkTools: el sitio lo abre y el reproductor lo dibuja). */
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, id del jugador, teclas, contador]
  durationFrames: number;
  scores: number[];
  winnerTeam: number | null;
  clientHash: string | null;
  track: unknown;
  chat: [number, string | null, string][];
}

/**
 * Graba cada partida en `pasta/<fecha>.bkrp`.
 *
 * El juego es determinista: estado inicial (is) + configuración (gs) + teclas de cada jugador bastan
 * para reproducir todo. Además guardamos la "pista" (posiciones de la pelota y los discos), tomada de la
 * simulación del ScoreTracker, para que el sitio solo dibuje la partida.
 */
export class Gravador {
  private atual: Replay | null = null;
  private amostras = new Map<number, Estado>(); // frame -> estado
  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: [],
    };
  };

  // Las teclas de los jugadores llegan por WebRTC; cada paquete se vuelve [frame, id, teclas, contador].
  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;
  };

  /** El bot que JUEGA (la IA) también necesita grabar sus teclas: el servidor no se las devuelve al host. */
  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; // partida que ni empezó
    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]); // firma + versión + 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)`);
  };

  /** Pista v1 (fútbol): posiciones cada `step` frames, en centésimas, como diferencias en varint zigzag. */
  private trilha(r: Replay): unknown {
    const step = 3; // el ScoreTracker avanza cada 100 ms = 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) }))];
    // muestra más reciente hasta el 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);
  }
}

/** Enteros con signo -> zigzag -> varint (7 bits por 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);
}

Yendo más allá

  • Estadísticas y ranking. Los mismos eventos dan todo para un !status: suma victorias con winnerTeam y goles con score. El "autor del gol" es el jugador del equipo que marcó que tocó la pelota por última vez, y se descubre por la pista (el disco más cerca de la pelota en los cuadros antes del gol). Guárdalo en un JSON o en SQLite.
  • Publicar los replays. Envía el .bkrp a un canal de Discord (ver Integración con Discord) o a tu propio sitio.
  • Replay en video en Discord. El sitio exporta MP4 en el navegador; en un servidor, puedes dibujar los cuadros a partir de la pista y pasarlos por ffmpeg.