Usa la IA

Descargar los modelos

Todos los modelos entrenados por BonkTools (fútbol y mbappa; delantero, defensor y portero), los formatos de archivo y los casos de prueba para verificar tu implementación.

Descargas

Fútbol

ModeloArchivoCasos de pruebaSituación
Delantero / 1v1 (182 millones de pasos, observación v2)football-1x1.policy.jsoncasosEl que jugaba en las salas 1v1 y como delantero en la sala 2v2
Portero (22,4 millones de pasos, observación "gk1")football-goleiro.policy.jsoncasosExperimental: en el simulador recibe menos goles que nuestro portero por reglas (8,2% vs 11,5% de las jugadas), pero nunca llegó a la sala (allí jugaba el portero por reglas)

Mbappa (mapa "Mbappa Clean", motor clásico)

ModeloArchivoCasos de pruebaSituación
Delantero (53,6 millones de pasos, observación v3)mbappa-atacante.policy.jsoncasosEl que jugaba en la sala de mbappa 1v1 y como delantero en la 2v2
Portero (200 mil pasos, observación v3)mbappa-goleiro.policy.jsoncasosExperimental: red entrenada para el portero de la sala 2v2. Quedó en pruebas y no llegó a la sala (allí el portero usaba la red del delantero + reglas de seguridad)
Defensor (4,5 millones de pasos, observación v1)mbappa-defensor.policy.jsoncasosExperimental: especialista entrenado solo en jugadas de defensa, para jugar en dupla con el delantero. No mejoró la dupla y no se quedó en la sala

Para empezar rápido

ArchivoQué es
sala-exemplo.zipSala lista con el modo "desafía a la IA" (MODO=ia) usando el delantero de fútbol; también trae el código de los otros modelos (src/ia/)
ia-kit.zipKit de entrenamiento en Python para entrenar el tuyo

Licencia: MIT. Usa, modifica y redistribuye; solo mantén el aviso de licencia y no digas que estás afiliado a bonk.io.

Fútbol: delantero / 1v1

El formato 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"
}
CampoSignificado
obsSize, obsVersionCuántos números espera la red (39 = versión 2 de la observación)
actionTableLas 18 acciones como teclas de bonk.io: izquierda 1, derecha 2, arriba 4, abajo 8, tiro 16
layersLas capas: w son los pesos (out × in, fila por fila) y b el bias, en float32 little-endian codificados en base64
activationtanh en las capas ocultas; la última es lineal (da 18 "notas", los logits)

Para cada capa: y = W·x + b, y tanh(y) si no es la última. Las 18 notas finales dicen cuánto "quiere" la IA cada acción.

Casos de prueba

json
{
  "state":  { "ball": {...}, "discs": [null, {...}, {...}], "ftu": 37 },
  "selfId": 1, "oppId": 2, "mirror": false,
  "obs":    [0.12, -0.4, ...],      // los 39 números esperados
  "logits": [1.23, -0.5, ...],      // las 18 notas esperadas
  "prev":   5,                      // decisión anterior (o null)
  "decided": 3,                     // la acción decidida eje por eje
  "bits":   2                       // las teclas a pulsar (ya reflejadas si mirror)
}

Arma la observación del state, ejecuta la red, decide con prev y compara. La observación debe coincidir exactamente (los valores se redondean a float32 antes del límite de ±2); las notas, hasta el 4º decimal.

Como delantero en el 2v2

El mismo modelo jugaba como delantero en la sala 2v2 (la IA junto a un portero). Ve el juego como 1v1: en cada decisión, el "rival" es el humano más cercano a la pelota. Con la pelota en su propio campo, una regla simple mantenía al delantero adelantado, sin disputarle la pelota al portero.

Fútbol: portero

Mismo formato (bonktools-rl-policy/1) y la misma decisión eje por eje, pero con otra observación: la "gk1" (obsVersion 101, 27 números), en el eje del portero (su propia portería queda a la izquierda). Trae al portero, la pelota, los dos rivales más cercanos a la pelota, el compañero (el delantero) y la previsión de dónde la pelota cruza la línea de gol.

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

/**
 * Observación "gk1" del PORTERO de fútbol entrenado por RL (obsVersion 101, 27 números), exactamente como en el entrenamiento.
 * Verifica con los casos de prueba publicados junto al modelo. Eje canónico del portero (su PROPIA portería queda a la izquierda).
 */
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; // línea del portero, 1,6 delante de su propia portería
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;

/** Refleja y en las paredes de arriba/abajo (la pelota rebota). */
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, tiempo) en que la pelota cruza x = xLine yendo hacia la portería; null si no viene. */
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];
}

Para jugar: decide(policy.logits(gkObs(estado, idPortero, equipo, idsRivales, idCompañero)), anterior) y actionToBits(accion, teamMirror(equipo)), con el mismo policy.ts del delantero.

Los casos de prueba traen state, gk, team, humans (rivales), bot (compañero), obs, logits, prev, decided y bits.

Mbappa: delantero, portero y defensor

El mbappa es otro juego: el mapa "Mbappa Clean" en el motor clásico de bonk.io (vista lateral, gravedad, salto, una pelota que rebota mucho, porterías en jaulas). La receta es la misma (PPO, currículo, self-play, física real), pero con otra observación y otras acciones.

Formato bonktools-rl-mbappa/1

Igual al de fútbol, con dos diferencias:

  • actions en lugar de actionTable: 18 tríos [horizontal, vertical, pesado]. Horizontal: 0 nada, 1 ←, 2 →. Vertical: 0 nada, 1 ↑ (salta), 2 ↓ (baja rápido en el aire). Pesado: mantener X.
  • Decisión por argmax (la acción de mayor nota), una cada 100 ms.
VersiónNúmerosQué ve
v1 (el defensor)26Pelota, yo y el rival (posición, velocidad, en el suelo, pesado, vivo) y la pelota respecto a mí, al rival y a las dos jaulas
v238v1 + dónde caerá la pelota, previsión de la pelota a 0,3 s y 0,6 s y una memoria (teclas de la decisión anterior, cuánto tiempo manteniendo ↑, cuánto tiempo en el aire)
v3 (delantero y portero)43v2 + el medidor de X de ambos, si el rival está pesado y si la pelota está encima de una de las jaulas

Eje canónico: el agente siempre ataca hacia la derecha. En el mbappa el que se refleja es el azul (en fútbol es el rojo).

El código

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

/**
 * La IA del mbappa (mapa "Mbappa Clean", motor clásico de bonk.io) en JS puro: la observación exacta del entrenamiento
 * (v1: 26 números; v2: 38, con previsión de la pelota y memoria; v3: 43, + el medidor de X de ambos, la X del rival y la pelota
 * encima de una de las jaulas) y la red (MLP tanh, argmax). Verifica con los casos de prueba publicados junto a cada
 * modelo: una observación distinta haría que el bot juegue mal sin ningún error.
 */

/** Estado del motor clásico: posiciones en unidades del juego, y crece hacia abajo. */
export interface ClassicState {
  ball: { x: number; y: number; xv: number; yv: number };
  /** `heavy` = manteniendo X; `stamina` = medidor de X (0..1000: gasta 10/cuadro mientras se mantiene, recarga 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; // pelota encima del techo de la jaula izquierda (eje canónico)
/** Medidor de X (0..1); sin el campo, lleno (como en el entrenamiento). */
const staminaOf = (d: { stamina?: number }): number => Math.min(Math.max((typeof d.stamina === 'number' ? d.stamina : STAMINA_MAX) / STAMINA_MAX, 0), 1);

/** Memoria del jugador (v2): teclas del último paso, cuadros manteniendo ↑, cuadros en el aire. */
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));

/** Observación desde el punto de vista de `me` (equipo `team`), en el eje canónico (el agente siempre ataca hacia la derecha). */
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)));
}

/** Teclas del juego para la jugada (eje canónico; reflejado: ← y → se intercambian). */
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);
  }

  /** La jugada más probable (argmax de los 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;
  }

  /** Partida nueva: reinicia la memoria. */
  resetMemory(): void {
    this.mem = newMemory();
    this.lastKeys = null;
  }

  /**
   * Las teclas que REALMENTE salieron en este paso, cuando quien usa la red cambió su jugada (sala 2x2 del mbappa: el
   * delantero cede la jugada al portero): la memoria del siguiente paso registra lo que hizo el jugador, como en el entrenamiento.
   */
  noteKeys(keys: number): void {
    this.lastKeys = keys;
  }

  /**
   * Teclas para `me` (equipo `team`) en este estado, llamado cada `frames` cuadros (100 ms = 3, el paso del entrenamiento): la
   * memoria registra las teclas de la decisión anterior y si el jugador está en el aire ahora (el mismo orden del entrenamiento).
   */
  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;
  }
}

Uso: policy.keys(estado, yo, rival, equipo) cada 3 cuadros (100 ms) devuelve las teclas a pulsar y se encarga de la memoria solo. Llama a resetMemory() en cada partida nueva.

Casos de prueba del mbappa

Cada caso trae state (formato ClassicState), me, opp, team, mem ([teclas, cuadrosManteniendoArriba, cuadrosEnElAire]), obs, action (el argmax) y bits (las teclas). Arma la observación con buildObs(state, me, opp, team, {keys, upFrames, airFrames}, version), ejecuta act() y compara.