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+.
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.pySe terminar com OK — a ponte com a física funcionou., está tudo pronto.
2. O que tem no kit
| Ficheiro | O que faz |
|---|---|
sim_bridge/bridge.mjs | A ponte: um processo Node que roda a física do bonk.io e conversa com o Python |
bonk_ia/ambiente.py | O ambiente: transforma o jogo num exercício (lance, observação, pontos) |
bonk_ia/features.py | O que a IA vê (igual ao features.ts da sala) |
bonk_ia/recompensas.py | Como a IA ganha pontos |
bonk_ia/adversarios.py | Adversários com script |
bonk_ia/politica.py | Exporta para policy.json e roda modelos antigos (self-play) |
bonk_ia/decisao.py | A decisão eixo a eixo (igual à da sala) |
treinar.py, avaliar.py, testar_ponte.py | Os 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.
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":[]}────────────────────────────────| Comando | O que faz |
|---|---|
reset | Começ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} |
step | Aperta as teclas de cada jogador ({"id": teclas}) e avança frames quadros. Devolve o estado e os golos que saíram |
close | Encerra |
O código inteiro da ponte tem menos de 90 linhas:
// 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
| Campo | Conteú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") |
scores | marcador por id de equipa (2 vermelho, 3 azul) |
ftu | quadros 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:
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.