Use a IA

Colocar a IA na sua sala

Faça a conta da sala jogar com a IA: observação, rede, decisão sem zigue-zague, os "olhos" sem atraso e uma sala "desafie a IA" completa.

Aqui a conta que hospeda a sala entra em campo e joga com a IA. Tudo roda em Node, junto da sala, sem Python. O código está no projeto de exemplo, pasta src/ia/.

O jeito mais rápido

  1. Baixe o projeto de exemplo e o modelo. Coloque o football-1x1.policy.json na pasta do projeto.
  2. No .env: MODO=ia (e, se quiser, IA_MODELO=caminho/do/modelo.json).
  3. npm run dev, entre na sala e desafie a IA.

Quem entra vai para uma fila; a IA joga de azul contra o primeiro da fila. Quem vence a IA continua; quem perde volta para o fim da fila.

Como funciona, peça por peça

text
ScoreTracker "olhos" (sem atraso) ──'state' a cada 100 ms──► JogadorIA
                                                                 │ buildObs()  → 39 números
                                                                 │ policy.logits() → 18 notas
                                                                 │ decide()    → ação, sem zigue-zague
                                                                 │ actionToBits() → teclas (espelhadas se vermelho)
                                                                 ▼
                                    room.sendInput(teclas) ──► servidor do bonk.io ──► jogadores
                                    tracker.recordOwnInput()   (a simulação local também precisa saber)

1. A observação: features.ts

É a parte mais delicada: precisa ser idêntica à do treino. Não mexa nela sem conferir com os casos de teste.

ts
// features.ts
/**
 * Observação e ações da IA de football da BonkTools — exatamente como ela foi treinada.
 *
 * Qualquer diferença (uma escala, um sinal, um campo ausente tratado de outro jeito) faz a IA jogar mal
 * SEM erro nenhum. Confira a sua versão com os casos de teste publicados junto com o modelo.
 *
 * Eixo canônico: o bot sempre "ataca pra direita". Jogando de vermelho (ataca pra esquerda), x e as
 * velocidades em x são espelhados na observação e esquerda/direita são trocadas na ação.
 *
 * Versões da observação (a política diz qual usa em `obsVersion`/`obsSize`): v1 = 25 números; v2 = 39 (v1 + traves,
 * paredes, alinhamento bola-gol e velocidade da bola em relação ao bot). 
 */

export const TEAM_RED = 2;
export const TEAM_BLUE = 3;

const CENTER_X = 33.18;
const CENTER_Y = 22.73;
const HALF_W = 33.0;
const HALF_H = 22.7;
const GOAL_X = 64.0;
const OWN_GOAL_X = 2 * CENTER_X - GOAL_X;
const PLAYER_MAX_SPEED = 11.7;
const BALL_MAX_SPEED = 20.0;

export const LEFT = 1;
export const RIGHT = 2;
export const UP = 4;
export const DOWN = 8;
export const KICK = 16;

const DIRS = [0, UP, UP | RIGHT, RIGHT, DOWN | RIGHT, DOWN, DOWN | LEFT, LEFT, UP | LEFT];
/** 9 direções (incl. parado) x {sem chute, chute} — mesma ordem do treino. */
export const ACTION_TABLE: readonly number[] = [...DIRS, ...DIRS.map((d) => d | KICK)];
/** Tamanho da observação por versão. 101 = a do goleiro treinado por RL (goleiro-rl.ts). */
export const OBS_SIZES: Readonly<Record<number, number>> = { 1: 25, 2: 39, 101: 27 };
export const OBS_SIZE = OBS_SIZES[1]!;

// Geometria da v2 (eixo canônico).
const POST_X = 64.09;
const POST_Y_TOP = CENTER_Y - 6.5;
const POST_Y_BOTTOM = CENTER_Y + 6.5;
const PLAYER_X_MIN = 1.0;
const PLAYER_X_MAX = 65.36;
const PLAYER_Y_MIN = 1.0;
const PLAYER_Y_MAX = 44.45;
const BALL_Y_MIN = 7.79;
const BALL_Y_MAX = 37.67;

/** Versão da observação pelo tamanho da entrada da rede (25 -> 1, 39 -> 2); null se não existir. */
export function versionForSize(size: number): number | null {
  for (const [v, n] of Object.entries(OBS_SIZES)) if (n === size) return Number(v);
  return null;
}

export function mirrorBits(bits: number): number {
  let rest = bits & ~(LEFT | RIGHT);
  if (bits & LEFT) rest |= RIGHT;
  if (bits & RIGHT) rest |= LEFT;
  return rest;
}

export function actionToBits(action: number, mirror: boolean): number {
  const bits = ACTION_TABLE[action] ?? 0;
  return mirror ? mirrorBits(bits) : bits;
}

/** O time ataca pra esquerda (vermelho) — precisa espelhar pro eixo canônico. */
export function teamMirror(team: number): boolean {
  return team === TEAM_RED;
}

interface Body {
  x: number;
  y: number;
  xv: number;
  yv: number;
  kickReady?: boolean;
}

const ZERO: Body = { x: CENTER_X, y: CENTER_Y, xv: 0, yv: 0, kickReady: false };

/** null/undefined e objeto VAZIO contam como ausentes (igual ao treino em Python). */
function isBody(v: unknown): v is Body {
  return !!v && typeof v === 'object' && Object.keys(v).length > 0;
}

/** Estado do ScoreTracker/PhysicsSimulator (ball, discs[], ftu). Ausente = centro do campo parado. */
export interface GameStateLike {
  ball?: unknown;
  discs?: unknown;
  ftu?: unknown;
}

function ball(state: GameStateLike): Body {
  return isBody(state.ball) ? state.ball : ZERO;
}

function disc(state: GameStateLike, id: number): Body {
  const discs = Array.isArray(state.discs) ? state.discs : [];
  const d: unknown = id >= 0 && id < discs.length ? discs[id] : null;
  return isBody(d) ? d : ZERO;
}

function canon(b: Body, mirror: boolean): [number, number, number, number] {
  return mirror ? [2 * CENTER_X - b.x, b.y, -b.xv, b.yv] : [b.x, b.y, b.xv, b.yv];
}

const clip = (v: number): number => Math.min(2, Math.max(-2, v));

/**
 * Projeta o estado `leadFrames` quadros (30/s) À FRENTE: posições += velocidade × tempo (sem colisões) e o relógio de
 * congelamento da saída de bola (`ftu`) adiantado.
 *
 * A simulação local da sala roda de propósito 6 quadros (200 ms) atrás do relógio, para as teclas atrasadas da rede
 * chegarem (e o placar automático não anunciar gol que uma tecla atrasada desfaria). O bot decidia sobre esse passado:
 * no simulador, com 200 ms de atraso a IA perdia TODAS as saídas de bola para um atacante que chuta de primeira;
 * projetando, voltou a não sofrer gol de saída.
 */
export function projectState(state: GameStateLike, leadFrames: number): GameStateLike {
  if (!(leadFrames > 0)) return state;
  const dt = leadFrames / 30;
  const move = (v: unknown): unknown => {
    if (!isBody(v)) return v;
    const b = v as Body & Record<string, unknown>;
    return { ...b, x: b.x + b.xv * dt, y: b.y + b.yv * dt };
  };
  const out: GameStateLike = { ...state, ball: move(state.ball) };
  if (Array.isArray(state.discs)) out.discs = state.discs.map(move);
  if (typeof state.ftu === 'number' && state.ftu > 0) out.ftu = Math.max(state.ftu - leadFrames, 0);
  return out;
}

function unit(dx: number, dy: number): [number, number] {
  const n = Math.hypot(dx, dy);
  return n > 1e-6 ? [dx / n, dy / n] : [0, 0];
}

/** Observação (float32 como no NumPy) do ponto de vista de `selfId`, na versão `version` (1 = 25, 2 = 39 números). */
export function buildObs(
  state: GameStateLike,
  selfId: number,
  oppId: number,
  mirror: boolean,
  version = 1,
): Float32Array {
  const v1 = buildObsV1(state, selfId, oppId, mirror);
  if (version === 1) return v1;
  if (version !== 2) throw new Error(`versão de observação desconhecida: ${version}`);
  const out = new Float32Array(OBS_SIZES[2]!);
  out.set(v1);
  out.set(extraV2(state, selfId, mirror), v1.length);
  return out;
}

function extraV2(state: GameStateLike, selfId: number, mirror: boolean): Float32Array {
  const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
  const [bx, by, bxv, byv] = canon(ball(state), mirror);
  const ownX = 2 * CENTER_X - POST_X;
  const [ax, ay] = unit(bx - sx, by - sy);
  const [gx, gy] = unit(POST_X - bx, CENTER_Y - by);
  const [dx, dy] = unit(sx - bx, sy - by);
  const [ox, oy] = unit(ownX - bx, CENTER_Y - by);
  const values = [
    (POST_X - sx) / HALF_W, (POST_Y_TOP - sy) / HALF_H, (POST_Y_BOTTOM - sy) / HALF_H, (sx - ownX) / HALF_W,
    (sx - PLAYER_X_MIN) / HALF_W, (PLAYER_X_MAX - sx) / HALF_W,
    (sy - PLAYER_Y_MIN) / HALF_H, (PLAYER_Y_MAX - sy) / HALF_H,
    (by - BALL_Y_MIN) / HALF_H, (BALL_Y_MAX - by) / HALF_H,
    ax * gx + ay * gy, dx * ox + dy * oy,
    (bxv - sxv) / BALL_MAX_SPEED, (byv - syv) / BALL_MAX_SPEED,
  ];
  const out = new Float32Array(values.length);
  for (let i = 0; i < values.length; i++) out[i] = clip(Math.fround(values[i]!));
  return out;
}

function buildObsV1(state: GameStateLike, selfId: number, oppId: number, mirror: boolean): Float32Array {
  const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
  const [ox, oy, oxv, oyv] = canon(disc(state, oppId), mirror);
  const [bx, by, bxv, byv] = canon(ball(state), mirror);
  // Python: `state.get("ftu", -1) or 0` — ausente vira -1; 0/None viram 0.
  const rawFtu = state.ftu === undefined ? -1 : typeof state.ftu === 'number' ? state.ftu : 0;

  const px = (x: number): number => (x - CENTER_X) / HALF_W;
  const py = (y: number): number => (y - CENTER_Y) / HALF_H;
  const dSelf = Math.hypot(bx - sx, by - sy);
  const dOpp = Math.hypot(bx - ox, by - oy);

  const values = [
    px(sx), py(sy), sxv / PLAYER_MAX_SPEED, syv / PLAYER_MAX_SPEED,
    px(bx), py(by), bxv / BALL_MAX_SPEED, byv / BALL_MAX_SPEED,
    px(ox), py(oy), oxv / PLAYER_MAX_SPEED, oyv / PLAYER_MAX_SPEED,
    (bx - sx) / HALF_W, (by - sy) / HALF_H,
    (bx - ox) / HALF_W, (by - oy) / HALF_H,
    (GOAL_X - bx) / HALF_W, (CENTER_Y - by) / HALF_H,
    (bx - OWN_GOAL_X) / HALF_W, (by - CENTER_Y) / HALF_H,
    dSelf / HALF_W, dOpp / HALF_W,
    disc(state, selfId).kickReady ? 1 : 0,
    disc(state, oppId).kickReady ? 1 : 0,
    Math.min(Math.max(rawFtu, 0), 120) / 120,
  ];
  // np.array(..., dtype=float32) arredonda cada valor pra float32 ANTES do clip (que compara em float32).
  const out = new Float32Array(OBS_SIZE);
  for (let i = 0; i < OBS_SIZE; i++) out[i] = clip(Math.fround(values[i]!));
  return out;
}

2. A rede e a decisão: policy.ts

Lê o policy.json, roda as três camadas e decide eixo a eixo (veja por quê em Baixar o modelo).

ts
// policy.ts
import { readFileSync } from 'node:fs';
import { ACTION_TABLE, DOWN, KICK, LEFT, OBS_SIZES, RIGHT, UP, versionForSize } from './features.js';

/**
 * A rede da IA (o policy.json publicado), rodando em JS puro — sem Python nem PyTorch na máquina da sala. MLP pequena: obs(25 na v1, 39 na v2 — `obsVersion`) -> 256 -> tanh -> 256 -> tanh -> 18 logits;
 * a ação é o argmax (a jogada mais provável). Pesos em float32 base64.
 */

export const POLICY_FORMAT = 'bonktools-rl-policy/1';

interface LayerJson {
  in: number;
  out: number;
  w: string;
  b: string;
}

export interface PolicyJson {
  format: string;
  obsSize: number;
  /** Versão da observação (features.ts). Ausente nas políticas antigas: sai do obsSize. */
  obsVersion?: number;
  actionTable: number[];
  activation: string;
  layers: LayerJson[];
  timesteps?: number;
  exportedAt?: string;
}

interface Layer {
  inSize: number;
  outSize: number;
  /** out x in, linha a linha (mesmo layout do `weight` do PyTorch). */
  w: Float32Array;
  b: Float32Array;
}

function floats(b64: string, expected: number, what: string): Float32Array {
  const buf = Buffer.from(b64, 'base64');
  if (buf.length !== expected * 4) throw new Error(`política inválida: ${what} tem ${buf.length / 4} valores, esperado ${expected}`);
  // Copia pra um buffer alinhado (o do base64 pode começar num offset qualquer).
  const out = new Float32Array(expected);
  for (let i = 0; i < expected; i++) out[i] = buf.readFloatLE(i * 4);
  return out;
}

export class Policy {
  readonly timesteps: number;
  readonly exportedAt: string;
  /** Versão da observação que esta rede espera (passar para `buildObs`). */
  readonly obsVersion: number;
  private readonly layers: Layer[];

  constructor(json: PolicyJson) {
    if (json.format !== POLICY_FORMAT) throw new Error(`formato de política desconhecido: ${String(json.format)}`);
    if (json.activation !== 'tanh') throw new Error(`ativação não suportada: ${json.activation}`);
    const version = json.obsVersion ?? versionForSize(json.obsSize);
    if (version === null || OBS_SIZES[version] !== json.obsSize) {
      throw new Error(`política espera ${json.obsSize} entradas (versão ${String(json.obsVersion ?? '?')}); a sala não conhece essa observação`);
    }
    this.obsVersion = version;
    if (json.actionTable.length !== ACTION_TABLE.length || json.actionTable.some((v, i) => v !== ACTION_TABLE[i])) {
      throw new Error('tabela de ações da política não bate com a da sala (features.ts)');
    }
    this.layers = json.layers.map((l, i) => ({
      inSize: l.in,
      outSize: l.out,
      w: floats(l.w, l.in * l.out, `camada ${i} (pesos)`),
      b: floats(l.b, l.out, `camada ${i} (bias)`),
    }));
    for (let i = 1; i < this.layers.length; i++) {
      if (this.layers[i]!.inSize !== this.layers[i - 1]!.outSize) throw new Error(`política inválida: camada ${i} não encaixa na anterior`);
    }
    if (this.layers[0]?.inSize !== json.obsSize || this.layers.at(-1)?.outSize !== ACTION_TABLE.length) {
      throw new Error('política inválida: entrada/saída não batem com a observação/ações');
    }
    this.timesteps = json.timesteps ?? 0;
    this.exportedAt = json.exportedAt ?? '';
  }

  static fromFile(file: string): Policy {
    return new Policy(JSON.parse(readFileSync(file, 'utf8')) as PolicyJson);
  }

  /** Logits de cada ação (tanh nas camadas escondidas, linear na última). */
  logits(obs: ArrayLike<number>): Float64Array {
    let x: ArrayLike<number> = obs;
    for (let li = 0; li < this.layers.length; li++) {
      const { inSize, outSize, w, b } = this.layers[li]!;
      const y = new Float64Array(outSize);
      for (let o = 0; o < outSize; o++) {
        let s = b[o]!;
        const row = o * inSize;
        for (let i = 0; i < inSize; i++) s += w[row + i]! * x[i]!;
        y[o] = li < this.layers.length - 1 ? Math.tanh(s) : s;
      }
      x = y;
    }
    return x as Float64Array;
  }

  /** Ação determinística (índice em ACTION_TABLE): argmax puro. Ao vivo usa-se `decide` (sem zigue-zague). */
  act(obs: ArrayLike<number>): number {
    const l = this.logits(obs);
    let best = 0;
    for (let i = 1; i < l.length; i++) if (l[i]! > l[best]!) best = i;
    return best;
  }
}

/** Margens da decisão eixo a eixo (medidas no simulador). */
export const AXIS_MARGIN = 0.25;
export const FLIP_MARGIN = 0.7;

function axis(pPos: number, pNeg: number, prev: number): number {
  const diff = pPos - pNeg;
  const needPos = prev < 0 ? FLIP_MARGIN : AXIS_MARGIN;
  const needNeg = prev > 0 ? FLIP_MARGIN : AXIS_MARGIN;
  if (diff > needPos) return 1;
  if (-diff > needNeg) return -1;
  return 0;
}

/**
 * Decide a jogada EIXO A EIXO a partir dos logits
 * O argmax das 18 ações alternava "diagonal pra cima"/"diagonal pra baixo" quase empatadas a cada decisão: o bot
 * andava em zigue-zague e nunca reto (42 inversões/min em partidas reais; humanos, ~1). Aqui cada eixo
 * vem da probabilidade somada de cada lado; empate = nenhuma tecla daquele eixo (anda reto), e inverter o sentido
 * anterior exige vantagem maior (histerese). Chute se P(chute) > 0,5.
 */
export function decide(logits: ArrayLike<number>, prevAction: number | null): number {
  let max = -Infinity;
  for (let i = 0; i < logits.length; i++) max = Math.max(max, logits[i]!);
  const p = new Float64Array(logits.length);
  let sum = 0;
  for (let i = 0; i < logits.length; i++) sum += p[i] = Math.exp(logits[i]! - max);
  let up = 0, down = 0, left = 0, right = 0, kick = 0;
  for (let i = 0; i < p.length; i++) {
    const q = p[i]! / sum;
    const b = ACTION_TABLE[i]!;
    if (b & UP) up += q;
    if (b & DOWN) down += q;
    if (b & LEFT) left += q;
    if (b & RIGHT) right += q;
    if (b & KICK) kick += q;
  }
  const pb = prevAction === null ? 0 : ACTION_TABLE[prevAction] ?? 0;
  const v = axis(down, up, pb & UP ? -1 : pb & DOWN ? 1 : 0); // +1 = baixo (y cresce pra baixo)
  const h = axis(right, left, pb & RIGHT ? 1 : pb & LEFT ? -1 : 0);
  let bits = (v > 0 ? DOWN : v < 0 ? UP : 0) | (h > 0 ? RIGHT : h < 0 ? LEFT : 0);
  if (kick > 0.5) bits |= KICK;
  return ACTION_TABLE.indexOf(bits);
}

3. O jogador: jogador-ia.ts

ts
// jogador-ia.ts
import type { BonkRoom, ScoreTracker, StateInfo } from 'bonktools';
import { actionToBits, buildObs, projectState, teamMirror } from './features.js';
import { decide, type Policy } from './policy.js';

/**
 * Faz o bot (a conta que hospeda a sala) JOGAR com a IA: a cada estado novo da simulação (100 ms),
 * monta a observação, roda a rede e aperta as teclas.
 */
export class JogadorIA {
  private partida: { eu: number; adversario: number; espelho: boolean } | null = null;
  private ultimasTeclas = -1; // última combinação enviada (só mandamos quando muda, como um teclado de verdade)
  private ultimaAcao: number | null = null; // a decisão eixo a eixo compara com a anterior (evita zigue-zague)

  constructor(
    private readonly room: BonkRoom,
    /** O ScoreTracker da sala (placar): a tecla do próprio bot precisa entrar nele. */
    private readonly placar: ScoreTracker,
    private readonly policy: Policy,
    /**
     * "Olhos" sem atraso (opcional): um 2º ScoreTracker com lagFrames 0. Sem ele, a IA vê o estado
     * do placar, que fica 200 ms no passado, e nós projetamos esse estado para o presente.
     */
    private readonly olhos?: ScoreTracker,
    /** Avisa cada tecla enviada (o gravador de replays precisa dela). */
    private readonly aoTeclar?: (id: number, k: { i: number; f: number; c: number }) => void,
  ) {
    (olhos ?? placar).on('state', this.aoEstado);
  }

  /** `time`: 3 = azul (ataca para a direita), 2 = vermelho (a IA espelha o campo). */
  comecar(eu: number, adversario: number, time: number): void {
    this.partida = { eu, adversario, espelho: teamMirror(time) };
    this.ultimasTeclas = -1;
    this.ultimaAcao = null;
  }

  parar(): void {
    this.partida = null;
    this.enviar(0); // solta todas as teclas
  }

  private readonly aoEstado = ({ state }: StateInfo): void => {
    const p = this.partida;
    if (!p || !state || typeof state !== 'object') return;
    // sem "olhos", o estado está 6 frames (200 ms) atrás: projeta para agora
    const visto = this.olhos ? state : projectState(state, 6);
    const obs = buildObs(visto, p.eu, p.adversario, p.espelho, this.policy.obsVersion);
    const acao = decide(this.policy.logits(obs), this.ultimaAcao);
    this.ultimaAcao = acao;
    this.enviar(actionToBits(acao, p.espelho));
  };

  private enviar(teclas: number): void {
    if (teclas === this.ultimasTeclas || this.partida === null && teclas !== 0) return;
    this.ultimasTeclas = teclas;
    const eu = this.partida?.eu ?? this.room.state.myId;
    if (eu === null) return;
    const k = this.room.sendInput(teclas);
    // O servidor não devolve ao host a tecla que ele mesmo mandou: sem isto, a simulação local
    // acharia que o bot está parado e a IA "veria" um jogo diferente do real.
    this.placar.recordOwnInput(eu, k.i, k.f, k.c);
    this.olhos?.recordOwnInput(eu, k.i, k.f, k.c);
    this.aoTeclar?.(eu, k);
  }

  destroy(): void {
    (this.olhos ?? this.placar).off('state', this.aoEstado);
    this.partida = null;
  }
}

Três detalhes que fazem toda a diferença:

  • recordOwnInput. O servidor não devolve ao host a tecla que ele mesmo mandou. Sem registrar na simulação local, ela acharia o bot parado e a IA passaria a "ver" um jogo diferente do real.
  • Só manda tecla quando muda, como um teclado de verdade. Mandar a cada 100 ms incha o histórico que quem entra no meio da partida recebe.
  • Solta tudo no fim (parar() manda 0), senão o disco do bot fica andando sozinho na próxima partida.

4. Os "olhos": por que dois ScoreTrackers

O ScoreTracker do placar roda de propósito 200 ms atrás do relógio: espera as teclas atrasadas da rede para nunca anunciar um gol que não aconteceu. Ótimo para o placar, péssimo para jogar: a IA estaria decidindo sobre o passado.

Por isso a sala "desafie a IA" cria um segundo ScoreTracker com lagFrames: 0: os "olhos". Ele simula até o instante atual e, quando uma tecla atrasada chega, volta e refaz o trecho.

Configuração da salaTreine comResultado medido (100 lances contra o script mais forte)
Com "olhos" (lagFrames: 0), sem projeção--visao agora (padrão)95 gols, 2 sofridos
Só o placar (200 ms atrás) + projectState(estado, 6)--visao atrasada68 gols, 13 sofridos

5. A sala "desafie a IA": sala-ia.ts

ts
// sala-ia.ts
import { ScoreTracker, TEAM_BLUE, TEAM_RED, TEAM_SPEC, type BonkRoom } from 'bonktools';
import { falar } from '../chat.js';
import { JogadorIA } from './jogador-ia.js';
import { Policy } from './policy.js';

/** Sala "desafie a IA": a IA fica no azul e cada jogador da fila joga contra ela. Quem vence continua. */
export class SalaIA {
  private readonly placar: ScoreTracker;
  private readonly olhos: ScoreTracker;
  private readonly ia: JogadorIA;
  private fila: number[] = [];
  private adversario: number | null = null;
  private timer: NodeJS.Timeout | null = null;

  constructor(private readonly room: BonkRoom, arquivoModelo = 'football-1x1.policy.json') {
    this.placar = new ScoreTracker(room, { cacheDir: '.cache/bonk-client' });
    this.olhos = new ScoreTracker(room, { cacheDir: '.cache/bonk-client', lagFrames: 0 });
    this.ia = new JogadorIA(room, this.placar, Policy.fromFile(arquivoModelo), this.olhos);

    room.on('player-join', (p) => {
      this.fila.push(p.id);
      falar(room, `${p.userName}, você está na fila para desafiar a IA (posição ${this.fila.length})`);
      this.proxima();
    });
    room.on('player-leave', (p) => {
      this.fila = this.fila.filter((id) => id !== p.id);
      if (p.id === this.adversario) this.encerrar(null);
    });
    this.placar.on('score', ({ scores }) => falar(room, `IA ${scores[TEAM_BLUE]} x ${scores[TEAM_RED]} desafiante`));
    this.placar.on('match-winner', ({ team }) => {
      falar(room, team === TEAM_BLUE ? 'a IA venceu!' : 'você venceu a IA!');
      this.timer = setTimeout(() => this.encerrar(team), 4_000); // depois da tela de vitória
    });
    void this.placar.start();
    void this.olhos.start();
    room.lockTeams();
  }

  private proxima(): void {
    const eu = this.room.state.myId;
    if (this.adversario !== null || !this.fila.length || eu === null) return;
    const adv = this.fila[0]!;
    this.adversario = adv;
    for (const id of this.room.state.players.keys()) {
      this.room.setTeam(id, id === eu ? TEAM_BLUE : id === adv ? TEAM_RED : TEAM_SPEC);
    }
    setTimeout(async () => {
      const escalacao: Array<{ id: number; team: number } | null> = [];
      escalacao[eu] = { id: eu, team: TEAM_BLUE };
      escalacao[adv] = { id: adv, team: TEAM_RED };
      const is = await this.placar.buildInitialState(escalacao);
      if (!is || this.adversario !== adv) return void this.encerrar(null);
      this.room.startGame({ is });
      this.ia.comecar(eu, adv, TEAM_BLUE);
    }, 1_000); // dá tempo das trocas de time chegarem ao servidor
  }

  /** Fim da partida. `vencedor` null = cancelada. Quem perdeu para a IA vai para o fim da fila. */
  private encerrar(vencedor: number | null): void {
    const adv = this.adversario;
    this.adversario = null;
    this.ia.parar();
    this.room.stopGame();
    this.room.emit('game-end', { type: 'GAME_END' });
    if (adv !== null && vencedor === TEAM_BLUE && this.fila.includes(adv)) {
      this.fila = [...this.fila.filter((id) => id !== adv), adv];
    }
    setTimeout(() => this.proxima(), 2_000);
  }

  destroy(): void {
    if (this.timer) clearTimeout(this.timer);
    this.ia.destroy();
    this.placar.stop();
    this.olhos.stop();
  }
}

Para o bot entrar em campo, ele se coloca num time (room.setTeam(eu, TEAM_BLUE)) e o estado inicial é gerado com ele na escalação, como qualquer jogador.

Gravando as partidas da IA

Se usar o gravador junto, passe as teclas do bot para ele (o peer-input não traz as do próprio host):

ts
const gravador = new Gravador(room, placar);
const ia = new JogadorIA(room, placar, policy, olhos, (id, tecla) => gravador.teclaPropria(id, tecla));

Trocar o modelo sem reiniciar a sala

Nas salas da BonkTools o modelo era trocado com a sala cheia: a cada minuto o bot conferia a data do arquivo e, se mudou, carregava o novo (mantendo o antigo se o novo estivesse quebrado). É uma boa ideia se você for treinar e atualizar com frequência:

ts
let mtime = 0;
setInterval(() => {
  const m = statSync(arquivo).mtimeMs;
  if (m === mtime) return;
  try { policy = Policy.fromFile(arquivo); mtime = m; } catch { /* arquivo inválido: segue com o atual */ }
}, 60_000);

Ideias

  • Dificuldade ajustável: com probabilidade p, troque a decisão por uma ação aleatória ou segure a tecla anterior por mais um tick. É assim que o adversário com script do treino tem "habilidade".
  • 2x2 com IA: dois JogadorIA não funcionam na mesma conta (uma conta = um jogador). Para dois bots, conecte uma segunda conta com joinRoom() e dê a ela o seu próprio JogadorIA. Os outros modelos (goleiro, mbappa) estão em Baixar os modelos.
  • Treinar com as partidas da sua sala: grave as partidas contra humanos e use os lances reais como cenários de treino. Foi o que mais ajudou a nossa IA a defender (veja O que aprendemos).