Crie sua sala

Gravar partidas (rec)

Grave cada partida em um arquivo .bkrp de poucos KB e assista no nosso site, com linha do tempo, gols e chat.

Um "rec" grava as partidas da sua sala para assistir depois: tirar a dúvida de um gol, guardar uma jogada bonita, mostrar uma final. O rec.ts do projeto de exemplo grava cada partida em replays/<data>.bkrp, e esse arquivo abre direto no nosso site:

bonktools.com.br/pt/replays/abrir — arraste o arquivo para a página. Nada é enviado: o arquivo é lido no seu navegador. Dá até para exportar a partida em vídeo MP4.

Como um replay cabe em poucos KB

O bonk.io é determinístico: com o mesmo estado inicial e as mesmas teclas, a física dá sempre o mesmo resultado. Então não precisamos gravar um vídeo, só:

  • o estado inicial da partida (is) e as configurações (gs), que chegam no evento game-start;
  • as teclas de cada jogador, com o quadro (frame) em que foram apertadas;
  • o chat da partida.

Para o site desenhar a partida sem rodar a física no navegador, também guardamos a trilha: as posições da bola e de cada jogador ao longo do tempo, tiradas da simulação do ScoreTracker que a sala já roda para o placar.

De onde vem cada coisa

DadoEventoObservação
is, gsroom.on('game-start')Início da partida
Teclasroom.on('peer-input') + parseInputFrame()Chegam por WebRTC; viram [frame, id, teclas, contador]
Chatroom.on('chat-message')Gravado com o quadro aproximado
Posiçõestracker.on('state')A cada 100 ms (3 quadros)
Gols e placartracker.on('score')Quadro e time de cada gol
Vencedortracker.on('match-winner')
Fimroom.on('game-end')Hora de salvar

O formato .bkrp

text
"BKRP" (4 bytes)  +  versão (1 byte = 1)  +  gzip( JSON )

O JSON tem estes campos:

CampoConteúdo
version, fps1 e 30
startedAtinício, em milissegundos desde 1970
gs, isconfigurações e estado inicial da partida
players{ id, name, team, guest, level } de cada um
inputs[frame, id, teclas, contador], ordenados por frame e contador. Teclas: esquerda 1, direita 2, cima 4, baixo 8, chute 16, especial 32
durationFrames, scores, winnerTeamduração, placar por id de time (2 vermelho, 3 azul) e vencedor
chat[frame, nome, texto]
tracka trilha para o site desenhar (abaixo)

A trilha (track, versão 1, football)

CampoConteúdo
v, step1 e de quantos em quantos quadros há uma amostra (o exemplo usa 3)
namostras por entidade
entsa bola primeiro ({k:'b'}), depois um disco por jogador ({k:'d', id, team, name})
das posições: para cada entidade, n pares (x, y) em centésimos, cada valor como diferença do anterior, codificados em zigzag + varint e depois em base64
goals[frame, time] de cada gol
startquadro em que acaba o congelamento inicial
field, rmedidas do campo (do estado inicial) e raios do disco e da bola

Diferenças pequenas viram 1 ou 2 bytes cada: uma partida de 3 minutos cabe em poucas dezenas de KB.

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

/** O que vai dentro do .bkrp (o mesmo formato das salas da BonkTools: o site abre e o player desenha). */
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 do jogador, teclas, contador]
  durationFrames: number;
  scores: number[];
  winnerTeam: number | null;
  clientHash: string | null;
  track: unknown;
  chat: [number, string | null, string][];
}

/**
 * Grava cada partida em `pasta/<data>.bkrp`.
 *
 * O jogo é determinístico: estado inicial (is) + configuração (gs) + teclas de cada jogador bastam
 * para reproduzir tudo. Além disso guardamos a "trilha" (posições da bola e dos discos), tirada da
 * simulação do ScoreTracker, para o site só desenhar a 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: [],
    };
  };

  // Teclas dos jogadores chegam por WebRTC; cada pacote vira [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;
  };

  /** O bot que JOGA (a IA) também precisa gravar as teclas dele: o servidor não as devolve ao 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 nem começou
    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]); // assinatura + versão + 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)`);
  };

  /** Trilha v1 (football): posições a cada `step` frames, em centésimos, como diferenças em varint zigzag. */
  private trilha(r: Replay): unknown {
    const step = 3; // o ScoreTracker anda de 100 em 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) }))];
    // amostra mais recente até o 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);
  }
}

/** Inteiros com sinal -> 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);
}

Indo além

  • Estatísticas e ranking. Os mesmos eventos dão tudo para um !status: some vitórias pelo winnerTeam e gols pelo score. O "dono do gol" é o jogador do time que marcou que tocou a bola por último, e dá para descobrir pela trilha (o disco mais perto da bola nos quadros antes do gol). Guarde num arquivo JSON ou num SQLite.
  • Publicar os replays. Envie o .bkrp para um canal do Discord (veja Integração com o Discord) ou para o seu próprio site.
  • Ver o replay em vídeo no Discord. O site exporta MP4 no navegador; num servidor, dá para desenhar os quadros a partir da trilha e passar pelo ffmpeg.