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
- Descarga el proyecto de ejemplo y el modelo. Pon el
football-1x1.policy.jsonen la carpeta del proyecto. - En el
.env:MODO=ia(y, si quieres,IA_MODELO=ruta/del/modelo.json). 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
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.
// 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).
// 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
// 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 sala | Entrena con | Resultado 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 atrasada | 68 goles, 13 recibidos |
5. La sala "desafía a la IA": sala-ia.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):
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:
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
JogadorIAno funcionan en la misma cuenta (una cuenta = un jugador). Para dos bots, conecta una segunda cuenta conjoinRoom()y dale su propioJogadorIA. 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).