Usa la IA

Poner la IA en tu sala

Haz que la cuenta de la sala juegue con la IA: observación, red, decisión sin zigzag, los "ojos" sin retraso y una sala "desafía a la IA" completa.

Aquí la cuenta que aloja la sala entra al campo y juega con la IA. Todo corre en Node, junto a la sala, sin Python. El código está en el proyecto de ejemplo, carpeta src/ia/.

La forma más rápida

  1. Descarga el proyecto de ejemplo y el modelo. Pon el football-1x1.policy.json en la carpeta del proyecto.
  2. En el .env: MODO=ia (y, si quieres, IA_MODELO=ruta/del/modelo.json).
  3. npm run dev, entra a la sala y desafía a la IA.

Quien entra va a una cola; la IA juega de azul contra el primero de la cola. Quien le gana a la IA sigue; quien pierde vuelve al final de la cola.

Cómo funciona, pieza por pieza

text
ScoreTracker "ojos" (sin retraso) ──'state' cada 100 ms──► JogadorIA
                                                              │ buildObs()  → 39 números
                                                              │ policy.logits() → 18 notas
                                                              │ decide()    → acción, sin zigzag
                                                              │ actionToBits() → teclas (reflejadas si rojo)
                                                              ▼
                                 room.sendInput(teclas) ──► servidor de bonk.io ──► jugadores
                                 tracker.recordOwnInput()   (la simulación local también debe saberlo)

1. La observación: features.ts

Es la parte más delicada: tiene que ser idéntica a la del entrenamiento. No la toques sin verificar con los casos de prueba.

ts
// features.ts
/**
 * Observación y acciones de la IA de fútbol de BonkTools — exactamente como fue entrenada.
 *
 * Cualquier diferencia (una escala, un signo, un campo ausente tratado de otra forma) hace que la IA juegue mal
 * SIN ningún error. Verifica tu versión con los casos de prueba publicados junto al modelo.
 *
 * Eje canónico: el bot siempre "ataca hacia la derecha". Jugando de rojo (ataca hacia la izquierda), x y las
 * velocidades en x se reflejan en la observación y izquierda/derecha se intercambian en la acción.
 *
 * Versiones de la observación (la política indica cuál usa en `obsVersion`/`obsSize`): v1 = 25 números; v2 = 39 (v1 + postes,
 * paredes, alineación pelota-portería y velocidad de la pelota respecto al 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 direcciones (incl. quieto) x {sin tiro, tiro} — mismo orden del entrenamiento. */
export const ACTION_TABLE: readonly number[] = [...DIRS, ...DIRS.map((d) => d | KICK)];
/** Tamaño de la observación por versión. 101 = la del portero entrenado 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]!;

// Geometría de la v2 (eje 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;

/** Versión de la observación según el tamaño de entrada de la red (25 -> 1, 39 -> 2); null si no existe. */
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;
}

/** El equipo ataca hacia la izquierda (rojo) — hay que reflejar al eje 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 y un objeto VACÍO cuentan como ausentes (igual que el entrenamiento en Python). */
function isBody(v: unknown): v is Body {
  return !!v && typeof v === 'object' && Object.keys(v).length > 0;
}

/** Estado del ScoreTracker/PhysicsSimulator (ball, discs[], ftu). Ausente = centro del campo, quieto. */
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));

/**
 * Proyecta el estado `leadFrames` cuadros (30/s) HACIA ADELANTE: posiciones += velocidad × tiempo (sin colisiones) y el reloj de
 * congelamiento del saque (`ftu`) adelantado.
 *
 * La simulación local de la sala va a propósito 6 cuadros (200 ms) detrás del reloj, para que las teclas atrasadas de la red
 * lleguen (y el marcador automático no anuncie un gol que una tecla atrasada desharía). El bot decidía sobre ese pasado:
 * en el simulador, con 200 ms de retraso la IA perdía TODOS los saques ante un delantero que tira de primera;
 * proyectando, volvió a no recibir goles de saque.
 */
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];
}

/** Observación (float32 como en NumPy) desde el punto de vista de `selfId`, en la versión `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 pasa a -1; 0/None pasan a 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) redondea cada valor a float32 ANTES del clip (que compara en 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. La red y la decisión: policy.ts

Lee el policy.json, ejecuta las tres capas y decide eje por eje (ver por qué en Descargar los modelos).

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

/**
 * La red de la IA (el policy.json publicado), en JS puro — sin Python ni PyTorch en la máquina de la sala. MLP pequeña: obs(25 en v1, 39 en v2 — `obsVersion`) -> 256 -> tanh -> 256 -> tanh -> 18 logits;
 * la acción es el argmax (la jugada más probable). Pesos en 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;
  /** Versión de la observación (features.ts). Ausente en políticas antiguas: sale del obsSize. */
  obsVersion?: number;
  actionTable: number[];
  activation: string;
  layers: LayerJson[];
  timesteps?: number;
  exportedAt?: string;
}

interface Layer {
  inSize: number;
  outSize: number;
  /** out x in, fila por fila (mismo layout que el `weight` de 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 a un búfer alineado (el del base64 puede empezar en cualquier offset).
  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;
  /** Versión de la observación que espera esta red (pasarla a `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 acción (tanh en las capas ocultas, lineal en la ú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;
  }

  /** Acción determinista (índice en ACTION_TABLE): argmax puro. En vivo se usa `decide` (sin zigzag). */
  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;
  }
}

/** Márgenes de la decisión eje por eje (medidos en el 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 la jugada EJE POR EJE a partir de los logits
 * El argmax de las 18 acciones alternaba "diagonal arriba"/"diagonal abajo" casi empatadas en cada decisión: el bot
 * andaba en zigzag y nunca recto (42 inversiones/min en partidas reales; humanos, ~1). Aquí cada eje
 * sale de la probabilidad sumada de cada lado; empate = ninguna tecla de ese eje (anda recto), e invertir el sentido
 * anterior exige mayor ventaja (histéresis). Tiro si P(tiro) > 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 = abajo (y crece hacia abajo)
  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. El jugador: 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';

/**
 * Hace que el bot (la cuenta que aloja la sala) JUEGUE con la IA: en cada estado nuevo de la simulación (100 ms),
 * arma la observación, ejecuta la red y pulsa las teclas.
 */
export class JogadorIA {
  private partida: { eu: number; adversario: number; espelho: boolean } | null = null;
  private ultimasTeclas = -1; // última combinación enviada (solo enviamos cuando cambia, como un teclado de verdad)
  private ultimaAcao: number | null = null; // la decisión eje por eje compara con la anterior (evita el zigzag)

  constructor(
    private readonly room: BonkRoom,
    /** El ScoreTracker de la sala (marcador): la tecla del propio bot tiene que entrar en él. */
    private readonly placar: ScoreTracker,
    private readonly policy: Policy,
    /**
     * "Ojos" sin retraso (opcional): un 2º ScoreTracker con lagFrames 0. Sin él, la IA ve el estado
     * del marcador, que va 200 ms en el pasado, y proyectamos ese estado al presente.
     */
    private readonly olhos?: ScoreTracker,
    /** Avisa cada tecla enviada (el grabador de replays la necesita). */
    private readonly aoTeclar?: (id: number, k: { i: number; f: number; c: number }) => void,
  ) {
    (olhos ?? placar).on('state', this.aoEstado);
  }

  /** `time` (equipo): 3 = azul (ataca hacia la derecha), 2 = rojo (la IA refleja el 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); // suelta todas las teclas
  }

  private readonly aoEstado = ({ state }: StateInfo): void => {
    const p = this.partida;
    if (!p || !state || typeof state !== 'object') return;
    // sin "ojos", el estado va 6 frames (200 ms) atrás: proyecta a ahora
    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);
    // El servidor no devuelve al host la tecla que él mismo envió: sin esto, la simulación local
    // creería que el bot está quieto y la IA "vería" un juego distinto del 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;
  }
}

Tres detalles que lo cambian todo:

  • recordOwnInput. El servidor no le devuelve al host la tecla que él mismo envió. Sin registrarla en la simulación local, esta creería que el bot está quieto y la IA "vería" un juego distinto del real.
  • Solo envía una tecla cuando cambia, como un teclado de verdad. Enviar cada 100 ms infla el historial que reciben quienes entran a mitad de partida.
  • Suelta todo al final (parar(), "detener", envía 0); si no, el disco del bot sigue moviéndose solo en la siguiente partida.

4. Los "ojos": por qué dos ScoreTrackers

El ScoreTracker del marcador va a propósito 200 ms detrás del reloj: espera las teclas atrasadas de la red para nunca anunciar un gol que no ocurrió. Genial para el marcador, terrible para jugar: la IA estaría decidiendo sobre el pasado.

Por eso la sala "desafía a la IA" crea un segundo ScoreTracker con lagFrames: 0: los "ojos". Simula hasta el instante actual y, cuando llega una tecla atrasada, vuelve atrás y rehace ese tramo.

Configuración de la salaEntrena conResultado medido (100 jugadas contra el script más fuerte)
Con "ojos" (lagFrames: 0), sin proyección--visao agora (por defecto)95 goles, 2 recibidos
Solo el marcador (200 ms atrás) + projectState(estado, 6)--visao atrasada68 goles, 13 recibidos

5. La sala "desafía a la 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 "desafía a la IA": la IA está en azul y cada jugador de la cola juega contra ella. Quien gana sigue. */
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); // después de la pantalla de victoria
    });
    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); // da tiempo a que los cambios de equipo lleguen al servidor
  }

  /** Fin de la partida. `vencedor` null = cancelada. Quien perdió contra la IA va al final de la cola. */
  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 entrar al campo, el bot se pone en un equipo (room.setTeam(eu, TEAM_BLUE)) y el estado inicial se genera con él en la alineación, como cualquier jugador.

Grabar las partidas de la IA

Si usas también el grabador, pásale las teclas del bot (peer-input no trae las del propio host):

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

Cambiar el modelo sin reiniciar la sala

En las salas de BonkTools el modelo se cambiaba con la sala llena: cada minuto el bot revisaba la fecha del archivo y, si cambió, cargaba el nuevo (manteniendo el anterior si el nuevo venía roto). Es buena idea si vas a entrenar y actualizar seguido:

ts
let mtime = 0;
setInterval(() => {
  const m = statSync(arquivo).mtimeMs;
  if (m === mtime) return;
  try { policy = Policy.fromFile(arquivo); mtime = m; } catch { /* archivo inválido: sigue con el actual */ }
}, 60_000);

Ideas

  • Dificultad ajustable: con probabilidad p, cambia la decisión por una acción aleatoria o mantén la tecla anterior un tick más. Así el rival con script del entrenamiento tiene "habilidad".
  • 2v2 con IA: dos JogadorIA no funcionan en la misma cuenta (una cuenta = un jugador). Para dos bots, conecta una segunda cuenta con joinRoom() y dale su propio JogadorIA. Los otros modelos (portero, mbappa) están en Descargar los modelos.
  • Entrenar con las partidas de tu sala: graba las partidas contra humanos y usa las jugadas reales como escenarios de entrenamiento. Fue lo que más ayudó a nuestra IA a defender (ver Lo que aprendimos).