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èle | Fichier | Cas de test | Statut |
|---|---|---|---|
| Attaquant / 1v1 (182 millions de pas, observation v2) | football-1x1.policy.json | cas | Celui qui jouait dans les salons 1v1 et comme attaquant dans le salon 2v2 |
| Gardien (22,4 millions de pas, observation « gk1 ») | football-goleiro.policy.json | cas | Expé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èle | Fichier | Cas de test | Statut |
|---|---|---|---|
| Attaquant (53,6 millions de pas, observation v3) | mbappa-atacante.policy.json | cas | Celui qui jouait dans le salon mbappa 1v1 et comme attaquant dans le 2v2 |
| Gardien (200 mille pas, observation v3) | mbappa-goleiro.policy.json | cas | Expé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.json | cas | Expé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
| Fichier | Ce que c'est |
|---|---|
| sala-exemplo.zip | Salon 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.zip | Kit 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
{
"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"
}| Champ | Signification |
|---|---|
obsSize, obsVersion | Combien de nombres le réseau attend (39 = version 2 de l'observation) |
actionTable | Les 18 actions comme touches de bonk.io : gauche 1, droite 2, haut 4, bas 8, tir 16 |
layers | Les couches : w sont les poids (out × in, ligne par ligne) et b le biais, en float32 little-endian encodés en base64 |
activation | tanh 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
{
"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.
// 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 :
actionsau lieu deactionTable: 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.
| Version | Nombres | Ce qu'elle voit |
|---|---|---|
| v1 (le défenseur) | 26 | Ballon, moi et l'adversaire (position, vitesse, au sol, lourd, vivant) et le ballon par rapport à moi, à l'adversaire et aux deux cages |
| v2 | 38 | v1 + 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) | 43 | v2 + 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
// 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.