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 eventogame-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
| Dado | Evento | Observação |
|---|---|---|
is, gs | room.on('game-start') | Início da partida |
| Teclas | room.on('peer-input') + parseInputFrame() | Chegam por WebRTC; viram [frame, id, teclas, contador] |
| Chat | room.on('chat-message') | Gravado com o quadro aproximado |
| Posições | tracker.on('state') | A cada 100 ms (3 quadros) |
| Gols e placar | tracker.on('score') | Quadro e time de cada gol |
| Vencedor | tracker.on('match-winner') | |
| Fim | room.on('game-end') | Hora de salvar |
O formato .bkrp
"BKRP" (4 bytes) + versão (1 byte = 1) + gzip( JSON )O JSON tem estes campos:
| Campo | Conteúdo |
|---|---|
version, fps | 1 e 30 |
startedAt | início, em milissegundos desde 1970 |
gs, is | configuraçõ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, winnerTeam | duração, placar por id de time (2 vermelho, 3 azul) e vencedor |
chat | [frame, nome, texto] |
track | a trilha para o site desenhar (abaixo) |
A trilha (track, versão 1, football)
| Campo | Conteúdo |
|---|---|
v, step | 1 e de quantos em quantos quadros há uma amostra (o exemplo usa 3) |
n | amostras por entidade |
ents | a bola primeiro ({k:'b'}), depois um disco por jogador ({k:'d', id, team, name}) |
d | as 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 |
start | quadro em que acaba o congelamento inicial |
field, r | medidas 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
// 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 pelowinnerTeame gols peloscore. 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
.bkrppara 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.