Treine a IA

Preparar o ambiente de treino

Instale o kit, entenda a ponte entre Python e a física real do bonk.io e confira que tudo está ligado.

Nesta trilha você treina a sua IA de football. Não precisa de placa de vídeo nem de nenhum serviço pago: só um computador com Node.js e Python. Com 4 simulações em paralelo, um PC comum treina cerca de 750 passos por segundo (cada passo = 100 ms de jogo).

1. Descarregue e instale o kit

Descarregar ia-kit.zip e descompacte. Você vai precisar de Node.js 20.18+ e Python 3.10+.

bash
cd ia-kit
cd sim_bridge && npm install && cd ..

python -m venv .venv
# Windows:  .venv\Scripts\activate
# Linux/mac: source .venv/bin/activate
pip install -r requirements.txt     # gymnasium, stable-baselines3, torch (CPU), numpy, tensorboard

python testar_ponte.py

Se terminar com OK — a ponte com a física funcionou., está tudo pronto.

2. O que tem no kit

FicheiroO que faz
sim_bridge/bridge.mjsA ponte: um processo Node que roda a física do bonk.io e conversa com o Python
bonk_ia/ambiente.pyO ambiente: transforma o jogo num exercício (lance, observação, pontos)
bonk_ia/features.pyO que a IA vê (igual ao features.ts da sala)
bonk_ia/recompensas.pyComo a IA ganha pontos
bonk_ia/adversarios.pyAdversários com script
bonk_ia/politica.pyExporta para policy.json e roda modelos antigos (self-play)
bonk_ia/decisao.pyA decisão eixo a eixo (igual à da sala)
treinar.py, avaliar.py, testar_ponte.pyOs comandos que você roda

3. A ponte: Python conversando com a física

O treino é em Python (é onde estão as bibliotecas de IA), mas a física do bonk.io é JavaScript. A ponte resolve isso: o Python abre um processo Node e os dois trocam uma linha de JSON por vez.

text
Python  ──{"cmd":"reset","players":[null,{"id":1,"team":3},{"id":2,"team":2}],"seed":42}──►  Node
        ◄──{"ok":true,"state":{"ball":{...},"discs":[null,{...},{...}],"ftu":120}}───────────
        ──{"cmd":"step","actions":{"1":18,"2":0},"frames":3}─────────────────────────────►
        ◄──{"ok":true,"state":{...},"frame":3,"goals":[]}────────────────────────────────
ComandoO que faz
resetComeça um lance. players é a escalação (índice = id). overrides (opcional) coloca bola e jogadores onde você quiser: {"ball":{"x":..,"y":..,"xv":0,"yv":0},"discs":{"1":{"x":..,"y":..}},"ftu":0}
stepAperta as teclas de cada jogador ({"id": teclas}) e avança frames quadros. Devolve o estado e os golos que saíram
closeEncerra

O código inteiro da ponte tem menos de 90 linhas:

js
// bridge.mjs
// Ponte entre o simulador de física (Node, `PhysicsSimulator` de `bonktools`) e o ambiente
// Gymnasium (Python, `bonk_ia/ambiente.py`). Protocolo: uma requisição JSON por linha em stdin, uma
// resposta JSON por linha em stdout. Estritamente request/response — o chamador espera a resposta
// de cada linha antes de mandar a próxima (não há pipeline de várias requisições em voo).
//
// Comandos:
//   {"cmd":"reset","players":[null,{"id":1,"team":3},{"id":2,"team":2}],"seed":123}
//     -> {"ok":true,"state":{...}}
//   {"cmd":"reset",...,"overrides":{"ball":{"x":..,"y":..,"xv":..,"yv":..},"discs":{"1":{...}},"ftu":0}}  (opcional)
//   {"cmd":"step","actions":{"1":2,"2":0},"frames":3}   (frames opcional, padrão 1)
//     -> {"ok":true,"state":{...},"frame":N,"goals":[...]}
//   {"cmd":"close"}
//     -> {"ok":true}  (processo encerra em seguida)
// Erros: {"ok":false,"error":"mensagem"}
import readline from 'node:readline';
import { PhysicsSimulator } from 'bonktools';

const sim = new PhysicsSimulator();
let started = false;

// Só os campos que o ambiente Python usa — o estado completo do jogo é bem maior e serializar/parsear
// ele inteiro a cada passo era boa parte do custo por passo.
function compact(state) {
  if (!state) return state;
  const body = (b) => (b ? { x: b.x, y: b.y, xv: b.xv, yv: b.yv } : null);
  return {
    ball: body(state.ball),
    discs: (state.discs || []).map((d) => (d ? { ...body(d), team: d.team, kickReady: d.kickReady } : null)),
    scores: state.scores,
    ftu: state.ftu,
  };
}

function send(obj) {
  process.stdout.write(JSON.stringify(obj) + '\n');
}

const rl = readline.createInterface({ input: process.stdin, terminal: false });

// `readline` dispara 'line' para cada linha já bufferizada sem esperar o handler anterior
// terminar — se não serializássemos aqui, um 'close' que chega logo atrás de um 'reset' lento
// mataria o processo (process.exit) antes da resposta do 'reset' ser escrita. Uma fila de
// promises garante que cada linha só começa a ser processada depois da resposta da anterior
// ter sido enviada, honrando o protocolo request/response mesmo se o stdin chegar tudo de uma vez.
let queue = Promise.resolve();

rl.on('line', (line) => {
  queue = queue.then(() => handleLine(line));
});

async function handleLine(line) {
  const trimmed = line.trim();
  if (!trimmed) return;

  let req;
  try {
    req = JSON.parse(trimmed);
  } catch {
    send({ ok: false, error: 'linha não é JSON válido' });
    return;
  }

  try {
    if (req.cmd === 'reset') {
      if (!started) {
        await sim.start();
        started = true;
      }
      const state = await sim.reset(req.players, req.seed, undefined, req.overrides);
      send({ ok: true, state: compact(state) });
    } else if (req.cmd === 'step') {
      const result = await sim.step(req.actions, req.frames || 1);
      send({ ok: true, state: compact(result.state), frame: result.frame, goals: result.goals });
    } else if (req.cmd === 'close') {
      sim.close();
      send({ ok: true });
      process.exit(0);
    } else {
      send({ ok: false, error: `comando desconhecido: ${String(req.cmd)}` });
    }
  } catch (err) {
    send({ ok: false, error: err instanceof Error ? err.message : String(err) });
  }
}

O estado do jogo

CampoConteúdo
ball{x, y, xv, yv}: posição e velocidade da bola
discs[id]{x, y, xv, yv, team, kickReady}: cada jogador (o corpo físico dele é um "disco")
scoresmarcador por id de equipa (2 vermelho, 3 azul)
ftuquadros até a saída de bola liberar (~120 = 4 s; teclas são ignoradas antes disso)

O campo mede cerca de 66 × 45 unidades: jogador anda em x de 1 a 65,4 e y de 1 a 44,5 (y cresce para baixo), o golo da direita fica em x ≈ 64 e o centro em (33,18; 22,73). O jogador corre até ~11,7 unidades/s e um chute sai a ~24.

4. Mais rápido: várias simulações ao mesmo tempo

Cada ambiente tem a sua ponte (um processo Node). O treinar.py manda o passo para todas antes de ler as respostas, então as simulações andam em paralelo com um único Python:

bash
python treinar.py --envs 4     # 4 pontes: use 2, 4 ou 8 (múltiplos que dividem o lote do PPO)

Regra de bolso: um ambiente por núcleo do processador.

Próximo passo

Entenda o que a IA vê e como ela ganha pontos antes de mudar qualquer coisa, e depois vá para Treinar e exportar.