Créez votre salon

Votre salon, pas à pas

Téléchargez le projet d'exemple, comprenez son organisation et mettez votre salon de football en ligne en quelques minutes.

Dans ce parcours, vous montez un salon de football complet, comme fonctionnaient les salons BonkTools : pick avec capitaines, score automatique, commandes et admins, enregistrement des matchs, Discord et même un mode « défiez l'IA ». Le tout uniquement avec la bibliothèque bonktools.

Chaque page de l'onglet explique une partie. Celle-ci montre le squelette et la façon dont les parties communiquent.

1. Téléchargez le projet

Télécharger sala-exemplo.zip et décompressez-le. Il vous faut Node.js 20.18 ou plus récent (nodejs.org).

bash
cd sala-exemplo
npm install
cp .env.example .env     # sous Windows : copy .env.example .env
npm run dev

En quelques secondes, le terminal affiche :

text
sala no ar: https://bonk.io/123456abcde

(« sala no ar » = « salon en ligne ».) Ouvrez le lien dans le navigateur et entrez. Voilà : vous êtes dans votre salon.

2. Organisation du projet

text
sala-exemplo/
├── .env              secrets et réglages (hors de git !)
├── src/
│   ├── index.ts      lance le salon et le recrée s'il tombe
│   ├── config.ts     nom, mot de passe, taille des équipes, buts, admins
│   ├── sala.ts       relie tout : accueil, chat, score, pick, rec, Discord
│   ├── pick.ts       système de pick
│   ├── comandos.ts   commandes de chat et admins
│   ├── chat.ts       coupe les messages longs (le chat de bonk coupe vers 95 caractères)
│   ├── rec.ts        enregistre chaque match dans replays/*.bkrp
│   ├── discord.ts    webhook et bot Discord
│   └── ia/           l'IA (voir l'onglet « Intelligence artificielle »)
└── replays/          les matchs enregistrés

L'idée est simple : chaque fichier s'occupe d'une chose, et sala.ts (« salon ») les relie tous aux événements du salon. Vous voulez changer le pick ? Ne touchez que pick.ts. Une nouvelle commande ? Seulement comandos.ts ou sala.ts.

3. La configuration

Tout ce qui change d'un salon à l'autre est dans config.ts, lu depuis le .env :

ts
// config.ts
// Tout ce qui change d'un salon à l'autre est ici (et les secrets, dans le .env).
export const config = {
  sala: {
    nome: process.env.SALA_NOME ?? 'Mon Salon | Pick 2v2',
    senha: process.env.SALA_SENHA ?? '',
    maxJogadores: 8,
    oculta: process.env.SALA_OCULTA === '1',
  },
  /** Joueurs par équipe : 1 = 1v1, 2 = 2v2, 3 = 3v3. */
  tamanhoTime: Number(process.env.TAMANHO_TIME ?? 2),
  /** Buts pour gagner. */
  gols: Number(process.env.GOLS ?? 3),
  /** Noms (bonk.io) ayant accès aux commandes d'admin. */
  admins: (process.env.ADMINS ?? '').split(',').map((n) => n.trim().toLowerCase()).filter(Boolean),
};
Variable du .envCe qu'elle change
SALA_NOME, SALA_SENHANom et mot de passe du salon
SALA_OCULTA=1Cache le salon de la liste publique (pratique pour tester)
TAMANHO_TIMETaille des équipes : 1 = 1v1, 2 = 2v2, 3 = 3v3
GOLSButs pour gagner le match
ADMINSNoms des comptes autorisés à utiliser !kick, !ban...

4. Lancer le salon et le garder en vie : index.ts

ts
// index.ts
import 'dotenv/config';
import { BonkSession } from 'bonktools';
import { config } from './config.js';
import { SalaIA } from './ia/sala-ia.js';
import { MinhaSala } from './sala.js';

const session = new BonkSession({
  auth: process.env.BONK_USERNAME
    ? { type: 'registered', username: process.env.BONK_USERNAME, password: process.env.BONK_PASSWORD ?? '' }
    : { type: 'guest', guestName: 'MinhaSalaBot' },
});

// La BonkSession recrée le salon toute seule s'il tombe. Chaque nouveau salon est un nouvel objet BonkRoom :
// c'est pourquoi la logique est montée sur 'room-added' (et démontée quand le salon disparaît).
const salas = new Map<string, { destroy(): void }>();
session.on('room-added', (localId) => {
  const entry = session.rooms.get(localId);
  if (!entry) return;
  for (const [id, sala] of salas) if (!session.rooms.has(id)) { sala.destroy(); salas.delete(id); }
  console.log('sala no ar:', entry.room.shareLink);
  // MODO=ia : salon "défiez l'IA" ; sinon, le salon de pick
  salas.set(localId, process.env.MODO === 'ia' ? new SalaIA(entry.room, process.env.IA_MODELO) : new MinhaSala(entry.room));
});
session.on('room-removed', (localId) => { salas.get(localId)?.destroy(); salas.delete(localId); });
session.on('room-dead-terminal', ({ reason }) => console.error('a sala morreu de vez:', reason));

await session.startFromConfig({
  rooms: [{
    id: 'minha-sala',
    name: config.sala.nome,
    password: config.sala.senha,
    maxPlayers: config.sala.maxJogadores,
    mode: 'f', // football
    rounds: config.gols,
    hidden: config.sala.oculta,
  }],
  // intervalle entre créations de salon (important avec plusieurs salons sur le même compte)
  throttle: { maxConcurrentRooms: 1, roomCreationDelayMs: 3_000, roomCreationJitterMs: 2_000 },
});

// Ctrl+C / systemd stop : ferme le salon proprement.
for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, () => void session.destroy().then(() => process.exit(0)));

Trois idées importantes :

  1. BonkSession au lieu de createRoom. La session recrée le salon toute seule s'il tombe (internet, serveur bonk qui redémarre). Voir Sessions 24h/24 et reconnexion.
  2. La logique naît sur room-added. Quand le salon est recréé, c'est un nouvel objet BonkRoom. C'est pourquoi on crée un nouveau MinhaSala à chaque room-added et on détruit l'ancien ; sinon les minuteurs de l'ancien salon tournent pour toujours.
  3. Fermer proprement. Avec Ctrl+C (ou quand le serveur arrête le processus), session.destroy() ferme le salon correctement.

5. Relier les pièces : sala.ts

ts
// sala.ts
import { ScoreTracker, TEAM_BLUE, TEAM_RED, type BonkRoom } from 'bonktools';
import { falar } from './chat.js';
import { Comandos, acharJogador, ehAdmin } from './comandos.js';
import { config } from './config.js';
import { PonteDiscord, avisarWebhook, limpar } from './discord.js';
import { Pick } from './pick.js';
import { Gravador } from './rec.js';

const NOME_TIME: Record<number, string> = { [TEAM_BLUE]: 'azul', [TEAM_RED]: 'vermelho' };

/** Tout ce que fait le salon, construit sur un BonkRoom. Un nouvel objet à chaque salon (re)créé. */
export class MinhaSala {
  private readonly tracker: ScoreTracker;
  private readonly pick: Pick;
  private readonly gravador: Gravador;
  private readonly comandos = new Comandos();
  private discord: PonteDiscord | null = null;
  private fimTimer: NodeJS.Timeout | null = null;

  constructor(private readonly room: BonkRoom) {
    // Score automatique : simule la physique du jeu et signale buts et vainqueur (football seulement).
    this.tracker = new ScoreTracker(room, { cacheDir: '.cache/bonk-client' });
    this.pick = new Pick(room, config.tamanhoTime, async (escalacao) => {
      const is = await this.tracker.buildInitialState(escalacao); // le bon état initial pour ces joueurs
      if (!is) return false;
      room.startGame({ is });
      return true;
    });
    this.gravador = new Gravador(room, this.tracker);

    this.registrarComandos();
    room.enableAntiAfk(); // 12 s sans bouger ni parler = AFK

    room.on('player-join', (p) => {
      falar(room, `bem-vindo, ${p.userName}! digite !ajuda para ver os comandos`);
      this.pick.entrou(p.id);
    });
    room.on('player-leave', (p) => this.pick.saiu(p.id));
    room.on('player-afk', (id) => this.pick.parado(id));
    room.on('chat-message', (m) => this.chat(m.id, m.message));

    this.tracker.on('score', ({ team, scores }) => falar(room, `GOL do ${NOME_TIME[team]}! azul ${scores[TEAM_BLUE]} x ${scores[TEAM_RED]} vermelho`));
    this.tracker.on('match-winner', ({ team, scores }) => {
      const texto = `o time ${NOME_TIME[team]} venceu! (${scores[TEAM_BLUE]} x ${scores[TEAM_RED]})`;
      falar(room, texto);
      this.discord?.enviar(`🏆 ${texto}`);
      if (process.env.DISCORD_WEBHOOK) void avisarWebhook(process.env.DISCORD_WEBHOOK, `🏆 ${texto}`);
      // attend l'écran de victoire du jeu (4 s) et fait la rotation
      this.fimTimer = setTimeout(() => this.pick.fimDePartida(team), 4_000);
    });
    this.tracker.on('error', (e) => console.error('[placar] desligado:', e.message));
    void this.tracker.start();

    if (process.env.DISCORD_TOKEN && process.env.DISCORD_CANAL) void this.ligarDiscord(process.env.DISCORD_TOKEN, process.env.DISCORD_CANAL);
  }

  private chat(id: number, texto: string): void {
    if (id === this.room.state.myId) return;
    const nome = this.room.state.players.get(id)?.userName ?? '?';
    this.discord?.enviar(`**${limpar(nome)}**: ${limpar(texto)}`);
    if (this.pick.mensagem(id, texto)) return; // capitaine en train de choisir
    this.comandos.tratar(this.room, id, texto, (r) => falar(this.room, r));
  }

  private registrarComandos(): void {
    const room = this.room;
    this.comandos
      .registrar('ajuda', { ajuda: 'lista os comandos', executar: (c) => c.responder(this.comandos.ajuda(ehAdmin(room, c.id))) })
      .registrar('afk', { ajuda: 'entra/sai do AFK', executar: (c) => c.responder(this.pick.alternarAfk(c.id)) })
      .registrar('discord', { ajuda: 'link do Discord', executar: (c) => c.responder('entre no nosso Discord: discord.gg/SEU-CONVITE') })
      .registrar('kick', {
        ajuda: 'expulsa: !kick nome', soAdmin: true,
        executar: (c) => {
          const alvo = acharJogador(room, c.args[0] ?? '');
          if (alvo === null) return c.responder('jogador não encontrado');
          room.kickPlayer(alvo);
        },
      })
      .registrar('ban', {
        ajuda: 'bane: !ban nome', soAdmin: true,
        executar: (c) => {
          const alvo = acharJogador(room, c.args[0] ?? '');
          if (alvo === null) return c.responder('jogador não encontrado');
          room.banPlayer(alvo);
        },
      });
  }

  private async ligarDiscord(token: string, canal: string): Promise<void> {
    try {
      this.discord = await PonteDiscord.conectar(token, canal);
      // de Discord vers le salon, avec le nom de l'auteur
      this.discord.aoReceber = (autor, texto) => falar(this.room, `[discord] ${autor}: ${texto}`);
      this.discord.enviar(`sala no ar: ${this.room.shareLink}`);
    } catch (err) {
      console.error('[discord] não conectou:', err);
    }
  }

  destroy(): void {
    if (this.fimTimer) clearTimeout(this.fimTimer);
    this.pick.destroy();
    this.gravador.destroy();
    this.tracker.stop(); // arrête la simulation (worker) de ce salon
    this.discord?.destroy();
  }
}

Remarquez le principe : sala.ts écoute les événements (player-join, chat-message, score...) et les transmet à celui qui s'occupe de chaque sujet. Il ne sait pas comment fonctionne le pick ; il prévient seulement le pick que quelqu'un est entré.

Le déroulement d'un match :

text
un joueur entre ─► pick.entrou() ─► forme les équipes ─► tracker.buildInitialState() ─► room.startGame()
                                                                                         │
ScoreTracker simule la physique ─► 'score' (but) ─► chat                                 │
                                └► 'match-winner' ─► attend 4 s ─► pick.fimDePartida() ◄┘
                                                                     └► rotation et match suivant

6. Tester seul

Pas besoin d'amis pour tester l'essentiel :

  • Ouvrez le salon dans deux onglets du navigateur (un normal et un en navigation privée ; chacun entre comme un joueur).
  • Utilisez SALA_OCULTA=1 pendant les tests, pour que personne ne tombe dans votre salon en plein test.
  • Le score automatique télécharge les fichiers du jeu la première fois (dossier .cache/) ; le premier match peut prendre quelques secondes de plus.

Étapes suivantes