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).
cd sala-exemplo
npm install
cp .env.example .env # no Windows: copy .env.example .env
npm run devEm alguns segundos aparece no terminal:
sala no ar: https://bonk.io/123456abcdeAbra o link no navegador e entre. Pronto: você está na sua sala.
2. Como o projeto se organiza
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 gravadasA 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:
// 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 .env | O que muda |
|---|---|
SALA_NOME, SALA_SENHA | Nome e senha da sala |
SALA_OCULTA=1 | Some da lista pública (bom para testar) |
TAMANHO_TIME | 1 = 1v1, 2 = 2v2, 3 = 3v3 |
GOLS | Gols para vencer a partida |
ADMINS | Nomes das contas que podem usar !kick, !ban... |
4. Subir a sala e mantê-la viva: index.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:
BonkSessionem vez decreateRoom. A sessão recria a sala sozinha se ela cair (internet, servidor do bonk reiniciando). Veja Sessões 24/7 e reconexão.- A lógica nasce no
room-added. Quando a sala é recriada, ela é um objetoBonkRoomnovo. Por isso criamos umMinhaSalanovo a cadaroom-addede destruímos o antigo, senão os timers da sala velha ficam rodando para sempre. - 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
// 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:
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 partida6. 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=1enquanto 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
- Sistema de pick: como o
pick.tsmonta times iguais e deixa o capitão escolher. - Comandos, admins e moderação: crie os seus comandos.
- Gravar partidas (rec): replays que abrem no nosso site.
- Integração com o Discord e Deixar a sala no ar 24/7.