Entrena la IA
Preparar el entorno de entrenamiento
Instala el kit, entiende el puente entre Python y la física real de bonk.io y verifica que todo esté conectado.
En este recorrido entrenas tu propia IA de fútbol. No necesitas tarjeta gráfica ni ningún servicio de pago: solo un ordenador con Node.js y Python. Con 4 simulaciones en paralelo, un PC común entrena unos 750 pasos por segundo (cada paso = 100 ms de juego).
1. Descarga e instala el kit
Descargar ia-kit.zip y descomprímelo. Necesitarás Node.js 20.18+ y 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.pySi termina con OK — a ponte com a física funcionou. ("el puente con la física funcionó"), todo está listo.
2. Qué trae el kit
| Archivo | Qué hace |
|---|---|
sim_bridge/bridge.mjs | El puente: un proceso Node que ejecuta la física de bonk.io y habla con Python |
bonk_ia/ambiente.py | El entorno: convierte el juego en un ejercicio (jugada, observación, puntos) |
bonk_ia/features.py | Lo que la IA ve (igual al features.ts de la sala) |
bonk_ia/recompensas.py | Cómo la IA gana puntos (recompensas) |
bonk_ia/adversarios.py | Rivales con script |
bonk_ia/politica.py | Exporta a policy.json y ejecuta modelos antiguos (self-play) |
bonk_ia/decisao.py | La decisión eje por eje (igual a la de la sala) |
treinar.py, avaliar.py, testar_ponte.py | Los comandos que ejecutas: entrenar, evaluar, probar el puente |
3. El puente: Python hablando con la física
El entrenamiento está en Python (ahí están las bibliotecas de IA), pero la física de bonk.io es JavaScript. El puente lo resuelve: Python abre un proceso Node y los dos intercambian una línea de JSON a la 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 | Qué hace |
|---|---|
reset | Empieza una jugada. players es la alineación (índice = id). overrides (opcional) pone la pelota y los jugadores donde quieras: {"ball":{"x":..,"y":..,"xv":0,"yv":0},"discs":{"1":{"x":..,"y":..}},"ftu":0} |
step | Pulsa las teclas de cada jugador ({"id": teclas}) y avanza frames cuadros. Devuelve el estado y los goles marcados |
close | Cierra |
El puente entero tiene menos de 90 líneas:
// bridge.mjs
// Puente entre el simulador de física (Node, `PhysicsSimulator` de `bonktools`) y el entorno
// Gymnasium (Python, `bonk_ia/ambiente.py`). Protocolo: una petición JSON por línea en stdin, una
// respuesta JSON por línea en stdout. Estrictamente request/response — quien llama espera la respuesta
// de cada línea antes de enviar la siguiente (no hay pipeline de varias peticiones en vuelo).
//
// 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, por defecto 1)
// -> {"ok":true,"state":{...},"frame":N,"goals":[...]}
// {"cmd":"close"}
// -> {"ok":true} (el proceso termina enseguida)
// Errores: {"ok":false,"error":"mensaje"}
import readline from 'node:readline';
import { PhysicsSimulator } from 'bonktools';
const sim = new PhysicsSimulator();
let started = false;
// Solo los campos que usa el entorno Python — el estado completo del juego es mucho mayor y serializar/parsear
// todo en cada paso era buena parte del costo por paso.
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 línea ya en el búfer sin esperar al handler anterior
// a que termine — si no serializáramos aquí, un 'close' que llega justo detrás de un 'reset' lento
// mataría el proceso (process.exit) antes de que se escribiera la respuesta del 'reset'. Una cola de
// promises garantiza que cada línea solo empieza a procesarse después de la respuesta de la anterior
// haya sido enviada, respetando el protocolo request/response aunque el stdin llegue todo de una 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) });
}
}El estado del juego
| Campo | Contenido |
|---|---|
ball | {x, y, xv, yv}: posición y velocidad de la pelota |
discs[id] | {x, y, xv, yv, team, kickReady}: cada jugador (su cuerpo físico es un "disco") |
scores | marcador por id de equipo (2 rojo, 3 azul) |
ftu | cuadros hasta que se libere el saque (~120 = 4 s; las teclas se ignoran antes) |
El campo mide unas 66 × 45 unidades: el jugador se mueve en x de 1 a 65,4 y en y de 1 a 44,5 (y crece hacia abajo), la portería de la derecha está en x ≈ 64 y el centro en (33,18; 22,73). Un jugador corre hasta ~11,7 unidades/s y un tiro sale a ~24.
4. Más rápido: varias simulaciones a la vez
Cada entorno tiene su propio puente (un proceso Node). treinar.py envía el paso a todos antes de leer las respuestas, así las simulaciones avanzan en paralelo con un solo Python:
python treinar.py --envs 4 # 4 puentes: usa 2, 4 u 8 (dividen el lote del PPO exacto)Regla práctica: un entorno por núcleo del procesador.
Siguiente paso
Entiende lo que ve la IA y cómo gana puntos antes de cambiar nada, y después ve a Entrenar y exportar.