Crie sua sala
Sistema de pick
Fila, capitães que escolhem pelo número, vencedor que fica e times sempre do mesmo tamanho. Explicado linha a linha.
O "pick" é o coração de uma sala de football: decide quem joga, em qual time 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
- Quem entra vai para a fila (no spec).
- O 1º da fila vira capitão do azul; o 2º, capitão do vermelho.
- Para completar os times, o capitão do time menor (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.
- Times sempre iguais. Com 3 jogadores e times de 2, joga 1v1 e um espera. Nunca começa 2v1.
- Quem vence fica no azul. O time perdedor inteiro vai para o fim da fila e o 1º da fila vira o novo capitão do vermelho.
- Alguém saiu ou ficou AFK no meio da partida? Ela para e os times são refeitos.
Um exemplo com times de 2 e a Eva esperando:
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: AnaO estado: quatro listas e uma fase
Tudo o que o pick precisa lembrar cabe em poucas variáveis:
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:
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 um time 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:
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:
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 (a tela de vitória do jogo) e chama pick.fimDePartida(time):
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
!afkliga 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()) avisaplayer-afkquando 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 os times. Veja Anti-AFK.
O código completo
// 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
| Ideia | Onde mexer |
|---|---|
| Rei da quadra: quem vence 3 seguidas sai para dar a vez | Conte vitórias em fimDePartida() e mande o time para a fila |
Fila furada para VIPs (!furarfila) | Um comando que move o id para o começo de fila |
| Times sorteados em vez de escolhidos | Em pedirEscolha(), sorteie em vez de esperar o número |
| Parar a partida quando chega gente para completar um 1v1 → 2v2 | Em entrou(), se jogando e os times estão abaixo de n com fila suficiente, chame pararPartida() |
| Tempo de escolha menor | TEMPO_ESCOLHA_MS |