Entraîner l'IA

Préparer l'environnement d'entraînement

Installez le kit, comprenez le pont entre Python et la vraie physique de bonk.io et vérifiez que tout est branché.

Dans ce parcours, vous entraînez votre propre IA de football. Pas besoin de carte graphique ni de service payant : juste un ordinateur avec Node.js et Python. Avec 4 simulations en parallèle, un PC ordinaire entraîne environ 750 pas par seconde (chaque pas = 100 ms de jeu).

1. Téléchargez et installez le kit

Télécharger ia-kit.zip et décompressez-le. Il vous faut Node.js 20.18+ et 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

S'il se termine par OK — a ponte com a física funcionou. (« le pont avec la physique fonctionne »), tout est prêt.

2. Contenu du kit

FichierCe qu'il fait
sim_bridge/bridge.mjsLe pont : un processus Node qui exécute la physique de bonk.io et parle à Python
bonk_ia/ambiente.pyL'environnement : transforme le jeu en exercice (action, observation, points)
bonk_ia/features.pyCe que l'IA voit (identique au features.ts du salon)
bonk_ia/recompensas.pyComment l'IA gagne des points (récompenses)
bonk_ia/adversarios.pyAdversaires scriptés
bonk_ia/politica.pyExporte vers policy.json et fait tourner d'anciens modèles (self-play)
bonk_ia/decisao.pyLa décision axe par axe (identique à celle du salon)
treinar.py, avaliar.py, testar_ponte.pyLes commandes que vous lancez : entraîner, évaluer, tester le pont

3. Le pont : Python qui parle à la physique

L'entraînement est en Python (c'est là que sont les bibliothèques d'IA), mais la physique de bonk.io est en JavaScript. Le pont règle ça : Python ouvre un processus Node et les deux échangent une ligne de JSON à la fois.

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":[]}────────────────────────────────
CommandeCe qu'elle fait
resetDémarre une action. players est la composition (indice = id). overrides (optionnel) place le ballon et les joueurs où vous voulez : {"ball":{"x":..,"y":..,"xv":0,"yv":0},"discs":{"1":{"x":..,"y":..}},"ftu":0}
stepPresse les touches de chaque joueur ({"id": touches}) et avance de frames images. Renvoie l'état et les buts marqués
closeFerme

Le pont entier fait moins de 90 lignes :

js
// bridge.mjs
// Pont entre le simulateur physique (Node, `PhysicsSimulator` de `bonktools`) et l'environnement
// Gymnasium (Python, `bonk_ia/ambiente.py`). Protocole : une requête JSON par ligne sur stdin, une
// réponse JSON par ligne sur stdout. Strictement requête/réponse — l'appelant attend la réponse
// à chaque ligne avant d'envoyer la suivante (pas de pipeline de plusieurs requêtes en vol).
//
// Commandes :
//   {"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}}  (optionnel)
//   {"cmd":"step","actions":{"1":2,"2":0},"frames":3}   (frames optionnel, 1 par défaut)
//     -> {"ok":true,"state":{...},"frame":N,"goals":[...]}
//   {"cmd":"close"}
//     -> {"ok":true}  (le processus se termine ensuite)
// Erreurs : {"ok":false,"error":"message"}
import readline from 'node:readline';
import { PhysicsSimulator } from 'bonktools';

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

// Seulement les champs utilisés par l'environnement Python — l'état complet du jeu est bien plus gros, et sérialiser/parser
// tout à chaque pas représentait une bonne part du coût par pas.
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` déclenche 'line' pour chaque ligne déjà en tampon sans attendre que le handler précédent
// se termine — si on ne sérialisait pas ici, un 'close' arrivant juste après un 'reset' lent
// tuerait le processus (process.exit) avant que la réponse du 'reset' soit écrite. Une file de
// promesses garantit que chaque ligne n'est traitée qu'après l'envoi de la réponse précédente
// , respectant le protocole requête/réponse même si stdin arrive d'un seul coup.
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) });
  }
}

L'état du jeu

ChampContenu
ball{x, y, xv, yv} : position et vitesse du ballon
discs[id]{x, y, xv, yv, team, kickReady} : chaque joueur (son corps physique est un « disque »)
scoresscore par id d'équipe (2 rouge, 3 bleu)
ftuimages avant que l'engagement soit libéré (~120 = 4 s ; les touches sont ignorées avant)

Le terrain mesure environ 66 × 45 unités : le joueur se déplace en x de 1 à 65,4 et en y de 1 à 44,5 (y augmente vers le bas), le but de droite est en x ≈ 64 et le centre en (33,18 ; 22,73). Un joueur court jusqu'à ~11,7 unités/s et un tir part à ~24.

4. Plus vite : plusieurs simulations à la fois

Chaque environnement a son propre pont (un processus Node). treinar.py envoie le pas à tous avant de lire les réponses, ainsi les simulations avancent en parallèle avec un seul Python :

bash
python treinar.py --envs 4     # 4 ponts : utilisez 2, 4 ou 8 (ils divisent exactement le lot du PPO)

Règle pratique : un environnement par cœur du processeur.

Étape suivante

Comprenez ce que voit l'IA et comment elle gagne des points avant de changer quoi que ce soit, puis passez à Entraîner et exporter.