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).

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

En unos segundos aparece en la terminal:

text
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

text
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 grabadas

La 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:

ts
// 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 .envQué cambia
SALA_NOME, SALA_SENHANombre y contraseña de la sala
SALA_OCULTA=1La oculta de la lista pública (bueno para probar)
TAMANHO_TIMETamaño de equipo: 1 = 1v1, 2 = 2v2, 3 = 3v3
GOLSGoles para ganar la partida
ADMINSNombres de las cuentas que pueden usar !kick, !ban...

4. Levantar la sala y mantenerla 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' },
});

// 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:

  1. BonkSession en lugar de createRoom. La sesión recrea la sala sola si se cae (internet, servidor de bonk reiniciando). Ver Sesiones 24/7 y reconexión.
  2. La lógica nace en room-added. Cuando la sala se recrea, es un objeto BonkRoom nuevo. Por eso creamos un MinhaSala nuevo en cada room-added y destruimos el anterior; si no, los temporizadores de la sala vieja siguen corriendo para siempre.
  3. 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

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í:

text
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 partida

6. 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=1 mientras 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