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
- Baixe o projeto de exemplo e o modelo. Coloque o
football-1x1.policy.jsonna pasta do projeto. - No
.env:MODO=ia(e, se quiser,IA_MODELO=caminho/do/modelo.json). 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
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.
// 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).
// 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
// 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 sala | Treine com | Resultado 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 atrasada | 68 gols, 13 sofridos |
5. A sala "desafie a 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 "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):
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:
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
JogadorIAnão funcionam na mesma conta (uma conta = um jogador). Para dois bots, conecte uma segunda conta comjoinRoom()e dê a ela o seu próprioJogadorIA. 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).