Crea tu sala
Tu sala, paso a paso
Descarga el proyecto de ejemplo, entiende cómo se organiza y pon tu sala de fútbol en línea en minutos.
En este recorrido montas una sala de fútbol completa, como funcionaban las salas de BonkTools: pick con capitanes, marcador automático, comandos y admins, grabación de partidas, Discord e incluso un modo "desafía a la IA". Todo hecho solo con la biblioteca bonktools.
Cada página de la pestaña explica una parte. Esta muestra el esqueleto y cómo se comunican las partes.
1. Descarga el proyecto
Descargar sala-exemplo.zip y descomprímelo. Necesitarás Node.js 20.18 o más reciente (nodejs.org).
cd sala-exemplo
npm install
cp .env.example .env # en Windows: copy .env.example .env
npm run devEn unos segundos aparece en la terminal:
sala no ar: https://bonk.io/123456abcde("sala no ar" = "sala en línea".) Abre el enlace en el navegador y entra. Listo: estás en tu sala.
2. Cómo se organiza el proyecto
sala-exemplo/
├── .env secretos y ajustes (¡fuera de git!)
├── src/
│ ├── index.ts levanta la sala y la recrea si se cae
│ ├── config.ts nombre, contraseña, tamaño de los equipos, goles, admins
│ ├── sala.ts conecta todo: bienvenida, chat, marcador, pick, rec, Discord
│ ├── pick.ts sistema de pick
│ ├── comandos.ts comandos de chat y admins
│ ├── chat.ts parte mensajes largos (el chat de bonk corta en ~95 letras)
│ ├── rec.ts graba cada partida en replays/*.bkrp
│ ├── discord.ts webhook y bot de Discord
│ └── ia/ la IA (ver la pestaña "Inteligencia Artificial")
└── replays/ las partidas grabadasLa idea es simple: cada archivo se encarga de una cosa, y sala.ts los conecta todos a los eventos de la sala. ¿Quieres cambiar el pick? Toca solo pick.ts. ¿Un comando nuevo? Solo comandos.ts o sala.ts.
3. La configuración
Todo lo que cambia de una sala a otra está en config.ts, leído del .env:
// config.ts
// Todo lo que cambia de una sala a otra está aquí (y los secretos, en el .env).
export const config = {
sala: {
nome: process.env.SALA_NOME ?? 'Mi Sala | Pick 2v2',
senha: process.env.SALA_SENHA ?? '',
maxJogadores: 8,
oculta: process.env.SALA_OCULTA === '1',
},
/** Jugadores por equipo: 1 = 1v1, 2 = 2v2, 3 = 3v3. */
tamanhoTime: Number(process.env.TAMANHO_TIME ?? 2),
/** Goles para ganar. */
gols: Number(process.env.GOLS ?? 3),
/** Nombres (de bonk.io) con acceso a los comandos de admin. */
admins: (process.env.ADMINS ?? '').split(',').map((n) => n.trim().toLowerCase()).filter(Boolean),
};Variable en el .env | Qué cambia |
|---|---|
SALA_NOME, SALA_SENHA | Nombre y contraseña de la sala |
SALA_OCULTA=1 | La oculta de la lista pública (bueno para probar) |
TAMANHO_TIME | Tamaño de equipo: 1 = 1v1, 2 = 2v2, 3 = 3v3 |
GOLS | Goles para ganar la partida |
ADMINS | Nombres de las cuentas que pueden usar !kick, !ban... |
4. Levantar la sala y mantenerla 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' },
});
// La BonkSession recrea la sala sola si se cae. Cada sala nueva es un objeto BonkRoom nuevo:
// por eso la lógica se monta en 'room-added' (y se desmonta cuando la sala desaparece).
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 "desafía a la IA"; si no, la 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 creaciones de sala (importa cuando hay varias salas en la misma cuenta)
throttle: { maxConcurrentRooms: 1, roomCreationDelayMs: 3_000, roomCreationJitterMs: 2_000 },
});
// Ctrl+C / systemd stop: cierra la sala con educación.
for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, () => void session.destroy().then(() => process.exit(0)));Tres ideas importantes:
BonkSessionen lugar decreateRoom. La sesión recrea la sala sola si se cae (internet, servidor de bonk reiniciando). Ver Sesiones 24/7 y reconexión.- La lógica nace en
room-added. Cuando la sala se recrea, es un objetoBonkRoomnuevo. Por eso creamos unMinhaSalanuevo en cadaroom-addedy destruimos el anterior; si no, los temporizadores de la sala vieja siguen corriendo para siempre. - Cerrar con educación. Con
Ctrl+C(o cuando el servidor detiene el proceso),session.destroy()cierra la sala correctamente.
5. Conectando las piezas: 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' };
/** Todo lo que hace la sala, montado sobre un BonkRoom. Un objeto nuevo por cada sala (re)creada. */
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) {
// Marcador automático: simula la física del juego y avisa goles y ganador (solo fútbol).
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); // el estado inicial correcto para estos jugadores
if (!is) return false;
room.startGame({ is });
return true;
});
this.gravador = new Gravador(room, this.tracker);
this.registrarComandos();
room.enableAntiAfk(); // 12 s sin moverse ni hablar = 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 la pantalla de victoria del juego (4 s) y hace la rotación
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án eligiendo
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 a la sala, con el nombre de quien escribió
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(); // apaga la simulación (worker) de esta sala
this.discord?.destroy();
}
}Observa el patrón: sala.ts escucha los eventos (player-join, chat-message, score...) y los pasa a quien se encarga de cada tema. No sabe cómo funciona el pick; solo le avisa al pick que alguien entró.
El flujo de una partida queda así:
jugador entra ─► pick.entrou() ─► arma los equipos ─► tracker.buildInitialState() ─► room.startGame()
│
ScoreTracker simula la física ─► 'score' (gol) ─► chat │
└► 'match-winner' ─► espera 4 s ─► pick.fimDePartida() ◄┘
└► rotación y siguiente partida6. Probando solo
No necesitas amigos para probar lo básico:
- Abre la sala en dos pestañas del navegador (una normal y una de incógnito; cada una entra como un jugador).
- Usa
SALA_OCULTA=1mientras pruebas, para que nadie caiga en tu sala en medio de una prueba. - El marcador automático descarga los archivos del juego la primera vez (carpeta
.cache/); la primera partida puede tardar unos segundos más.
Próximos pasos
- Sistema de pick: cómo
pick.tsarma equipos iguales y deja elegir al capitán. - Comandos, admins y moderación: crea tus comandos.
- Grabar partidas (rec): replays que se abren en nuestro sitio.
- Integración con Discord y Mantener la sala en línea 24/7.