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 eventogame-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
| Dato | Evento | Nota |
|---|---|---|
is, gs | room.on('game-start') | Inicio de la partida |
| Teclas | room.on('peer-input') + parseInputFrame() | Llegan por WebRTC; se vuelven [frame, id, teclas, contador] |
| Chat | room.on('chat-message') | Grabado con el cuadro aproximado |
| Posiciones | tracker.on('state') | Cada 100 ms (3 cuadros) |
| Goles y marcador | tracker.on('score') | Cuadro y equipo de cada gol |
| Ganador | tracker.on('match-winner') | |
| Fin | room.on('game-end') | Hora de guardar |
El formato .bkrp
"BKRP" (4 bytes) + versión (1 byte = 1) + gzip( JSON )El JSON tiene estos campos:
| Campo | Contenido |
|---|---|
version, fps | 1 y 30 |
startedAt | inicio, en milisegundos desde 1970 |
gs, is | configuració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, winnerTeam | duración, marcador por id de equipo (2 rojo, 3 azul) y ganador |
chat | [frame, nombre, texto] |
track | la pista para que el sitio dibuje (abajo) |
La pista (track, versión 1, fútbol)
| Campo | Contenido |
|---|---|
v, step | 1 y cada cuántos cuadros hay una muestra (el ejemplo usa 3) |
n | muestras por entidad |
ents | la pelota primero ({k:'b'}), luego un disco por jugador ({k:'d', id, team, name}) |
d | las 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 |
start | cuadro en que termina el congelamiento inicial |
field, r | medidas 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
// 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 conwinnerTeamy goles conscore. 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
.bkrpa 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.