Crie a sua sala

Sistema de pick

Fila, capitães que escolhem pelo número, vencedor que fica e equipas sempre do mesmo tamanho. Explicado linha a linha.

O "pick" é o coração de uma sala de football: decide quem joga, em qual equipa e quem espera. Nesta página você entende as regras e o código do pick.ts do projeto de exemplo, e no fim vê ideias para personalizar.

As regras

  1. Quem entra vai para a fila (no spec).
  2. O 1º da fila vira capitão do azul; o 2º, capitão do vermelho.
  3. Para completar as equipas, o capitão da equipa mais pequena (empate: azul) digita o número de quem quer. Sem resposta em 30 s, vai o primeiro da lista. Se só sobrou um candidato, ele entra sem escolha.
  4. Equipas sempre iguais. Com 3 jogadores e equipas de 2, joga 1v1 e um espera. Nunca começa 2v1.
  5. Quem vence fica no azul. A equipa perdedora inteira vai para o fim da fila e o 1º da fila vira o novo capitão do vermelho.
  6. Alguém saiu ou ficou AFK no meio da partida? Ela para e as equipas são refeitas.

Um exemplo com equipas de 2 e a Eva esperando:

text
azul: Ana, Carla     vermelho: Bruno, Diego    fila: Eva
> vermelho vence
azul: Bruno, Diego   vermelho: Eva (capitã)    fila: Ana, Carla
> Eva digita: 2   (Carla)
azul: Bruno, Diego   vermelho: Eva, Carla      fila: Ana

O estado: quatro listas e uma fase

Tudo o que o pick precisa lembrar cabe em poucas variáveis:

ts
private fila: number[] = [];          // ids no spec, na ordem de chegada
private readonly afk = new Set<number>();
private azul: number[] = [];          // o primeiro de cada time é o capitão
private vermelho: number[] = [];
private fase: 'lobby' | 'escolhendo' | 'jogando' = 'lobby';

Os jogadores são guardados pelo id (um número que o bonk.io dá a cada um na sala), nunca pelo nome: dois convidados podem ter o mesmo nome.

O coração: atualizar()

Toda vez que algo muda (alguém entrou, saiu, uma escolha foi feita, a partida acabou), o pick chama atualizar(). Ele faz três passos:

ts
private atualizar(): void {
  if (this.fase !== 'lobby') return;
  // 1) capitães
  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 os times: o capitão do time menor escolhe
  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;          // os dois times estão cheios
    if (this.fila.length === 1) { this.lista(time).push(this.fila.shift()!); continue; }
    this.pedirEscolha(time);                              // pausa até o capitão escolher
    return;
  }
  // 3) a regra de ouro: times do mesmo tamanho
  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();
}

O passo 3 é o que garante "nada de 2v1": se uma equipa ficou maior, quem sobra volta para o começo da fila (não perde a vez).

A escolha pelo número

pedirEscolha() anuncia a lista e espera. Quando o capitão da vez digita no chat, o sala.ts passa a mensagem para pick.mensagem() antes de qualquer 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, ''));   // aceita "2" e "!pick 2"
  const escolhido = Number.isInteger(n) ? this.fila[n - 1] : undefined;
  if (escolhido === undefined) return false;
  this.escolher(escolhido);
  return true;
}

Se o capitão sair ou alguém da lista ficar AFK durante a escolha, a lista mudou e a escolha recomeça (recomecarEscolha()). Sem isso, o número que ele digitasse poderia apontar para outra pessoa.

Começar a partida com o estado certo

O bonk.io precisa de um estado inicial (o "IS blob") com um disco para cada jogador. O ScoreTracker gera esse estado pela própria física do jogo, para qualquer número de jogadores:

ts
this.pick = new Pick(room, config.tamanhoTime, async (escalacao) => {
  const is = await this.tracker.buildInitialState(escalacao);
  if (!is) return false;          // o pick tenta de novo em 3 s
  room.startGame({ is });
  return true;
});

A escalacao é uma lista indexada pelo id: [ , {id:1,team:3}, {id:2,team:2}]. Mais detalhes em Partidas, IS blob e espectadores.

Fim de partida

O ScoreTracker avisa match-winner. O sala.ts espera 4 segundos (o ecrã de vitória do jogo) e chama pick.fimDePartida(time):

ts
fimDePartida(vencedor: number): void {
  const perdedores = vencedor === TEAM_BLUE ? this.vermelho : this.azul;
  this.fila.push(...perdedores);                                   // fim da fila
  this.azul = vencedor === TEAM_BLUE ? this.azul : this.vermelho;  // vencedor fica no azul
  this.vermelho = [];                                              // 1º da fila vira capitão
  this.pararPartida();
  this.atualizar();
}

AFK

  • !afk liga e desliga. Quem está jogando não pode ficar AFK (seria um jeito fácil de fugir de uma partida perdida).
  • O anti-AFK da biblioteca (room.enableAntiAfk()) avisa player-afk quando alguém passa 12 s sem se mexer nem falar durante a partida. O pick para a partida, manda a pessoa para o AFK e refaz as equipas. Veja Anti-AFK.

O 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 quem joga a próxima partida: índice = id do jogador (o formato que o ScoreTracker pede). */
export type Escalacao = Array<{ id: number; team: number } | null>;

const TEMPO_ESCOLHA_MS = 30_000;

/**
 * Sistema de pick: fila de espera, capitães que escolhem pelo número, vencedor fica no azul
 * e nenhuma partida começa com times diferentes (nada de 2v1).
 */
export class Pick {
  private fila: number[] = []; // espectadores, na ordem de chegada
  private readonly afk = new Set<number>();
  private azul: number[] = []; // o primeiro de cada time é o capitão
  private vermelho: number[] = [];
  private fase: Fase = 'lobby';
  private vez: number | null = null; // time do capitão que está escolhendo
  private timer: NodeJS.Timeout | null = null;

  constructor(
    private readonly room: BonkRoom,
    /** Jogadores por time (1 = 1v1, 2 = 2v2...). */
    private readonly n: number,
    /** Quem inicia a partida de verdade (gera o estado inicial e chama 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 encerrada, refazendo os times');
      this.pararPartida();
    }
    this.recomecarEscolha();
  }

  /** O capitão da vez digitou algo no chat. Devolve true se era uma escolha. */
  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: liga/desliga. Devolve a resposta para o 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`;
  }

  /** O anti-AFK pegou alguém parado no meio da 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();
  }

  /** Fim de partida: chame depois da tela de vitória. O perdedor vai para o fim da fila e o vencedor fica no 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();
  }

  // ── o coração: monta os times e começa quando der ─────────────────────────────

  private atualizar(): void {
    if (this.fase !== 'lobby') return;
    // 1) capitães: o primeiro da fila vai para o azul, o segundo para o vermelho
    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 os times: escolhe o capitão do time 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; // os dois times estão cheios
      if (this.fila.length === 1) {
        this.lista(time).push(this.fila.shift()!); // só um candidato: entra sem escolha
        continue;
      }
      this.pedirEscolha(time);
      return;
    }
    // 3) a regra de ouro: os dois times com o MESMO tamanho (quem sobra volta ao começo da fila)
    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(); // só o bot move jogadores
    const ok = await this.iniciar(escalacao).catch(() => false);
    if (!ok && this.fase === 'jogando') {
      this.fase = 'lobby';
      setTimeout(() => this.atualizar(), 3_000); // tenta de novo daqui a pouco
    }
  }

  private pararPartida(): void {
    this.fase = 'lobby';
    this.room.stopGame();
    // O servidor não devolve o GAME_END a quem parou a partida: avisamos os nossos próprios ouvintes.
    this.room.emit('game-end', { type: 'GAME_END' });
  }

  /** Alguém saiu ou ficou AFK durante a escolha: a lista mudou, então a escolha recomeça. */
  private recomecarEscolha(): void {
    if (this.fase === 'escolhendo') {
      this.limparTimer();
      this.fase = 'lobby';
      this.vez = null;
    }
    this.atualizar();
  }

  /** Coloca cada jogador no time que o pick decidiu (só manda o que mudou). */
  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();
  }
}

Ideias para personalizar

IdeiaOnde mexer
Rei da quadra: quem vence 3 seguidas sai para dar a vezConte vitórias em fimDePartida() e mande a equipa para a fila
Fila furada para VIPs (!furarfila)Um comando que move o id para o começo de fila
Equipas sorteados em vez de escolhidosEm pedirEscolha(), sorteie em vez de esperar o número
Parar a partida quando chega gente para completar um 1v1 → 2v2Em entrou(), se jogando e as equipas estão abaixo de n com fila suficiente, chame pararPartida()
Tempo de escolha menorTEMPO_ESCOLHA_MS