Créez votre salon

Système de pick

File d'attente, capitaines qui choisissent par numéro, le gagnant reste et des équipes toujours de même taille. Expliqué ligne par ligne.

Le « pick » est le cœur d'un salon de football : il décide qui joue, dans quelle équipe et qui attend. Sur cette page, vous découvrez les règles et le code de pick.ts du projet d'exemple, et à la fin des idées pour le personnaliser.

Les règles

  1. Qui entre va dans la file (en spectateur).
  2. Le 1er de la file devient capitaine des bleus ; le 2e, capitaine des rouges.
  3. Pour compléter les équipes, le capitaine de la plus petite équipe (égalité : bleu) tape le numéro du joueur qu'il veut. Sans réponse en 30 s, c'est le premier de la liste. S'il ne reste qu'un candidat, il entre sans choix.
  4. Des équipes toujours égales. Avec 3 joueurs et des équipes de 2, on joue en 1v1 et un attend. Jamais de 2v1.
  5. Le gagnant reste en bleu. Toute l'équipe perdante va en fin de file et le 1er de la file devient le nouveau capitaine rouge.
  6. Quelqu'un est parti ou est passé AFK en plein match ? Le match s'arrête et les équipes sont refaites.

Un exemple avec des équipes de 2 et Eva qui attend :

text
bleu : Ana, Carla     rouge : Bruno, Diego     file : Eva
> les rouges gagnent
bleu : Bruno, Diego   rouge : Eva (capitaine)  file : Ana, Carla
> Eva tape : 2   (Carla)
bleu : Bruno, Diego   rouge : Eva, Carla       file : Ana

L'état : quatre listes et une phase

Tout ce dont le pick doit se souvenir tient en quelques variables (fila = file, azul = bleu, vermelho = rouge, fase = phase) :

ts
private fila: number[] = [];          // ids des spectateurs, par ordre d'arrivée
private readonly afk = new Set<number>();
private azul: number[] = [];          // le premier de chaque équipe est le capitaine
private vermelho: number[] = [];
private fase: 'lobby' | 'escolhendo' | 'jogando' = 'lobby';   // lobby | choix en cours | en jeu

Les joueurs sont gardés par id (un numéro que bonk.io donne à chacun dans le salon), jamais par nom : deux invités peuvent avoir le même nom.

Le cœur : atualizar()

Chaque fois que quelque chose change (quelqu'un entre, sort, un choix est fait, le match se termine), le pick appelle atualizar() (« mettre à jour »). Il fait trois étapes :

ts
private atualizar(): void {
  if (this.fase !== 'lobby') return;
  // 1) capitaines
  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) complète les équipes : le capitaine de la plus petite équipe choisit
  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;          // les deux équipes sont pleines
    if (this.fila.length === 1) { this.lista(time).push(this.fila.shift()!); continue; }
    this.pedirEscolha(time);                              // attend que le capitaine choisisse
    return;
  }
  // 3) la règle d'or : des équipes de même taille
  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();
}

L'étape 3 est ce qui garantit « pas de 2v1 » : si une équipe est devenue plus grande, le surplus retourne en tête de file (il ne perd pas son tour).

Le choix par numéro

pedirEscolha() (« demander un choix ») annonce la liste et attend. Quand le capitaine dont c'est le tour écrit dans le chat, sala.ts passe le message à pick.mensagem() avant toute commande :

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, ''));   // accepte "2" et "!pick 2"
  const escolhido = Number.isInteger(n) ? this.fila[n - 1] : undefined;
  if (escolhido === undefined) return false;
  this.escolher(escolhido);
  return true;
}

Si le capitaine sort ou si quelqu'un de la liste passe AFK pendant le choix, la liste a changé et le choix recommence (recomecarEscolha()). Sans ça, le numéro tapé pourrait désigner une autre personne.

Démarrer le match avec le bon état

bonk.io a besoin d'un état initial (l'« IS blob ») avec un disque par joueur. Le ScoreTracker génère cet état avec la physique du jeu elle-même, pour n'importe quel nombre de joueurs :

ts
this.pick = new Pick(room, config.tamanhoTime, async (escalacao) => {
  const is = await this.tracker.buildInitialState(escalacao);
  if (!is) return false;          // le pick réessaie dans 3 s
  room.startGame({ is });
  return true;
});

L'escalacao (« composition ») est une liste indexée par id : [ , {id:1,team:3}, {id:2,team:2}]. Plus de détails dans Matchs, IS blob et spectateurs.

Fin du match

Le ScoreTracker émet match-winner. sala.ts attend 4 secondes (l'écran de victoire du jeu) et appelle pick.fimDePartida(équipe) (« fin de match ») :

ts
fimDePartida(vencedor: number): void {
  const perdedores = vencedor === TEAM_BLUE ? this.vermelho : this.azul;
  this.fila.push(...perdedores);                                   // fin de file
  this.azul = vencedor === TEAM_BLUE ? this.azul : this.vermelho;  // le gagnant reste en bleu
  this.vermelho = [];                                              // le 1er de la file devient capitaine
  this.pararPartida();
  this.atualizar();
}

AFK

  • !afk l'active et le désactive. Qui est en train de jouer ne peut pas passer AFK (ce serait un moyen facile de fuir un match perdu).
  • L'anti-AFK de la bibliothèque (room.enableAntiAfk()) émet player-afk quand quelqu'un passe 12 s sans bouger ni parler pendant le match. Le pick arrête le match, envoie la personne en AFK et refait les équipes. Voir Anti-AFK.

Le code complet

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

type Fase = 'lobby' | 'escolhendo' | 'jogando';
/** Qui joue le prochain match : indice = id du joueur (le format attendu par le ScoreTracker). */
export type Escalacao = Array<{ id: number; team: number } | null>;

const TEMPO_ESCOLHA_MS = 30_000;

/**
 * Système de pick : file d'attente, capitaines qui choisissent par numéro, le gagnant reste en bleu
 * et aucun match ne commence avec des équipes inégales (pas de 2v1).
 */
export class Pick {
  private fila: number[] = []; // spectateurs, par ordre d'arrivée
  private readonly afk = new Set<number>();
  private azul: number[] = []; // le premier de chaque équipe est le capitaine
  private vermelho: number[] = [];
  private fase: Fase = 'lobby';
  private vez: number | null = null; // équipe du capitaine qui choisit
  private timer: NodeJS.Timeout | null = null;

  constructor(
    private readonly room: BonkRoom,
    /** Joueurs par équipe (1 = 1v1, 2 = 2v2...). */
    private readonly n: number,
    /** Qui lance vraiment le match (génère l'état initial et appelle 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: partie terminée, refazendo os times');
      this.pararPartida();
    }
    this.recomecarEscolha();
  }

  /** Le capitaine dont c'est le tour a écrit dans le chat. Renvoie true si c'était un choix. */
  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 : active/désactive. Renvoie la réponse pour le 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`;
  }

  /** L'anti-AFK a repéré quelqu'un d'immobile en plein match. */
  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 match : à appeler après l'écran de victoire. Le perdant va en fin de file et le gagnant reste en bleu. */
  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();
  }

  // ── le cœur : forme les équipes et lance dès que possible ─────────────────────

  private atualizar(): void {
    if (this.fase !== 'lobby') return;
    // 1) capitaines : le premier de la file va en bleu, le second en rouge
    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) complète les équipes : le capitaine de la plus petite équipe choisit (égalité : bleu)
    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; // les deux équipes sont pleines
      if (this.fila.length === 1) {
        this.lista(time).push(this.fila.shift()!); // un seul candidat : il entre sans choix
        continue;
      }
      this.pedirEscolha(time);
      return;
    }
    // 3) la règle d'or : les deux équipes de la MÊME taille (le surplus retourne en tête de file)
    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(); // seul le bot déplace les joueurs
    const ok = await this.iniciar(escalacao).catch(() => false);
    if (!ok && this.fase === 'jogando') {
      this.fase = 'lobby';
      setTimeout(() => this.atualizar(), 3_000); // réessaie dans un instant
    }
  }

  private pararPartida(): void {
    this.fase = 'lobby';
    this.room.stopGame();
    // Le serveur ne renvoie pas GAME_END à celui qui a arrêté le match : on prévient nos propres écouteurs.
    this.room.emit('game-end', { type: 'GAME_END' });
  }

  /** Quelqu'un est parti ou passé AFK pendant le choix : la liste a changé, donc le choix recommence. */
  private recomecarEscolha(): void {
    if (this.fase === 'escolhendo') {
      this.limparTimer();
      this.fase = 'lobby';
      this.vez = null;
    }
    this.atualizar();
  }

  /** Place chaque joueur dans l'équipe décidée par le pick (n'envoie que ce qui a changé). */
  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();
  }
}

Idées pour personnaliser

IdéeOù modifier
Roi du terrain : qui gagne 3 fois de suite sort pour laisser la placeComptez les victoires dans fimDePartida() et envoyez l'équipe dans la file
Passe-droit pour les VIP (!furarfila)Une commande qui déplace l'id en tête de fila
Équipes tirées au sort au lieu d'être choisiesDans pedirEscolha(), tirez au sort au lieu d'attendre le numéro
Arrêter le match quand assez de monde arrive pour passer de 1v1 à 2v2Dans entrou(), si jogando et que les équipes sont sous n avec assez de monde en file, appelez pararPartida()
Temps de choix plus courtTEMPO_ESCOLHA_MS