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+.

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

Si 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

ArchivoQué hace
sim_bridge/bridge.mjsEl puente: un proceso Node que ejecuta la física de bonk.io y habla con Python
bonk_ia/ambiente.pyEl entorno: convierte el juego en un ejercicio (jugada, observación, puntos)
bonk_ia/features.pyLo que la IA ve (igual al features.ts de la sala)
bonk_ia/recompensas.pyCómo la IA gana puntos (recompensas)
bonk_ia/adversarios.pyRivales con script
bonk_ia/politica.pyExporta a policy.json y ejecuta modelos antiguos (self-play)
bonk_ia/decisao.pyLa decisión eje por eje (igual a la de la sala)
treinar.py, avaliar.py, testar_ponte.pyLos 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.

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":[]}────────────────────────────────
ComandoQué hace
resetEmpieza 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}
stepPulsa las teclas de cada jugador ({"id": teclas}) y avanza frames cuadros. Devuelve el estado y los goles marcados
closeCierra

El puente entero tiene menos de 90 líneas:

js
// 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

CampoContenido
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")
scoresmarcador por id de equipo (2 rojo, 3 azul)
ftucuadros 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:

bash
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.