Créez votre salon
Enregistrer les matchs (rec)
Enregistrez chaque match dans un fichier .bkrp de quelques Ko et regardez-le sur notre site, avec frise chronologique, buts et chat.
Un « rec » enregistre les matchs de votre salon pour les revoir plus tard : trancher un but litigieux, garder une belle action, montrer une finale. Le fichier rec.ts du projet d'exemple enregistre chaque match dans replays/<date>.bkrp, et ce fichier s'ouvre directement sur notre site :
bonktools.com.br/fr/replays/abrir — glissez le fichier sur la page. Rien n'est envoyé : le fichier est lu dans votre navigateur. Vous pouvez même exporter le match en vidéo MP4.
Comment un replay tient en quelques Ko
bonk.io est déterministe : avec le même état initial et les mêmes touches, la physique donne toujours le même résultat. Pas besoin d'enregistrer une vidéo, seulement :
- l'état initial du match (
is) et les réglages (gs), qui arrivent dans l'événementgame-start; - les touches de chaque joueur, avec l'image (frame) où elles ont été pressées ;
- le chat du match.
Pour que le site dessine le match sans exécuter la physique dans le navigateur, on garde aussi la piste : les positions du ballon et de chaque joueur au fil du temps, tirées de la simulation du ScoreTracker que le salon exécute déjà pour le score.
D'où vient chaque donnée
| Donnée | Événement | Remarque |
|---|---|---|
is, gs | room.on('game-start') | Début du match |
| Touches | room.on('peer-input') + parseInputFrame() | Arrivent par WebRTC ; deviennent [frame, id, touches, compteur] |
| Chat | room.on('chat-message') | Enregistré avec l'image approximative |
| Positions | tracker.on('state') | Toutes les 100 ms (3 images) |
| Buts et score | tracker.on('score') | Image et équipe de chaque but |
| Vainqueur | tracker.on('match-winner') | |
| Fin | room.on('game-end') | Moment d'enregistrer |
Le format .bkrp
"BKRP" (4 octets) + version (1 octet = 1) + gzip( JSON )Le JSON contient ces champs :
| Champ | Contenu |
|---|---|
version, fps | 1 et 30 |
startedAt | début, en millisecondes depuis 1970 |
gs, is | réglages et état initial du match |
players | { id, name, team, guest, level } de chacun |
inputs | [frame, id, touches, compteur], triés par frame et compteur. Touches : gauche 1, droite 2, haut 4, bas 8, tir 16, spécial 32 |
durationFrames, scores, winnerTeam | durée, score par id d'équipe (2 rouge, 3 bleu) et vainqueur |
chat | [frame, nom, texte] |
track | la piste que le site dessine (ci-dessous) |
La piste (track, version 1, football)
| Champ | Contenu |
|---|---|
v, step | 1 et toutes les combien d'images il y a un échantillon (l'exemple utilise 3) |
n | échantillons par entité |
ents | le ballon d'abord ({k:'b'}), puis un disque par joueur ({k:'d', id, team, name}) |
d | les positions : pour chaque entité, n paires (x, y) en centièmes, chaque valeur comme différence avec la précédente, codées en zigzag + varint puis en base64 |
goals | [frame, équipe] de chaque but |
start | image où se termine le gel initial |
field, r | mesures du terrain (de l'état initial) et rayons du disque et du ballon |
Les petites différences prennent 1 ou 2 octets chacune : un match de 3 minutes tient en quelques dizaines de Ko.
Le code complet
// 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 };
/** Ce qui va dans le .bkrp (le même format que les salons BonkTools : le site l'ouvre et le lecteur le dessine). */
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 du joueur, touches, compteur]
durationFrames: number;
scores: number[];
winnerTeam: number | null;
clientHash: string | null;
track: unknown;
chat: [number, string | null, string][];
}
/**
* Enregistre chaque match dans `pasta/<date>.bkrp`.
*
* Le jeu est déterministe : état initial (is) + réglages (gs) + touches de chaque joueur suffisent
* pour tout reproduire. On garde aussi la "piste" (positions du ballon et des disques), tirée de la
* simulation du ScoreTracker, pour que le site n'ait qu'à dessiner le match.
*/
export class Gravador {
private atual: Replay | null = null;
private amostras = new Map<number, Estado>(); // frame -> état
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: [],
};
};
// Les touches des joueurs arrivent par WebRTC ; chaque paquet devient [frame, id, touches, compteur].
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;
};
/** Le bot qui JOUE (l'IA) doit aussi enregistrer ses touches : le serveur ne les renvoie pas à l'hôte. */
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; // match qui n'a même pas commencé
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]); // signature + 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)`);
};
/** Piste v1 (football) : positions toutes les `step` images, en centièmes, sous forme de différences en varint zigzag. */
private trilha(r: Replay): unknown {
const step = 3; // le ScoreTracker avance toutes les 100 ms = 3 images
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) }))];
// échantillon le plus récent jusqu'à l'image 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);
}
}
/** Entiers signés -> zigzag -> varint (7 bits par octet). */
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);
}Aller plus loin
- Statistiques et classement. Les mêmes événements donnent tout pour un
!status: comptez les victoires avecwinnerTeamet les buts avecscore. Le « buteur » est le joueur de l'équipe qui a marqué qui a touché le ballon en dernier, et on le retrouve grâce à la piste (le disque le plus proche du ballon dans les images avant le but). Stockez-le dans un JSON ou dans SQLite. - Publier les replays. Envoyez le
.bkrpdans un salon Discord (voir Intégration Discord) ou sur votre propre site. - Replay en vidéo sur Discord. Le site exporte en MP4 dans le navigateur ; sur un serveur, vous pouvez dessiner les images à partir de la piste et les passer dans
ffmpeg.