Eigener Raum

Pick-System

Warteschlange, Kapitäne wählen per Nummer, der Sieger bleibt und die Teams sind immer gleich groß. Zeile für Zeile erklärt.

Der „Pick“ ist das Herz eines Fußballraums: Er entscheidet, wer spielt, in welchem Team und wer wartet. Auf dieser Seite lernst du die Regeln und den Code von pick.ts aus dem Beispielprojekt kennen, und am Ende gibt es Ideen zum Anpassen.

Die Regeln

  1. Wer beitritt, kommt in die Warteschlange (als Zuschauer).
  2. Der 1. in der Warteschlange wird Kapitän von Blau; der 2. Kapitän von Rot.
  3. Zum Auffüllen der Teams tippt der Kapitän des kleineren Teams (Gleichstand: Blau) die Nummer des Spielers, den er will. Ohne Antwort in 30 s kommt der Erste der Liste. Bleibt nur ein Kandidat, kommt er ohne Wahl dazu.
  4. Teams immer gleich groß. Mit 3 Spielern und Teams zu je 2 wird 1v1 gespielt und einer wartet. Nie 2v1.
  5. Der Sieger bleibt Blau. Das ganze Verliererteam geht ans Ende der Warteschlange, und der Erste der Warteschlange wird neuer Kapitän von Rot.
  6. Jemand ist mitten im Spiel gegangen oder AFK? Das Spiel stoppt und die Teams werden neu gebildet.

Ein Beispiel mit Zweierteams und Eva in der Warteschlange:

text
Blau: Ana, Carla     Rot: Bruno, Diego      Warteschlange: Eva
> Rot gewinnt
Blau: Bruno, Diego   Rot: Eva (Kapitänin)   Warteschlange: Ana, Carla
> Eva tippt: 2   (Carla)
Blau: Bruno, Diego   Rot: Eva, Carla        Warteschlange: Ana

Der Zustand: vier Listen und eine Phase

Alles, was der Pick sich merken muss, passt in ein paar Variablen (fila = Warteschlange, azul = Blau, vermelho = Rot, fase = Phase):

ts
private fila: number[] = [];          // IDs der Zuschauer, in Reihenfolge der Ankunft
private readonly afk = new Set<number>();
private azul: number[] = [];          // der Erste jedes Teams ist der Kapitän
private vermelho: number[] = [];
private fase: 'lobby' | 'escolhendo' | 'jogando' = 'lobby';   // Lobby | Wahl läuft | Spiel läuft

Spieler werden über ihre ID gespeichert (eine Zahl, die bonk.io jedem im Raum gibt), nie über den Namen: Zwei Gäste können denselben Namen haben.

Das Herzstück: atualizar()

Jedes Mal, wenn sich etwas ändert (jemand tritt bei, geht, eine Wahl fällt, das Spiel endet), ruft der Pick atualizar() („aktualisieren“) auf. Es macht drei Schritte:

ts
private atualizar(): void {
  if (this.fase !== 'lobby') return;
  // 1) Kapitäne
  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) Teams auffüllen: der Kapitän des kleineren Teams wählt
  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;          // beide Teams sind voll
    if (this.fila.length === 1) { this.lista(time).push(this.fila.shift()!); continue; }
    this.pedirEscolha(time);                              // wartet, bis der Kapitän wählt
    return;
  }
  // 3) die goldene Regel: Teams gleicher Größe
  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();
}

Schritt 3 garantiert „kein 2v1“: Wurde ein Team größer, geht der Überzählige an den Anfang der Warteschlange zurück (er verliert seinen Platz nicht).

Wahl per Nummer

pedirEscolha() („Wahl anfordern“) verkündet die Liste und wartet. Wenn der Kapitän, der dran ist, in den Chat schreibt, gibt sala.ts die Nachricht vor jedem Befehl an pick.mensagem() weiter:

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

Geht der Kapitän oder wird jemand auf der Liste während der Wahl AFK, hat sich die Liste geändert und die Wahl beginnt neu (recomecarEscolha()). Sonst könnte die getippte Nummer auf eine andere Person zeigen.

Das Spiel mit dem richtigen Zustand starten

bonk.io braucht einen Anfangszustand (den „IS-Blob“) mit einer Scheibe pro Spieler. Der ScoreTracker erzeugt diesen Zustand mit der Physik des Spiels selbst, für jede Spielerzahl:

ts
this.pick = new Pick(room, config.tamanhoTime, async (escalacao) => {
  const is = await this.tracker.buildInitialState(escalacao);
  if (!is) return false;          // der Pick versucht es in 3 s erneut
  room.startGame({ is });
  return true;
});

Die escalacao („Aufstellung“) ist eine nach ID indizierte Liste: [ , {id:1,team:3}, {id:2,team:2}]. Mehr dazu in Spiele, IS-Blob und Zuschauer.

Spielende

Der ScoreTracker meldet match-winner. sala.ts wartet 4 Sekunden (den Siegbildschirm des Spiels) und ruft pick.fimDePartida(team) („Spielende“) auf:

ts
fimDePartida(vencedor: number): void {
  const perdedores = vencedor === TEAM_BLUE ? this.vermelho : this.azul;
  this.fila.push(...perdedores);                                   // ans Ende der Warteschlange
  this.azul = vencedor === TEAM_BLUE ? this.azul : this.vermelho;  // der Sieger bleibt Blau
  this.vermelho = [];                                              // der Erste der Warteschlange wird Kapitän
  this.pararPartida();
  this.atualizar();
}

AFK

  • !afk schaltet ein und aus. Wer gerade spielt, kann nicht AFK gehen (sonst könnte man leicht vor einem verlorenen Spiel fliehen).
  • Das Anti-AFK der Bibliothek (room.enableAntiAfk()) meldet player-afk, wenn jemand während des Spiels 12 s weder bewegt noch chattet. Der Pick stoppt das Spiel, schickt die Person ins AFK und bildet die Teams neu. Siehe Anti-AFK.

Der vollständige Code

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

type Fase = 'lobby' | 'escolhendo' | 'jogando';
/** Wer das nächste Spiel spielt: Index = Spieler-ID (das Format, das der ScoreTracker erwartet). */
export type Escalacao = Array<{ id: number; team: number } | null>;

const TEMPO_ESCOLHA_MS = 30_000;

/**
 * Pick-System: Warteschlange, Kapitäne wählen per Nummer, der Sieger bleibt Blau
 * und kein Spiel beginnt mit ungleichen Teams (kein 2v1).
 */
export class Pick {
  private fila: number[] = []; // Zuschauer, in Reihenfolge der Ankunft
  private readonly afk = new Set<number>();
  private azul: number[] = []; // der Erste jedes Teams ist der Kapitän
  private vermelho: number[] = [];
  private fase: Fase = 'lobby';
  private vez: number | null = null; // Team des Kapitäns, der gerade wählt
  private timer: NodeJS.Timeout | null = null;

  constructor(
    private readonly room: BonkRoom,
    /** Spieler pro Team (1 = 1v1, 2 = 2v2...). */
    private readonly n: number,
    /** Wer das Spiel tatsächlich startet (erzeugt den Anfangszustand und ruft room.startGame auf). */
    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 beendet, refazendo os times');
      this.pararPartida();
    }
    this.recomecarEscolha();
  }

  /** Der Kapitän am Zug hat etwas in den Chat geschrieben. Gibt true zurück, wenn es eine Wahl war. */
  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: schaltet um. Gibt die Antwort für den Chat zurück. */
  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`;
  }

  /** Das Anti-AFK hat jemanden mitten im Spiel untätig erwischt. */
  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();
  }

  /** Spielende: nach dem Siegbildschirm aufrufen. Der Verlierer geht ans Ende der Warteschlange, der Sieger bleibt Blau. */
  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();
  }

  // ── das Herzstück: bildet die Teams und startet, sobald es geht ───────────────

  private atualizar(): void {
    if (this.fase !== 'lobby') return;
    // 1) Kapitäne: der Erste der Warteschlange geht zu Blau, der Zweite zu Rot
    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) füllt die Teams: der Kapitän des kleineren Teams wählt (Gleichstand: Blau)
    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; // beide Teams sind voll
      if (this.fila.length === 1) {
        this.lista(time).push(this.fila.shift()!); // nur ein Kandidat: kommt ohne Wahl dazu
        continue;
      }
      this.pedirEscolha(time);
      return;
    }
    // 3) die goldene Regel: beide Teams GLEICH groß (wer übrig ist, geht an den Anfang der Warteschlange zurück)
    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(); // nur der Bot verschiebt Spieler
    const ok = await this.iniciar(escalacao).catch(() => false);
    if (!ok && this.fase === 'jogando') {
      this.fase = 'lobby';
      setTimeout(() => this.atualizar(), 3_000); // versucht es gleich noch einmal
    }
  }

  private pararPartida(): void {
    this.fase = 'lobby';
    this.room.stopGame();
    // Der Server schickt GAME_END nicht an den, der das Spiel gestoppt hat: wir benachrichtigen unsere eigenen Listener.
    this.room.emit('game-end', { type: 'GAME_END' });
  }

  /** Jemand ist während der Wahl gegangen oder AFK: die Liste hat sich geändert, also beginnt die Wahl neu. */
  private recomecarEscolha(): void {
    if (this.fase === 'escolhendo') {
      this.limparTimer();
      this.fase = 'lobby';
      this.vez = null;
    }
    this.atualizar();
  }

  /** Setzt jeden Spieler ins vom Pick bestimmte Team (sendet nur Änderungen). */
  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();
  }
}

Ideen zum Anpassen

IdeeWo ändern
König des Platzes: Wer 3-mal in Folge gewinnt, macht PlatzSiege in fimDePartida() zählen und das Team in die Warteschlange schicken
Vordrängeln für VIPs (!furarfila)Ein Befehl, der die ID an den Anfang von fila setzt
Ausgeloste statt gewählte TeamsIn pedirEscolha() losen, statt auf die Nummer zu warten
Das Spiel stoppen, wenn genug Leute für 2v2 statt 1v1 da sindIn entrou(): Wenn jogando und die Teams unter n liegen und genug in der Warteschlange sind, pararPartida() aufrufen
Kürzere WahlzeitTEMPO_ESCOLHA_MS