Utiliser l'IA

Télécharger les modèles

Tous les modèles entraînés par BonkTools (football et mbappa ; attaquant, défenseur et gardien), les formats de fichier et les cas de test pour vérifier votre implémentation.

Téléchargements

Football

ModèleFichierCas de testStatut
Attaquant / 1v1 (182 millions de pas, observation v2)football-1x1.policy.jsoncasCelui qui jouait dans les salons 1v1 et comme attaquant dans le salon 2v2
Gardien (22,4 millions de pas, observation « gk1 »)football-goleiro.policy.jsoncasExpérimental : dans le simulateur il encaisse moins de buts que notre gardien à règles (8,2 % contre 11,5 % des actions), mais il n'est jamais allé dans le salon (c'est le gardien à règles qui y jouait)

Mbappa (carte « Mbappa Clean », moteur classique)

ModèleFichierCas de testStatut
Attaquant (53,6 millions de pas, observation v3)mbappa-atacante.policy.jsoncasCelui qui jouait dans le salon mbappa 1v1 et comme attaquant dans le 2v2
Gardien (200 mille pas, observation v3)mbappa-goleiro.policy.jsoncasExpérimental : réseau entraîné pour le gardien du salon 2v2. Resté en test, il n'est pas allé dans le salon (là, le gardien utilisait le réseau de l'attaquant + des règles de sécurité)
Défenseur (4,5 millions de pas, observation v1)mbappa-defensor.policy.jsoncasExpérimental : spécialiste entraîné uniquement sur des actions défensives, pour jouer en duo avec l'attaquant. Il n'a pas amélioré le duo et n'est pas resté dans le salon

Pour démarrer vite

FichierCe que c'est
sala-exemplo.zipSalon prêt avec le mode « défiez l'IA » (MODO=ia) utilisant l'attaquant de football ; il contient aussi le code des autres modèles (src/ia/)
ia-kit.zipKit d'entraînement en Python pour entraîner le vôtre

Licence : MIT. Utilisez, modifiez et redistribuez ; gardez simplement l'avis de licence et ne prétendez pas être affilié à bonk.io.

Football : attaquant / 1v1

Le format policy.json

json
{
  "format": "bonktools-rl-policy/1",
  "obsSize": 39,
  "obsVersion": 2,
  "actionTable": [0, 4, 6, 2, 10, 8, 9, 1, 5, 16, 20, 22, 18, 26, 24, 25, 17, 21],
  "activation": "tanh",
  "layers": [
    { "in": 39,  "out": 256, "w": "<base64>", "b": "<base64>" },
    { "in": 256, "out": 256, "w": "<base64>", "b": "<base64>" },
    { "in": 256, "out": 18,  "w": "<base64>", "b": "<base64>" }
  ],
  "timesteps": 182053103,
  "exportedAt": "2026-09-29T16:48:34Z"
}
ChampSignification
obsSize, obsVersionCombien de nombres le réseau attend (39 = version 2 de l'observation)
actionTableLes 18 actions comme touches de bonk.io : gauche 1, droite 2, haut 4, bas 8, tir 16
layersLes couches : w sont les poids (out × in, ligne par ligne) et b le biais, en float32 little-endian encodés en base64
activationtanh dans les couches cachées ; la dernière est linéaire (elle donne 18 « notes », les logits)

Pour chaque couche : y = W·x + b, et tanh(y) si ce n'est pas la dernière. Les 18 notes finales disent à quel point l'IA « veut » chaque action.

Cas de test

json
{
  "state":  { "ball": {...}, "discs": [null, {...}, {...}], "ftu": 37 },
  "selfId": 1, "oppId": 2, "mirror": false,
  "obs":    [0.12, -0.4, ...],      // les 39 nombres attendus
  "logits": [1.23, -0.5, ...],      // les 18 notes attendues
  "prev":   5,                      // décision précédente (ou null)
  "decided": 3,                     // l'action décidée axe par axe
  "bits":   2                       // les touches à presser (déjà inversées si mirror)
}

Construisez l'observation à partir de state, exécutez le réseau, décidez avec prev et comparez. L'observation doit correspondre exactement (les valeurs sont arrondies en float32 avant la limite de ±2) ; les notes, jusqu'à la 4e décimale.

Comme attaquant en 2v2

Le même modèle jouait attaquant dans le salon 2v2 (l'IA à côté d'un gardien). Il voit le jeu comme un 1v1 : à chaque décision, l'« adversaire » est l'humain le plus proche du ballon. Avec le ballon dans son propre camp, une règle simple maintenait l'attaquant devant, sans disputer le ballon au gardien.

Football : gardien

Même format (bonktools-rl-policy/1) et même décision axe par axe, mais avec une autre observation : « gk1 » (obsVersion 101, 27 nombres), sur l'axe du gardien (son propre but est à gauche). Elle contient le gardien, le ballon, les deux adversaires les plus proches du ballon, le coéquipier (l'attaquant) et la prévision de l'endroit où le ballon franchit la ligne de but.

ts
// goleiro-rl.ts
import { teamMirror } from './features.js';

/**
 * Observation "gk1" du GARDIEN de football entraîné par RL (obsVersion 101, 27 nombres), exactement comme à l'entraînement.
 * Vérifiez avec les cas de test publiés avec le modèle. Axe canonique du gardien (son PROPRE but est à gauche).
 */
export const GK_OBS_VERSION = 101;
export const GK_OBS_SIZE = 27;

const CENTER_X = 33.18;
const CENTER_Y = 22.73;
const LINE_X = 2 * CENTER_X - 64.0 + 1.6; // ligne du gardien, 1,6 devant son propre but
const HALF_W = 33.0;
const HALF_H = 22.7;
const PLAYER_MAX_SPEED = 11.7;
const BALL_MAX_SPEED = 20.0;

interface Body { x: number; y: number; xv?: number; yv?: number; kickReady?: boolean }
export interface GkState { ball?: Body | null; discs?: Array<Body | null | undefined> | null }

export function gkObs(state: GkState, gk: number, team: number, humans: number[], bot: number | null): Float64Array {
  const m = teamMirror(team);
  const get = (i: number | null): Body | null => (i !== null && i >= 0 ? state.discs?.[i] ?? null : null);
  const c = (b: Body | null | undefined): [number, number, number, number] =>
    !b ? [CENTER_X, CENTER_Y, 0, 0] : m ? [2 * CENTER_X - b.x, b.y, -(b.xv ?? 0), b.yv ?? 0] : [b.x, b.y, b.xv ?? 0, b.yv ?? 0];
  const me = get(gk);
  const [sx, sy, sxv, syv] = c(me);
  const [bx, by, bxv, byv] = c(state.ball);
  const px = (x: number): number => (x - CENTER_X) / HALF_W;
  const py = (y: number): number => (y - CENTER_Y) / HALF_H;
  const o: number[] = [px(sx), py(sy), sxv / PLAYER_MAX_SPEED, syv / PLAYER_MAX_SPEED, me?.kickReady ? 1 : 0,
    px(bx), py(by), bxv / BALL_MAX_SPEED, byv / BALL_MAX_SPEED,
    (bx - sx) / 10, (by - sy) / 10, Math.min(Math.hypot(bx - sx, by - sy), 40) / 10];
  const hs = humans.map((h) => {
    const [hx, hy, hxv, hyv] = c(get(h));
    return [Math.hypot(hx - bx, hy - by), hx, hy, hxv, hyv] as const;
  });
  hs.sort((a, b) => a[0] - b[0]);
  while (hs.length < 2) hs.push([40, CENTER_X + 20, CENTER_Y, 0, 0]);
  for (const [d, hx, hy, hxv, hyv] of hs.slice(0, 2)) {
    o.push((hx - bx) / 10, (hy - by) / 10, hxv / PLAYER_MAX_SPEED, hyv / PLAYER_MAX_SPEED, Math.min(d, 40) / 10);
  }
  const [tx, ty] = c(get(bot));
  o.push(px(tx), py(ty));
  const cross = predictCross(bx, by, bxv, byv, Math.max(sx, LINE_X));
  if (cross) o.push(1, (cross[0] - CENTER_Y) / HALF_H, Math.min(cross[1], 3) / 3);
  else o.push(0, 0, 1);
  return Float64Array.from(o, (v) => Math.max(-5, Math.min(5, Math.fround(v))));
}

const BALL_Y_MIN = 7.79;
const BALL_Y_MAX = 37.67;

/** Réfléchit y sur les murs haut/bas (le ballon rebondit). */
function reflectY(y: number): number {
  const lo = BALL_Y_MIN, span = BALL_Y_MAX - BALL_Y_MIN;
  const t = (((y - lo) % (2 * span)) + 2 * span) % (2 * span);
  return lo + (t <= span ? t : 2 * span - t);
}

/** (y, temps) où le ballon franchit x = xLine en allant vers le but ; null s'il ne vient pas. */
export function predictCross(bx: number, by: number, bxv: number, byv: number, xLine: number): [number, number] | null {
  if (bxv > -1.0 || bx <= xLine) return null;
  const t = (bx - xLine) / -bxv;
  return [reflectY(by + byv * t), t];
}

Pour jouer : decide(policy.logits(gkObs(état, idGardien, équipe, idsAdversaires, idCoéquipier)), précédente) et actionToBits(action, teamMirror(équipe)), avec le même policy.ts que l'attaquant.

Les cas de test contiennent state, gk, team, humans (adversaires), bot (coéquipier), obs, logits, prev, decided et bits.

Mbappa : attaquant, gardien et défenseur

Le mbappa est un autre jeu : la carte « Mbappa Clean » sur le moteur classique de bonk.io (vue de côté, gravité, saut, ballon très rebondissant, buts en cages). La recette est la même (PPO, curriculum, self-play, vraie physique), mais avec une autre observation et d'autres actions.

Le format bonktools-rl-mbappa/1

Comme pour le football, avec deux différences :

  • actions au lieu de actionTable : 18 triplets [horizontal, vertical, lourd]. Horizontal : 0 rien, 1 ←, 2 →. Vertical : 0 rien, 1 ↑ (saute), 2 ↓ (descend vite en l'air). Lourd : maintenir X.
  • Décision par argmax (l'action la mieux notée), une toutes les 100 ms.
VersionNombresCe qu'elle voit
v1 (le défenseur)26Ballon, moi et l'adversaire (position, vitesse, au sol, lourd, vivant) et le ballon par rapport à moi, à l'adversaire et aux deux cages
v238v1 + où le ballon va tomber, prévision du ballon à 0,3 s et 0,6 s et une mémoire (touches de la décision précédente, depuis combien de temps ↑ est maintenu, depuis combien de temps en l'air)
v3 (attaquant et gardien)43v2 + les jauges de X des deux, si l'adversaire est lourd et si le ballon est sur l'une des cages

Axe canonique : l'agent attaque toujours vers la droite. Au mbappa c'est le bleu qui est inversé (au football c'est le rouge).

Le code

ts
// mbappa.ts
import { readFileSync } from 'node:fs';

/**
 * L'IA du mbappa (carte "Mbappa Clean", moteur classique de bonk.io) en JS pur : l'observation exacte de l'entraînement
 * (v1 : 26 nombres ; v2 : 38, avec prévision du ballon et mémoire ; v3 : 43, + les jauges de X des deux, le X de l'adversaire et le ballon
 * au-dessus d'une des cages) et le réseau (MLP tanh, argmax). Vérifiez avec les cas de test publiés avec chaque
 * modèle : une observation différente ferait mal jouer le bot sans aucune erreur.
 */

/** État du moteur classique : positions en unités du jeu, y augmente vers le bas. */
export interface ClassicState {
  ball: { x: number; y: number; xv: number; yv: number };
  /** `heavy` = X maintenu ; `stamina` = jauge de X (0..1000 : -10/image en maintenant, recharge 5). */
  discs: Record<string, { x: number; y: number; xv: number; yv: number; team: number; heavy: boolean; stamina?: number }>;
  scores: (number | null)[];
  ftu: number;
}

export const MBAPPA_POLICY_FORMAT = 'bonktools-rl-mbappa/1';
const TEAM_BLUE = 3;
const MIRROR = 73.0;
const GROUND = 43.1;
const LEFT_LINE = 8.9;
const RIGHT_LINE = 64.1;
const ATTACK: [number, number] = [RIGHT_LINE + 1.5, 40.0];
const DEFEND: [number, number] = [LEFT_LINE - 1.5, 40.0];
const LEFT = 1, RIGHT = 2, UP = 4, DOWN = 8, HEAVY = 16;
const FPS = 30;
const BALL_GROUND = 43.4;
const BALL_GRAVITY = 20.0;
export const MBAPPA_OBS_SIZES: Record<number, number> = { 1: 26, 2: 38, 3: 43 };
const STAMINA_MAX = 1000;
const ROOF_X = 9.5, ROOF_Y = 34.6; // ballon sur le toit de la cage de gauche (axe canonique)
/** Jauge de X (0..1) ; sans le champ, pleine (comme à l'entraînement). */
const staminaOf = (d: { stamina?: number }): number => Math.min(Math.max((typeof d.stamina === 'number' ? d.stamina : STAMINA_MAX) / STAMINA_MAX, 0), 1);

/** Mémoire du joueur (v2) : touches du dernier pas, images en maintenant ↑, images en l'air. */
export interface MbappaMemory {
  keys: number;
  upFrames: number;
  airFrames: number;
}
export const newMemory = (): MbappaMemory => ({ keys: 0, upFrames: 0, airFrames: 0 });
export function updateMemory(m: MbappaMemory, keys: number, frames: number, airborne: boolean): void {
  m.keys = keys;
  m.upFrames = keys & UP ? m.upFrames + frames : 0;
  m.airFrames = airborne ? m.airFrames + frames : 0;
}

type Body = { x: number; y: number; xv: number; yv: number };
const predictBall = (b: Body, t: number): [number, number] => [b.x + b.xv * t, Math.min(b.y + b.yv * t + 0.5 * BALL_GRAVITY * t * t, BALL_GROUND)];
function landingTime(b: Body): number {
  const dy = BALL_GROUND - b.y;
  if (dy <= 0) return 0;
  return (-b.yv + Math.sqrt(b.yv * b.yv + 2 * BALL_GRAVITY * dy)) / BALL_GRAVITY;
}
const canon = (x: number, xv: number, mirrored: boolean): [number, number] => (mirrored ? [MIRROR - x, -xv] : [x, xv]);
export const onGround = (d: { y: number; yv: number }): boolean => d.y >= GROUND - 0.15 && Math.abs(d.yv) < 0.5;
const clip = (v: number): number => Math.max(-5, Math.min(5, v));

/** Observation du point de vue de `me` (équipe `team`), sur l'axe canonique (l'agent attaque toujours vers la droite). */
export function buildObs(state: ClassicState, me: number, opp: number, team: number, mem: MbappaMemory | null = null, version = 1): number[] {
  const mirrored = team === TEAM_BLUE;
  const b = state.ball;
  const [bx, bxv] = canon(b.x, b.xv, mirrored);
  const by = b.y, byv = b.yv;
  const d = state.discs[String(me)];
  const o = state.discs[String(opp)];
  const W = 36.5, H = 10.0, V = 30.0;
  let mx: number, mxv: number, my: number, myv: number, mheavy: number, mground: number;
  if (d) {
    [mx, mxv] = canon(d.x, d.xv, mirrored);
    my = d.y; myv = d.yv; mheavy = d.heavy ? 1 : 0; mground = onGround(d) ? 1 : 0;
  } else {
    mx = bx; mxv = 0; my = GROUND; myv = 0; mheavy = 0; mground = 1;
  }
  let ox: number, oxv: number, oy: number, oyv: number, oground: number, alive: number;
  if (o) {
    [ox, oxv] = canon(o.x, o.xv, mirrored);
    oy = o.y; oyv = o.yv; oground = onGround(o) ? 1 : 0; alive = 1;
  } else {
    ox = MIRROR - mx; oxv = 0; oy = GROUND; oyv = 0; oground = 1; alive = 0;
  }
  const [ax, ay] = ATTACK;
  const [dx, dy] = DEFEND;
  const base = [
    (bx - 36.5) / W, (by - GROUND) / H, bxv / V, byv / V,
    (mx - 36.5) / W, (my - GROUND) / H, mxv / V, myv / V, mheavy, mground,
    (bx - mx) / W, (by - my) / H, (bxv - mxv) / V, (byv - myv) / V,
    (ox - mx) / W, (oy - my) / H, oxv / V, oyv / V, oground, alive,
    (ox - bx) / W, (oy - by) / H,
    (ax - bx) / W, (ay - by) / H,
    (dx - bx) / W, (dy - by) / H,
  ];
  if (version >= 2) {
    const cb = { x: bx, y: by, xv: bxv, yv: byv };
    const tLand = landingTime(cb);
    const [lx] = predictBall(cb, tLand);
    const [p3x, p3y] = predictBall(cb, 0.3);
    const [p6x, p6y] = predictBall(cb, 0.6);
    const m = mem ?? newMemory();
    let left = !!(m.keys & LEFT), right = !!(m.keys & RIGHT);
    if (mirrored) [left, right] = [right, left];
    base.push(
      (lx - mx) / W, Math.min(tLand, 3.0) / 1.5,
      (p3x - mx) / W, (p3y - my) / H, (p6x - mx) / W, (p6y - my) / H,
      (right ? 1 : 0) - (left ? 1 : 0), m.keys & UP ? 1 : 0, m.keys & DOWN ? 1 : 0, m.keys & HEAVY ? 1 : 0,
      Math.min(m.upFrames / FPS, 1.0), Math.min(m.airFrames / FPS, 2.0) / 2.0,
    );
  }
  if (version >= 3) {
    base.push(
      d ? staminaOf(d) : 0, o ? staminaOf(o) : 0, o && o.heavy ? 1 : 0,
      bx < ROOF_X && by < ROOF_Y ? 1 : 0, bx > MIRROR - ROOF_X && by < ROOF_Y ? 1 : 0,
    );
  }
  return base.map((v) => clip(Math.fround(v)));
}

/** Touches du jeu pour le coup (axe canonique ; inversé : ← et → s'échangent). */
export function keysFor(action: number, actions: readonly (readonly [number, number, boolean | number])[], mirrored: boolean): number {
  const [h, v, heavy] = actions[action]!;
  let k = 0;
  if (h === 1) k |= mirrored ? RIGHT : LEFT;
  else if (h === 2) k |= mirrored ? LEFT : RIGHT;
  if (v === 1) k |= UP;
  else if (v === 2) k |= DOWN;
  if (heavy) k |= HEAVY;
  return k;
}

interface LayerJson {
  in: number;
  out: number;
  w: string;
  b: string;
}
export interface MbappaPolicyJson {
  format: string;
  obsSize: number;
  obsVersion?: number;
  actions: [number, number, boolean][];
  activation: string;
  layers: LayerJson[];
  timesteps?: number;
  exportedAt?: string;
}

function floats(b64: string, n: number): Float32Array {
  const buf = Buffer.from(b64, 'base64');
  if (buf.length !== n * 4) throw new Error(`política inválida: ${buf.length / 4} valores, esperado ${n}`);
  const out = new Float32Array(n);
  for (let i = 0; i < n; i++) out[i] = buf.readFloatLE(i * 4);
  return out;
}

export class MbappaPolicy {
  readonly actions: [number, number, boolean][];
  readonly timesteps: number;
  readonly obsVersion: number;
  private readonly layers: { in: number; out: number; w: Float32Array; b: Float32Array }[];
  private mem = newMemory();
  private lastKeys: number | null = null;

  constructor(json: MbappaPolicyJson) {
    if (json.format !== MBAPPA_POLICY_FORMAT) throw new Error(`formato de política desconhecido: ${String(json.format)}`);
    if (json.activation !== 'tanh') throw new Error(`ativação não suportada: ${json.activation}`);
    this.actions = json.actions;
    this.timesteps = json.timesteps ?? 0;
    const byOrder = Object.entries(MBAPPA_OBS_SIZES).find(([, n]) => n === json.obsSize)?.[0];
    this.obsVersion = json.obsVersion ?? Number(byOrder ?? 1);
    if (MBAPPA_OBS_SIZES[this.obsVersion] !== json.obsSize) throw new Error(`política com ${json.obsSize} entradas: observação desconhecida`);
    this.layers = json.layers.map((l) => ({ in: l.in, out: l.out, w: floats(l.w, l.in * l.out), b: floats(l.b, l.out) }));
    if (this.layers[0]?.in !== json.obsSize) throw new Error('política inválida: a primeira camada não bate com obsSize');
  }

  static load(path: string): MbappaPolicy {
    return new MbappaPolicy(JSON.parse(readFileSync(path, 'utf8')) as MbappaPolicyJson);
  }

  /** Le coup le plus probable (argmax des logits). */
  act(obs: readonly number[]): number {
    let x = Float32Array.from(obs);
    this.layers.forEach((l, li) => {
      const y = new Float32Array(l.out);
      for (let o = 0; o < l.out; o++) {
        let s = l.b[o]!;
        const row = o * l.in;
        for (let i = 0; i < l.in; i++) s += l.w[row + i]! * x[i]!;
        y[o] = li < this.layers.length - 1 ? Math.tanh(s) : s;
      }
      x = y;
    });
    let best = 0;
    for (let i = 1; i < x.length; i++) if (x[i]! > x[best]!) best = i;
    return best;
  }

  /** Nouveau match : remet la mémoire à zéro. */
  resetMemory(): void {
    this.mem = newMemory();
    this.lastKeys = null;
  }

  /**
   * Les touches RÉELLEMENT envoyées à ce pas, quand l'utilisateur du réseau a remplacé son coup (salon 2v2 du mbappa : l'
   * attaquant laisse l'action au gardien) : la mémoire du pas suivant enregistre ce que le joueur a fait, comme à l'entraînement.
   */
  noteKeys(keys: number): void {
    this.lastKeys = keys;
  }

  /**
   * Touches pour `me` (équipe `team`) dans cet état, appelé toutes les `frames` images (100 ms = 3, le pas d'entraînement) : la
   * mémoire enregistre les touches de la décision précédente et si le joueur est en l'air (même ordre qu'à l'entraînement).
   */
  keys(state: ClassicState, me: number, opp: number, team: number, frames = 3): number {
    if (this.obsVersion >= 2 && this.lastKeys !== null) {
      const d = state.discs[String(me)];
      updateMemory(this.mem, this.lastKeys, frames, !!d && !onGround(d));
    }
    const k = keysFor(this.act(buildObs(state, me, opp, team, this.mem, this.obsVersion)), this.actions, team === TEAM_BLUE);
    this.lastKeys = k;
    return k;
  }
}

Utilisation : policy.keys(état, moi, adversaire, équipe) toutes les 3 images (100 ms) renvoie les touches à presser et gère la mémoire seule. Appelez resetMemory() à chaque nouveau match.

Cas de test du mbappa

Chaque cas contient state (format ClassicState), me, opp, team, mem ([touches, imagesEnMaintenantHaut, imagesEnLAir]), obs, action (l'argmax) et bits (les touches). Construisez l'observation avec buildObs(state, me, opp, team, {keys, upFrames, airFrames}, version), exécutez act() et comparez.