Crea tu sala

Sistema de pick

Cola, capitanes que eligen por número, el ganador se queda y equipos siempre del mismo tamaño. Explicado línea por línea.

El "pick" es el corazón de una sala de fútbol: decide quién juega, en qué equipo y quién espera. En esta página entiendes las reglas y el código de pick.ts del proyecto de ejemplo, y al final ves ideas para personalizarlo.

Las reglas

  1. Quien entra va a la cola (como espectador).
  2. El 1º de la cola es capitán del azul; el 2º, capitán del rojo.
  3. Para completar los equipos, el capitán del equipo menor (empate: azul) escribe el número del jugador que quiere. Sin respuesta en 30 s, va el primero de la lista. Si queda un único candidato, entra sin elección.
  4. Equipos siempre iguales. Con 3 jugadores y equipos de 2, se juega 1v1 y uno espera. Nunca empieza 2v1.
  5. Quien gana se queda en el azul. El equipo perdedor entero va al final de la cola y el 1º de la cola es el nuevo capitán del rojo.
  6. ¿Alguien salió o quedó AFK a mitad de partida? Se detiene y los equipos se rehacen.

Un ejemplo con equipos de 2 y Eva esperando:

text
azul: Ana, Carla     rojo: Bruno, Diego     cola: Eva
> gana el rojo
azul: Bruno, Diego   rojo: Eva (capitana)   cola: Ana, Carla
> Eva escribe: 2   (Carla)
azul: Bruno, Diego   rojo: Eva, Carla       cola: Ana

El estado: cuatro listas y una fase

Todo lo que el pick necesita recordar cabe en pocas variables (fila = cola, azul = azul, vermelho = rojo, fase = fase):

ts
private fila: number[] = [];          // ids de los espectadores, en orden de llegada
private readonly afk = new Set<number>();
private azul: number[] = [];          // el primero de cada equipo es el capitán
private vermelho: number[] = [];
private fase: 'lobby' | 'escolhendo' | 'jogando' = 'lobby';   // lobby | eligiendo | jugando

Los jugadores se guardan por id (un número que bonk.io da a cada uno en la sala), nunca por nombre: dos invitados pueden tener el mismo nombre.

El corazón: atualizar()

Cada vez que algo cambia (alguien entró, salió, se hizo una elección, terminó la partida), el pick llama a atualizar() ("actualizar"). Hace tres pasos:

ts
private atualizar(): void {
  if (this.fase !== 'lobby') return;
  // 1) capitanes
  if (!this.azul.length && this.fila.length) this.azul.push(this.fila.shift()!);
  if (!this.vermelho.length && this.fila.length) this.vermelho.push(this.fila.shift()!);
  // 2) completa los equipos: elige el capitán del equipo menor
  while (this.azul.length && this.vermelho.length && this.fila.length) {
    const time = this.azul.length <= this.vermelho.length ? TEAM_BLUE : TEAM_RED;
    if (this.lista(time).length >= this.n) break;          // los dos equipos están llenos
    if (this.fila.length === 1) { this.lista(time).push(this.fila.shift()!); continue; }
    this.pedirEscolha(time);                              // espera a que el capitán elija
    return;
  }
  // 3) la regla de oro: equipos del mismo tamaño
  const m = Math.min(this.azul.length, this.vermelho.length);
  if (m >= 1) for (const time of [this.azul, this.vermelho]) while (time.length > m) this.fila.unshift(time.pop()!);
  this.sincronizar();
  if (m >= 1) void this.comecar();
}

El paso 3 es lo que garantiza "nada de 2v1": si un equipo quedó mayor, quien sobra vuelve al principio de la cola (no pierde su turno).

La elección por número

pedirEscolha() ("pedir elección") anuncia la lista y espera. Cuando el capitán de turno escribe en el chat, sala.ts pasa el mensaje a pick.mensagem() antes que cualquier comando:

ts
mensagem(id: number, texto: string): boolean {
  if (this.fase !== 'escolhendo' || this.vez === null || this.lista(this.vez)[0] !== id) return false;
  const n = Number(texto.trim().replace(/^!pick\s+/i, ''));   // acepta "2" y "!pick 2"
  const escolhido = Number.isInteger(n) ? this.fila[n - 1] : undefined;
  if (escolhido === undefined) return false;
  this.escolher(escolhido);
  return true;
}

Si el capitán sale o alguien de la lista queda AFK durante la elección, la lista cambió y la elección vuelve a empezar (recomecarEscolha()). Sin eso, el número que escribiera podría apuntar a otra persona.

Empezar la partida con el estado correcto

bonk.io necesita un estado inicial (el "IS blob") con un disco por jugador. El ScoreTracker genera ese estado con la propia física del juego, para cualquier número de jugadores:

ts
this.pick = new Pick(room, config.tamanhoTime, async (escalacao) => {
  const is = await this.tracker.buildInitialState(escalacao);
  if (!is) return false;          // el pick lo intenta de nuevo en 3 s
  room.startGame({ is });
  return true;
});

La escalacao ("alineación") es una lista indexada por id: [ , {id:1,team:3}, {id:2,team:2}]. Más detalles en Partidas, IS blob y espectadores.

Fin de partida

El ScoreTracker avisa match-winner. sala.ts espera 4 segundos (la pantalla de victoria del juego) y llama a pick.fimDePartida(equipo) ("fin de partida"):

ts
fimDePartida(vencedor: number): void {
  const perdedores = vencedor === TEAM_BLUE ? this.vermelho : this.azul;
  this.fila.push(...perdedores);                                   // final de la cola
  this.azul = vencedor === TEAM_BLUE ? this.azul : this.vermelho;  // el ganador queda en azul
  this.vermelho = [];                                              // el 1º de la cola será capitán
  this.pararPartida();
  this.atualizar();
}

AFK

  • !afk lo activa y desactiva. Quien está jugando no puede quedar AFK (sería una forma fácil de huir de una partida perdida).
  • El anti-AFK de la biblioteca (room.enableAntiAfk()) avisa player-afk cuando alguien pasa 12 s sin moverse ni hablar durante la partida. El pick detiene la partida, manda a la persona al AFK y rehace los equipos. Ver Anti-AFK.

El código completo

ts
// pick.ts
import { TEAM_BLUE, TEAM_RED, TEAM_SPEC, type BonkRoom } from 'bonktools';
import { falar } from './chat.js';

type Fase = 'lobby' | 'escolhendo' | 'jogando';
/** Lista de quién juega la próxima partida: índice = id del jugador (el formato que pide el ScoreTracker). */
export type Escalacao = Array<{ id: number; team: number } | null>;

const TEMPO_ESCOLHA_MS = 30_000;

/**
 * Sistema de pick: cola de espera, capitanes que eligen por número, el ganador queda en azul
 * y ninguna partida empieza con equipos distintos (nada de 2v1).
 */
export class Pick {
  private fila: number[] = []; // espectadores, en orden de llegada
  private readonly afk = new Set<number>();
  private azul: number[] = []; // el primero de cada equipo es el capitán
  private vermelho: number[] = [];
  private fase: Fase = 'lobby';
  private vez: number | null = null; // equipo del capitán que está eligiendo
  private timer: NodeJS.Timeout | null = null;

  constructor(
    private readonly room: BonkRoom,
    /** Jugadores por equipo (1 = 1v1, 2 = 2v2...). */
    private readonly n: number,
    /** Quien inicia la partida de verdad (genera el estado inicial y llama a room.startGame). */
    private readonly iniciar: (escalacao: Escalacao) => Promise<boolean>,
  ) {}

  get jogando(): boolean {
    return this.fase === 'jogando';
  }

  entrou(id: number): void {
    this.fila.push(id);
    this.atualizar();
  }

  saiu(id: number): void {
    const jogava = this.fase === 'jogando' && this.emCampo(id);
    this.remover(id);
    this.afk.delete(id);
    if (jogava) {
      falar(this.room, 'um jogador saiu: partida terminada, refazendo os times');
      this.pararPartida();
    }
    this.recomecarEscolha();
  }

  /** El capitán de turno escribió algo en el chat. Devuelve true si era una elección. */
  mensagem(id: number, texto: string): boolean {
    if (this.fase !== 'escolhendo' || this.vez === null || this.lista(this.vez)[0] !== id) return false;
    const n = Number(texto.trim().replace(/^!pick\s+/i, ''));
    const escolhido = Number.isInteger(n) ? this.fila[n - 1] : undefined;
    if (escolhido === undefined) return false;
    this.escolher(escolhido);
    return true;
  }

  /** !afk: activa/desactiva. Devuelve la respuesta para el chat. */
  alternarAfk(id: number): string {
    if (this.afk.delete(id)) {
      this.fila.push(id);
      this.atualizar();
      return `${this.nome(id)} saiu do AFK`;
    }
    if (this.fase === 'jogando' && this.emCampo(id)) return 'quem está jogando não pode ficar AFK agora';
    this.remover(id);
    this.afk.add(id);
    this.recomecarEscolha();
    return `${this.nome(id)} agora está AFK`;
  }

  /** El anti-AFK pilló a alguien quieto en medio de la partida. */
  parado(id: number): void {
    if (!(this.fase === 'jogando' && this.emCampo(id))) return;
    falar(this.room, `${this.nome(id)} ficou parado e foi para o AFK`);
    this.remover(id);
    this.afk.add(id);
    this.pararPartida();
    this.atualizar();
  }

  /** Fin de partida: llámalo después de la pantalla de victoria. El perdedor va al final de la cola y el ganador queda en azul. */
  fimDePartida(vencedor: number): void {
    if (this.fase !== 'jogando') return;
    const perdedores = vencedor === TEAM_BLUE ? this.vermelho : this.azul;
    this.fila.push(...perdedores);
    this.azul = vencedor === TEAM_BLUE ? this.azul : this.vermelho;
    this.vermelho = [];
    this.pararPartida();
    this.atualizar();
  }

  // ── el corazón: arma los equipos y empieza cuando se pueda ────────────────────

  private atualizar(): void {
    if (this.fase !== 'lobby') return;
    // 1) capitanes: el primero de la cola va al azul, el segundo al rojo
    if (!this.azul.length && this.fila.length) this.azul.push(this.fila.shift()!);
    if (!this.vermelho.length && this.fila.length) this.vermelho.push(this.fila.shift()!);
    // 2) completa los equipos: elige el capitán del equipo menor (empate: azul)
    while (this.azul.length && this.vermelho.length && this.fila.length) {
      const time = this.azul.length <= this.vermelho.length ? TEAM_BLUE : TEAM_RED;
      if (this.lista(time).length >= this.n) break; // los dos equipos están llenos
      if (this.fila.length === 1) {
        this.lista(time).push(this.fila.shift()!); // solo un candidato: entra sin elección
        continue;
      }
      this.pedirEscolha(time);
      return;
    }
    // 3) la regla de oro: los dos equipos del MISMO tamaño (quien sobra vuelve al principio de la cola)
    const m = Math.min(this.azul.length, this.vermelho.length);
    if (m >= 1) for (const time of [this.azul, this.vermelho]) while (time.length > m) this.fila.unshift(time.pop()!);
    this.sincronizar();
    if (m >= 1) void this.comecar();
  }

  private pedirEscolha(time: number): void {
    this.fase = 'escolhendo';
    this.vez = time;
    this.sincronizar();
    const capitao = this.nome(this.lista(time)[0]!);
    falar(this.room, `${capitao}, digite o número de quem você quer no time:`);
    falar(this.room, this.fila.map((id, i) => `${i + 1} - ${this.nome(id)}`).join(', '));
    this.timer = setTimeout(() => this.escolher(this.fila[0]!), TEMPO_ESCOLHA_MS);
  }

  private escolher(id: number): void {
    if (this.vez === null || !this.fila.includes(id)) return;
    this.limparTimer();
    this.fila = this.fila.filter((x) => x !== id);
    this.lista(this.vez).push(id);
    falar(this.room, `${this.nome(this.lista(this.vez)[0]!)} escolheu ${this.nome(id)}`);
    this.fase = 'lobby';
    this.vez = null;
    this.atualizar();
  }

  private async comecar(): Promise<void> {
    this.fase = 'jogando';
    const escalacao: Escalacao = [];
    for (const id of this.azul) escalacao[id] = { id, team: TEAM_BLUE };
    for (const id of this.vermelho) escalacao[id] = { id, team: TEAM_RED };
    this.room.lockTeams(); // solo el bot mueve jugadores
    const ok = await this.iniciar(escalacao).catch(() => false);
    if (!ok && this.fase === 'jogando') {
      this.fase = 'lobby';
      setTimeout(() => this.atualizar(), 3_000); // lo intenta de nuevo en un momento
    }
  }

  private pararPartida(): void {
    this.fase = 'lobby';
    this.room.stopGame();
    // El servidor no devuelve el GAME_END a quien paró la partida: avisamos a nuestros propios oyentes.
    this.room.emit('game-end', { type: 'GAME_END' });
  }

  /** Alguien salió o quedó AFK durante la elección: la lista cambió, así que la elección vuelve a empezar. */
  private recomecarEscolha(): void {
    if (this.fase === 'escolhendo') {
      this.limparTimer();
      this.fase = 'lobby';
      this.vez = null;
    }
    this.atualizar();
  }

  /** Pone a cada jugador en el equipo que decidió el pick (solo envía lo que cambió). */
  private sincronizar(): void {
    const quer = new Map<number, number>();
    for (const id of this.azul) quer.set(id, TEAM_BLUE);
    for (const id of this.vermelho) quer.set(id, TEAM_RED);
    for (const [id, p] of this.room.state.players) {
      if (id === this.room.state.myId) continue;
      const time = quer.get(id) ?? TEAM_SPEC;
      if (p.team !== time) this.room.setTeam(id, time);
    }
  }

  private lista(time: number): number[] {
    return time === TEAM_BLUE ? this.azul : this.vermelho;
  }

  private emCampo(id: number): boolean {
    return this.azul.includes(id) || this.vermelho.includes(id);
  }

  private remover(id: number): void {
    this.fila = this.fila.filter((x) => x !== id);
    this.azul = this.azul.filter((x) => x !== id);
    this.vermelho = this.vermelho.filter((x) => x !== id);
  }

  private nome(id: number): string {
    return this.room.state.players.get(id)?.userName ?? `#${id}`;
  }

  private limparTimer(): void {
    if (this.timer) clearTimeout(this.timer);
    this.timer = null;
  }

  destroy(): void {
    this.limparTimer();
  }
}

Ideas para personalizar

IdeaDónde tocar
Rey de la pista: quien gana 3 seguidas sale para dar turnoCuenta victorias en fimDePartida() y manda el equipo a la cola
Saltar la cola para VIPs (!furarfila)Un comando que mueve el id al principio de fila
Equipos sorteados en lugar de elegidosEn pedirEscolha(), sortea en lugar de esperar el número
Detener la partida cuando llega gente para pasar de 1v1 a 2v2En entrou(), si jogando y los equipos están por debajo de n con cola suficiente, llama a pararPartida()
Tiempo de elección menorTEMPO_ESCOLHA_MS