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énement game-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énementRemarque
is, gsroom.on('game-start')Début du match
Touchesroom.on('peer-input') + parseInputFrame()Arrivent par WebRTC ; deviennent [frame, id, touches, compteur]
Chatroom.on('chat-message')Enregistré avec l'image approximative
Positionstracker.on('state')Toutes les 100 ms (3 images)
Buts et scoretracker.on('score')Image et équipe de chaque but
Vainqueurtracker.on('match-winner')
Finroom.on('game-end')Moment d'enregistrer

Le format .bkrp

text
"BKRP" (4 octets)  +  version (1 octet = 1)  +  gzip( JSON )

Le JSON contient ces champs :

ChampContenu
version, fps1 et 30
startedAtdébut, en millisecondes depuis 1970
gs, isré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, winnerTeamdurée, score par id d'équipe (2 rouge, 3 bleu) et vainqueur
chat[frame, nom, texte]
trackla piste que le site dessine (ci-dessous)

La piste (track, version 1, football)

ChampContenu
v, step1 et toutes les combien d'images il y a un échantillon (l'exemple utilise 3)
néchantillons par entité
entsle ballon d'abord ({k:'b'}), puis un disque par joueur ({k:'d', id, team, name})
dles 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
startimage où se termine le gel initial
field, rmesures 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

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

/** 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 avec winnerTeam et les buts avec score. 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 .bkrp dans 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.