Crie sua sala

Sua sala, passo a passo

Baixe o projeto de exemplo, entenda como ele se organiza e suba a sua sala de football em minutos.

Nesta trilha você monta uma sala de football completa, do jeito que as salas da BonkTools funcionavam: pick com capitães, placar automático, comandos e admins, gravação das partidas, Discord e até um modo "desafie a IA". Tudo feito só com a biblioteca bonktools.

Cada página da aba explica uma parte. Esta aqui mostra o esqueleto e como as partes se conversam.

1. Baixe o projeto

Baixar sala-exemplo.zip e descompacte. Você vai precisar do Node.js 20.18 ou mais novo (nodejs.org).

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

Em alguns segundos aparece no terminal:

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

Abra o link no navegador e entre. Pronto: você está na sua sala.

2. Como o projeto se organiza

text
sala-exemplo/
├── .env              segredos e ajustes (fora do git!)
├── src/
│   ├── index.ts      sobe a sala e recria se ela cair
│   ├── config.ts     nome, senha, tamanho dos times, gols, admins
│   ├── sala.ts       liga tudo: boas-vindas, chat, placar, pick, rec, Discord
│   ├── pick.ts       sistema de pick
│   ├── comandos.ts   comandos de chat e admins
│   ├── chat.ts       quebra mensagens longas (o chat do bonk corta em ~95 letras)
│   ├── rec.ts        grava cada partida em replays/*.bkrp
│   ├── discord.ts    webhook e bot do Discord
│   └── ia/           a IA (veja a aba "Inteligência Artificial")
└── replays/          as partidas gravadas

A ideia é simples: cada arquivo cuida de uma coisa, e o sala.ts liga todos aos eventos da sala. Quer mudar o pick? Mexa só no pick.ts. Quer um comando novo? Só no comandos.ts ou no sala.ts.

3. A configuração

Tudo o que muda de uma sala para outra fica no config.ts, lido do .env:

ts
// config.ts
// Tudo o que muda de uma sala para outra fica aqui (e os segredos, no .env).
export const config = {
  sala: {
    nome: process.env.SALA_NOME ?? 'Minha Sala | Pick 2v2',
    senha: process.env.SALA_SENHA ?? '',
    maxJogadores: 8,
    oculta: process.env.SALA_OCULTA === '1',
  },
  /** Jogadores por time: 1 = 1v1, 2 = 2v2, 3 = 3v3. */
  tamanhoTime: Number(process.env.TAMANHO_TIME ?? 2),
  /** Gols para vencer. */
  gols: Number(process.env.GOLS ?? 3),
  /** Nomes (do bonk.io) com acesso aos comandos de admin. */
  admins: (process.env.ADMINS ?? '').split(',').map((n) => n.trim().toLowerCase()).filter(Boolean),
};
Variável no .envO que muda
SALA_NOME, SALA_SENHANome e senha da sala
SALA_OCULTA=1Some da lista pública (bom para testar)
TAMANHO_TIME1 = 1v1, 2 = 2v2, 3 = 3v3
GOLSGols para vencer a partida
ADMINSNomes das contas que podem usar !kick, !ban...

4. Subir a sala e mantê-la viva: 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' },
});

// A BonkSession recria a sala sozinha se ela cair. Cada sala nova é um objeto BonkRoom novo:
// por isso a lógica é montada no 'room-added' (e desmontada quando a sala some).
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: sala "desafie a IA"; senão, a sala 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,
  }],
  // intervalo entre criações de sala (importa quando há várias salas na mesma conta)
  throttle: { maxConcurrentRooms: 1, roomCreationDelayMs: 3_000, roomCreationJitterMs: 2_000 },
});

// Ctrl+C / systemd stop: fecha a sala com educação.
for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, () => void session.destroy().then(() => process.exit(0)));

Três ideias importantes aqui:

  1. BonkSession em vez de createRoom. A sessão recria a sala sozinha se ela cair (internet, servidor do bonk reiniciando). Veja Sessões 24/7 e reconexão.
  2. A lógica nasce no room-added. Quando a sala é recriada, ela é um objeto BonkRoom novo. Por isso criamos um MinhaSala novo a cada room-added e destruímos o antigo, senão os timers da sala velha ficam rodando para sempre.
  3. Encerrar com educação. No Ctrl+C (ou quando o servidor para o processo), session.destroy() fecha a sala direito.

5. Ligando as peças: 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' };

/** Tudo o que a sala faz, montado em cima de um BonkRoom. Um objeto novo a cada sala (re)criada. */
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) {
    // Placar automático: simula a física do jogo e avisa gol e vencedor (só football).
    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); // estado inicial certo p/ estes jogadores
      if (!is) return false;
      room.startGame({ is });
      return true;
    });
    this.gravador = new Gravador(room, this.tracker);

    this.registrarComandos();
    room.enableAntiAfk(); // 12 s sem se mexer nem falar = 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}`);
      // espera a tela de vitória do jogo (4 s) e faz o rodízio
      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; // capitão escolhendo
    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);
      // do Discord para a sala, com o nome de quem escreveu
      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(); // desliga a simulação (worker) desta sala
    this.discord?.destroy();
  }
}

Repare no padrão: o sala.ts escuta os eventos (player-join, chat-message, score...) e repassa para quem cuida de cada assunto. Ele não sabe como o pick funciona; só avisa o pick que alguém entrou.

O fluxo de uma partida fica assim:

text
jogador entra ─► pick.entrou() ─► monta os times ─► tracker.buildInitialState() ─► room.startGame()
                                                                                     │
ScoreTracker simula a física ─► 'score' (gol) ─► chat                                │
                             └► 'match-winner' ─► espera 4 s ─► pick.fimDePartida() ◄┘
                                                                  └► rodízio e próxima partida

6. Testando sozinho

Você não precisa de amigos para testar o básico:

  • Abra a sala em duas abas do navegador (uma normal e uma anônima, cada uma entra como um jogador).
  • Use SALA_OCULTA=1 enquanto testa, para ninguém cair na sua sala no meio de um teste.
  • O placar automático baixa os arquivos do jogo na primeira vez (pasta .cache/); a primeira partida pode demorar alguns segundos a mais.

Próximos passos