Utiliser l'IA
Mettre l'IA dans votre salon
Faites jouer le compte du salon avec l'IA : observation, réseau, décision sans zigzag, les « yeux » sans retard et un salon « défiez l'IA » complet.
Ici, le compte qui héberge le salon entre sur le terrain et joue avec l'IA. Tout tourne en Node, à côté du salon, sans Python. Le code est dans le projet d'exemple, dossier src/ia/.
Le plus rapide
- Téléchargez le projet d'exemple et le modèle. Mettez
football-1x1.policy.jsondans le dossier du projet. - Dans le
.env:MODO=ia(et, si vous voulez,IA_MODELO=chemin/du/modele.json). npm run dev, entrez dans le salon et défiez l'IA.
Qui entre va dans une file ; l'IA joue en bleu contre le premier de la file. Qui bat l'IA reste ; qui perd retourne en fin de file.
Comment ça marche, pièce par pièce
ScoreTracker « yeux » (sans retard) ──'state' toutes les 100 ms──► JogadorIA
│ buildObs() → 39 nombres
│ policy.logits() → 18 notes
│ decide() → action, sans zigzag
│ actionToBits() → touches (inversées si rouge)
▼
room.sendInput(touches) ──► serveur bonk.io ──► joueurs
tracker.recordOwnInput() (la simulation locale doit aussi le savoir)1. L'observation : features.ts
C'est la partie la plus délicate : elle doit être identique à celle de l'entraînement. N'y touchez pas sans vérifier avec les cas de test.
// features.ts
/**
* Observation et actions de l'IA de football de BonkTools — exactement comme elle a été entraînée.
*
* Toute différence (une échelle, un signe, un champ absent traité autrement) fait mal jouer l'IA
* SANS aucune erreur. Vérifiez votre version avec les cas de test publiés avec le modèle.
*
* Axe canonique : le bot "attaque toujours vers la droite". En rouge (attaque vers la gauche), x et les
* vitesses en x sont inversées dans l'observation et gauche/droite échangées dans l'action.
*
* Versions de l'observation (la politique indique laquelle dans `obsVersion`/`obsSize`) : v1 = 25 nombres ; v2 = 39 (v1 + poteaux,
* murs, alignement ballon-but et vitesse du ballon par rapport au bot).
*/
export const TEAM_RED = 2;
export const TEAM_BLUE = 3;
const CENTER_X = 33.18;
const CENTER_Y = 22.73;
const HALF_W = 33.0;
const HALF_H = 22.7;
const GOAL_X = 64.0;
const OWN_GOAL_X = 2 * CENTER_X - GOAL_X;
const PLAYER_MAX_SPEED = 11.7;
const BALL_MAX_SPEED = 20.0;
export const LEFT = 1;
export const RIGHT = 2;
export const UP = 4;
export const DOWN = 8;
export const KICK = 16;
const DIRS = [0, UP, UP | RIGHT, RIGHT, DOWN | RIGHT, DOWN, DOWN | LEFT, LEFT, UP | LEFT];
/** 9 directions (immobile compris) x {sans tir, tir} — même ordre qu'à l'entraînement. */
export const ACTION_TABLE: readonly number[] = [...DIRS, ...DIRS.map((d) => d | KICK)];
/** Taille de l'observation par version. 101 = celle du gardien entraîné par RL (goleiro-rl.ts). */
export const OBS_SIZES: Readonly<Record<number, number>> = { 1: 25, 2: 39, 101: 27 };
export const OBS_SIZE = OBS_SIZES[1]!;
// Géométrie de la v2 (axe canonique).
const POST_X = 64.09;
const POST_Y_TOP = CENTER_Y - 6.5;
const POST_Y_BOTTOM = CENTER_Y + 6.5;
const PLAYER_X_MIN = 1.0;
const PLAYER_X_MAX = 65.36;
const PLAYER_Y_MIN = 1.0;
const PLAYER_Y_MAX = 44.45;
const BALL_Y_MIN = 7.79;
const BALL_Y_MAX = 37.67;
/** Version de l'observation d'après la taille d'entrée du réseau (25 -> 1, 39 -> 2) ; null si inexistante. */
export function versionForSize(size: number): number | null {
for (const [v, n] of Object.entries(OBS_SIZES)) if (n === size) return Number(v);
return null;
}
export function mirrorBits(bits: number): number {
let rest = bits & ~(LEFT | RIGHT);
if (bits & LEFT) rest |= RIGHT;
if (bits & RIGHT) rest |= LEFT;
return rest;
}
export function actionToBits(action: number, mirror: boolean): number {
const bits = ACTION_TABLE[action] ?? 0;
return mirror ? mirrorBits(bits) : bits;
}
/** L'équipe attaque vers la gauche (rouge) — il faut inverser vers l'axe canonique. */
export function teamMirror(team: number): boolean {
return team === TEAM_RED;
}
interface Body {
x: number;
y: number;
xv: number;
yv: number;
kickReady?: boolean;
}
const ZERO: Body = { x: CENTER_X, y: CENTER_Y, xv: 0, yv: 0, kickReady: false };
/** null/undefined et un objet VIDE comptent comme absents (comme l'entraînement Python). */
function isBody(v: unknown): v is Body {
return !!v && typeof v === 'object' && Object.keys(v).length > 0;
}
/** État du ScoreTracker/PhysicsSimulator (ball, discs[], ftu). Absent = immobile au centre du terrain. */
export interface GameStateLike {
ball?: unknown;
discs?: unknown;
ftu?: unknown;
}
function ball(state: GameStateLike): Body {
return isBody(state.ball) ? state.ball : ZERO;
}
function disc(state: GameStateLike, id: number): Body {
const discs = Array.isArray(state.discs) ? state.discs : [];
const d: unknown = id >= 0 && id < discs.length ? discs[id] : null;
return isBody(d) ? d : ZERO;
}
function canon(b: Body, mirror: boolean): [number, number, number, number] {
return mirror ? [2 * CENTER_X - b.x, b.y, -b.xv, b.yv] : [b.x, b.y, b.xv, b.yv];
}
const clip = (v: number): number => Math.min(2, Math.max(-2, v));
/**
* Projette l'état de `leadFrames` images (30/s) EN AVANT : positions += vitesse × temps (sans collisions) et l'horloge de
* gel du coup d'envoi (`ftu`) avancée.
*
* La simulation locale du salon tourne exprès 6 images (200 ms) derrière l'horloge, pour que les touches en retard du réseau
* arrivent (et que le score automatique n'annonce pas un but qu'une touche en retard annulerait). Le bot décidait sur ce passé :
* dans le simulateur, avec 200 ms de retard l'IA perdait TOUS les coups d'envoi contre un attaquant qui tire en première intention ;
* en projetant, elle n'encaisse plus de buts sur l'engagement.
*/
export function projectState(state: GameStateLike, leadFrames: number): GameStateLike {
if (!(leadFrames > 0)) return state;
const dt = leadFrames / 30;
const move = (v: unknown): unknown => {
if (!isBody(v)) return v;
const b = v as Body & Record<string, unknown>;
return { ...b, x: b.x + b.xv * dt, y: b.y + b.yv * dt };
};
const out: GameStateLike = { ...state, ball: move(state.ball) };
if (Array.isArray(state.discs)) out.discs = state.discs.map(move);
if (typeof state.ftu === 'number' && state.ftu > 0) out.ftu = Math.max(state.ftu - leadFrames, 0);
return out;
}
function unit(dx: number, dy: number): [number, number] {
const n = Math.hypot(dx, dy);
return n > 1e-6 ? [dx / n, dy / n] : [0, 0];
}
/** Observation (float32 comme dans NumPy) du point de vue de `selfId`, en version `version` (1 = 25, 2 = 39 nombres). */
export function buildObs(
state: GameStateLike,
selfId: number,
oppId: number,
mirror: boolean,
version = 1,
): Float32Array {
const v1 = buildObsV1(state, selfId, oppId, mirror);
if (version === 1) return v1;
if (version !== 2) throw new Error(`versão de observação desconhecida: ${version}`);
const out = new Float32Array(OBS_SIZES[2]!);
out.set(v1);
out.set(extraV2(state, selfId, mirror), v1.length);
return out;
}
function extraV2(state: GameStateLike, selfId: number, mirror: boolean): Float32Array {
const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
const [bx, by, bxv, byv] = canon(ball(state), mirror);
const ownX = 2 * CENTER_X - POST_X;
const [ax, ay] = unit(bx - sx, by - sy);
const [gx, gy] = unit(POST_X - bx, CENTER_Y - by);
const [dx, dy] = unit(sx - bx, sy - by);
const [ox, oy] = unit(ownX - bx, CENTER_Y - by);
const values = [
(POST_X - sx) / HALF_W, (POST_Y_TOP - sy) / HALF_H, (POST_Y_BOTTOM - sy) / HALF_H, (sx - ownX) / HALF_W,
(sx - PLAYER_X_MIN) / HALF_W, (PLAYER_X_MAX - sx) / HALF_W,
(sy - PLAYER_Y_MIN) / HALF_H, (PLAYER_Y_MAX - sy) / HALF_H,
(by - BALL_Y_MIN) / HALF_H, (BALL_Y_MAX - by) / HALF_H,
ax * gx + ay * gy, dx * ox + dy * oy,
(bxv - sxv) / BALL_MAX_SPEED, (byv - syv) / BALL_MAX_SPEED,
];
const out = new Float32Array(values.length);
for (let i = 0; i < values.length; i++) out[i] = clip(Math.fround(values[i]!));
return out;
}
function buildObsV1(state: GameStateLike, selfId: number, oppId: number, mirror: boolean): Float32Array {
const [sx, sy, sxv, syv] = canon(disc(state, selfId), mirror);
const [ox, oy, oxv, oyv] = canon(disc(state, oppId), mirror);
const [bx, by, bxv, byv] = canon(ball(state), mirror);
// Python : `state.get("ftu", -1) or 0` — absent devient -1 ; 0/None deviennent 0.
const rawFtu = state.ftu === undefined ? -1 : typeof state.ftu === 'number' ? state.ftu : 0;
const px = (x: number): number => (x - CENTER_X) / HALF_W;
const py = (y: number): number => (y - CENTER_Y) / HALF_H;
const dSelf = Math.hypot(bx - sx, by - sy);
const dOpp = Math.hypot(bx - ox, by - oy);
const values = [
px(sx), py(sy), sxv / PLAYER_MAX_SPEED, syv / PLAYER_MAX_SPEED,
px(bx), py(by), bxv / BALL_MAX_SPEED, byv / BALL_MAX_SPEED,
px(ox), py(oy), oxv / PLAYER_MAX_SPEED, oyv / PLAYER_MAX_SPEED,
(bx - sx) / HALF_W, (by - sy) / HALF_H,
(bx - ox) / HALF_W, (by - oy) / HALF_H,
(GOAL_X - bx) / HALF_W, (CENTER_Y - by) / HALF_H,
(bx - OWN_GOAL_X) / HALF_W, (by - CENTER_Y) / HALF_H,
dSelf / HALF_W, dOpp / HALF_W,
disc(state, selfId).kickReady ? 1 : 0,
disc(state, oppId).kickReady ? 1 : 0,
Math.min(Math.max(rawFtu, 0), 120) / 120,
];
// np.array(..., dtype=float32) arrondit chaque valeur en float32 AVANT le clip (qui compare en float32).
const out = new Float32Array(OBS_SIZE);
for (let i = 0; i < OBS_SIZE; i++) out[i] = clip(Math.fround(values[i]!));
return out;
}2. Le réseau et la décision : policy.ts
Lit le policy.json, exécute les trois couches et décide axe par axe (voir pourquoi dans Télécharger les modèles).
// policy.ts
import { readFileSync } from 'node:fs';
import { ACTION_TABLE, DOWN, KICK, LEFT, OBS_SIZES, RIGHT, UP, versionForSize } from './features.js';
/**
* Le réseau de l'IA (le policy.json publié), en JS pur — sans Python ni PyTorch sur la machine du salon. Petit MLP : obs(25 en v1, 39 en v2 — `obsVersion`) -> 256 -> tanh -> 256 -> tanh -> 18 logits ;
* l'action est l'argmax (le coup le plus probable). Poids en float32 base64.
*/
export const POLICY_FORMAT = 'bonktools-rl-policy/1';
interface LayerJson {
in: number;
out: number;
w: string;
b: string;
}
export interface PolicyJson {
format: string;
obsSize: number;
/** Version de l'observation (features.ts). Absente des anciennes politiques : déduite de obsSize. */
obsVersion?: number;
actionTable: number[];
activation: string;
layers: LayerJson[];
timesteps?: number;
exportedAt?: string;
}
interface Layer {
inSize: number;
outSize: number;
/** out x in, ligne par ligne (même disposition que le `weight` de PyTorch). */
w: Float32Array;
b: Float32Array;
}
function floats(b64: string, expected: number, what: string): Float32Array {
const buf = Buffer.from(b64, 'base64');
if (buf.length !== expected * 4) throw new Error(`política inválida: ${what} tem ${buf.length / 4} valores, esperado ${expected}`);
// Copie dans un tampon aligné (celui du base64 peut commencer à n'importe quel offset).
const out = new Float32Array(expected);
for (let i = 0; i < expected; i++) out[i] = buf.readFloatLE(i * 4);
return out;
}
export class Policy {
readonly timesteps: number;
readonly exportedAt: string;
/** Version d'observation attendue par ce réseau (à passer à `buildObs`). */
readonly obsVersion: number;
private readonly layers: Layer[];
constructor(json: PolicyJson) {
if (json.format !== 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}`);
const version = json.obsVersion ?? versionForSize(json.obsSize);
if (version === null || OBS_SIZES[version] !== json.obsSize) {
throw new Error(`política espera ${json.obsSize} entradas (versão ${String(json.obsVersion ?? '?')}); a sala não conhece essa observação`);
}
this.obsVersion = version;
if (json.actionTable.length !== ACTION_TABLE.length || json.actionTable.some((v, i) => v !== ACTION_TABLE[i])) {
throw new Error('tabela de ações da política não bate com a da sala (features.ts)');
}
this.layers = json.layers.map((l, i) => ({
inSize: l.in,
outSize: l.out,
w: floats(l.w, l.in * l.out, `camada ${i} (pesos)`),
b: floats(l.b, l.out, `camada ${i} (bias)`),
}));
for (let i = 1; i < this.layers.length; i++) {
if (this.layers[i]!.inSize !== this.layers[i - 1]!.outSize) throw new Error(`política inválida: camada ${i} não encaixa na anterior`);
}
if (this.layers[0]?.inSize !== json.obsSize || this.layers.at(-1)?.outSize !== ACTION_TABLE.length) {
throw new Error('política inválida: entrada/saída não batem com a observação/ações');
}
this.timesteps = json.timesteps ?? 0;
this.exportedAt = json.exportedAt ?? '';
}
static fromFile(file: string): Policy {
return new Policy(JSON.parse(readFileSync(file, 'utf8')) as PolicyJson);
}
/** Logits de chaque action (tanh dans les couches cachées, linéaire dans la dernière). */
logits(obs: ArrayLike<number>): Float64Array {
let x: ArrayLike<number> = obs;
for (let li = 0; li < this.layers.length; li++) {
const { inSize, outSize, w, b } = this.layers[li]!;
const y = new Float64Array(outSize);
for (let o = 0; o < outSize; o++) {
let s = b[o]!;
const row = o * inSize;
for (let i = 0; i < inSize; i++) s += w[row + i]! * x[i]!;
y[o] = li < this.layers.length - 1 ? Math.tanh(s) : s;
}
x = y;
}
return x as Float64Array;
}
/** Action déterministe (indice dans ACTION_TABLE) : argmax brut. En direct on utilise `decide` (sans zigzag). */
act(obs: ArrayLike<number>): number {
const l = this.logits(obs);
let best = 0;
for (let i = 1; i < l.length; i++) if (l[i]! > l[best]!) best = i;
return best;
}
}
/** Marges de la décision axe par axe (mesurées dans le simulateur). */
export const AXIS_MARGIN = 0.25;
export const FLIP_MARGIN = 0.7;
function axis(pPos: number, pNeg: number, prev: number): number {
const diff = pPos - pNeg;
const needPos = prev < 0 ? FLIP_MARGIN : AXIS_MARGIN;
const needNeg = prev > 0 ? FLIP_MARGIN : AXIS_MARGIN;
if (diff > needPos) return 1;
if (-diff > needNeg) return -1;
return 0;
}
/**
* Décide le coup AXE PAR AXE à partir des logits
* L'argmax des 18 actions alternait "diagonale haut"/"diagonale bas" presque à égalité à chaque décision : le bot
* zigzaguait et n'allait jamais droit (42 inversions/min en vrais matchs ; humains, ~1). Ici chaque axe
* vient de la probabilité cumulée de chaque côté ; égalité = aucune touche sur cet axe (va droit), et inverser le sens
* précédent exige un écart plus grand (hystérésis). Tir si P(tir) > 0,5.
*/
export function decide(logits: ArrayLike<number>, prevAction: number | null): number {
let max = -Infinity;
for (let i = 0; i < logits.length; i++) max = Math.max(max, logits[i]!);
const p = new Float64Array(logits.length);
let sum = 0;
for (let i = 0; i < logits.length; i++) sum += p[i] = Math.exp(logits[i]! - max);
let up = 0, down = 0, left = 0, right = 0, kick = 0;
for (let i = 0; i < p.length; i++) {
const q = p[i]! / sum;
const b = ACTION_TABLE[i]!;
if (b & UP) up += q;
if (b & DOWN) down += q;
if (b & LEFT) left += q;
if (b & RIGHT) right += q;
if (b & KICK) kick += q;
}
const pb = prevAction === null ? 0 : ACTION_TABLE[prevAction] ?? 0;
const v = axis(down, up, pb & UP ? -1 : pb & DOWN ? 1 : 0); // +1 = bas (y augmente vers le bas)
const h = axis(right, left, pb & RIGHT ? 1 : pb & LEFT ? -1 : 0);
let bits = (v > 0 ? DOWN : v < 0 ? UP : 0) | (h > 0 ? RIGHT : h < 0 ? LEFT : 0);
if (kick > 0.5) bits |= KICK;
return ACTION_TABLE.indexOf(bits);
}3. Le joueur : jogador-ia.ts
// jogador-ia.ts
import type { BonkRoom, ScoreTracker, StateInfo } from 'bonktools';
import { actionToBits, buildObs, projectState, teamMirror } from './features.js';
import { decide, type Policy } from './policy.js';
/**
* Fait JOUER le bot (le compte qui héberge le salon) avec l'IA : à chaque nouvel état de la simulation (100 ms),
* il construit l'observation, exécute le réseau et appuie sur les touches.
*/
export class JogadorIA {
private partida: { eu: number; adversario: number; espelho: boolean } | null = null;
private ultimasTeclas = -1; // dernière combinaison envoyée (on n'envoie qu'au changement, comme un vrai clavier)
private ultimaAcao: number | null = null; // la décision axe par axe compare avec la précédente (évite le zigzag)
constructor(
private readonly room: BonkRoom,
/** Le ScoreTracker du salon (score) : la touche du bot doit y être injectée. */
private readonly placar: ScoreTracker,
private readonly policy: Policy,
/**
* "Yeux" sans retard (optionnel) : un 2e ScoreTracker avec lagFrames 0. Sans lui, l'IA voit l'état
* du score, qui a 200 ms de retard, et nous projetons cet état vers le présent.
*/
private readonly olhos?: ScoreTracker,
/** Signale chaque touche envoyée (l'enregistreur de replays en a besoin). */
private readonly aoTeclar?: (id: number, k: { i: number; f: number; c: number }) => void,
) {
(olhos ?? placar).on('state', this.aoEstado);
}
/** `time` (équipe) : 3 = bleu (attaque vers la droite), 2 = rouge (l'IA inverse le terrain). */
comecar(eu: number, adversario: number, time: number): void {
this.partida = { eu, adversario, espelho: teamMirror(time) };
this.ultimasTeclas = -1;
this.ultimaAcao = null;
}
parar(): void {
this.partida = null;
this.enviar(0); // relâche toutes les touches
}
private readonly aoEstado = ({ state }: StateInfo): void => {
const p = this.partida;
if (!p || !state || typeof state !== 'object') return;
// sans "yeux", l'état a 6 images (200 ms) de retard : on le projette à maintenant
const visto = this.olhos ? state : projectState(state, 6);
const obs = buildObs(visto, p.eu, p.adversario, p.espelho, this.policy.obsVersion);
const acao = decide(this.policy.logits(obs), this.ultimaAcao);
this.ultimaAcao = acao;
this.enviar(actionToBits(acao, p.espelho));
};
private enviar(teclas: number): void {
if (teclas === this.ultimasTeclas || this.partida === null && teclas !== 0) return;
this.ultimasTeclas = teclas;
const eu = this.partida?.eu ?? this.room.state.myId;
if (eu === null) return;
const k = this.room.sendInput(teclas);
// Le serveur ne renvoie pas à l'hôte la touche qu'il a lui-même envoyée : sans ceci, la simulation locale
// croirait le bot immobile et l'IA "verrait" un autre match que le vrai.
this.placar.recordOwnInput(eu, k.i, k.f, k.c);
this.olhos?.recordOwnInput(eu, k.i, k.f, k.c);
this.aoTeclar?.(eu, k);
}
destroy(): void {
(this.olhos ?? this.placar).off('state', this.aoEstado);
this.partida = null;
}
}Trois détails qui changent tout :
recordOwnInput. Le serveur ne renvoie pas à l'hôte la touche qu'il a lui-même envoyée. Sans l'enregistrer dans la simulation locale, celle-ci croirait le bot immobile et l'IA « verrait » un autre match que le vrai.- N'envoie une touche que quand elle change, comme un vrai clavier. Envoyer toutes les 100 ms alourdit l'historique que reçoivent ceux qui arrivent en cours de match.
- Relâche tout à la fin (
parar(), « arrêter », envoie 0) ; sinon le disque du bot continue de bouger tout seul au match suivant.
4. Les « yeux » : pourquoi deux ScoreTrackers
Le ScoreTracker du score tourne exprès 200 ms derrière l'horloge : il attend les touches en retard du réseau pour ne jamais annoncer un but qui n'a pas eu lieu. Parfait pour le score, terrible pour jouer : l'IA déciderait sur le passé.
C'est pourquoi le salon « défiez l'IA » crée un second ScoreTracker avec lagFrames: 0 : les « yeux ». Il simule jusqu'à l'instant présent et, quand une touche en retard arrive, revient en arrière et refait ce passage.
| Configuration du salon | Entraînez avec | Résultat mesuré (100 actions contre le script le plus fort) |
|---|---|---|
Avec les « yeux » (lagFrames: 0), sans projection | --visao agora (par défaut) | 95 buts, 2 encaissés |
Seulement le score (200 ms derrière) + projectState(état, 6) | --visao atrasada | 68 buts, 13 encaissés |
5. Le salon « défiez l'IA » : sala-ia.ts
// sala-ia.ts
import { ScoreTracker, TEAM_BLUE, TEAM_RED, TEAM_SPEC, type BonkRoom } from 'bonktools';
import { falar } from '../chat.js';
import { JogadorIA } from './jogador-ia.js';
import { Policy } from './policy.js';
/** Salon "défiez l'IA" : l'IA est en bleu et chaque joueur de la file joue contre elle. Le gagnant reste. */
export class SalaIA {
private readonly placar: ScoreTracker;
private readonly olhos: ScoreTracker;
private readonly ia: JogadorIA;
private fila: number[] = [];
private adversario: number | null = null;
private timer: NodeJS.Timeout | null = null;
constructor(private readonly room: BonkRoom, arquivoModelo = 'football-1x1.policy.json') {
this.placar = new ScoreTracker(room, { cacheDir: '.cache/bonk-client' });
this.olhos = new ScoreTracker(room, { cacheDir: '.cache/bonk-client', lagFrames: 0 });
this.ia = new JogadorIA(room, this.placar, Policy.fromFile(arquivoModelo), this.olhos);
room.on('player-join', (p) => {
this.fila.push(p.id);
falar(room, `${p.userName}, você está na fila para desafiar a IA (posição ${this.fila.length})`);
this.proxima();
});
room.on('player-leave', (p) => {
this.fila = this.fila.filter((id) => id !== p.id);
if (p.id === this.adversario) this.encerrar(null);
});
this.placar.on('score', ({ scores }) => falar(room, `IA ${scores[TEAM_BLUE]} x ${scores[TEAM_RED]} desafiante`));
this.placar.on('match-winner', ({ team }) => {
falar(room, team === TEAM_BLUE ? 'a IA venceu!' : 'você venceu a IA!');
this.timer = setTimeout(() => this.encerrar(team), 4_000); // après l'écran de victoire
});
void this.placar.start();
void this.olhos.start();
room.lockTeams();
}
private proxima(): void {
const eu = this.room.state.myId;
if (this.adversario !== null || !this.fila.length || eu === null) return;
const adv = this.fila[0]!;
this.adversario = adv;
for (const id of this.room.state.players.keys()) {
this.room.setTeam(id, id === eu ? TEAM_BLUE : id === adv ? TEAM_RED : TEAM_SPEC);
}
setTimeout(async () => {
const escalacao: Array<{ id: number; team: number } | null> = [];
escalacao[eu] = { id: eu, team: TEAM_BLUE };
escalacao[adv] = { id: adv, team: TEAM_RED };
const is = await this.placar.buildInitialState(escalacao);
if (!is || this.adversario !== adv) return void this.encerrar(null);
this.room.startGame({ is });
this.ia.comecar(eu, adv, TEAM_BLUE);
}, 1_000); // laisse le temps aux changements d'équipe d'arriver au serveur
}
/** Fin du match. `vencedor` (vainqueur) null = annulé. Celui qui a perdu contre l'IA va en fin de file. */
private encerrar(vencedor: number | null): void {
const adv = this.adversario;
this.adversario = null;
this.ia.parar();
this.room.stopGame();
this.room.emit('game-end', { type: 'GAME_END' });
if (adv !== null && vencedor === TEAM_BLUE && this.fila.includes(adv)) {
this.fila = [...this.fila.filter((id) => id !== adv), adv];
}
setTimeout(() => this.proxima(), 2_000);
}
destroy(): void {
if (this.timer) clearTimeout(this.timer);
this.ia.destroy();
this.placar.stop();
this.olhos.stop();
}
}Pour entrer sur le terrain, le bot se place dans une équipe (room.setTeam(eu, TEAM_BLUE)) et l'état initial est généré avec lui dans la composition, comme n'importe quel joueur.
Enregistrer les matchs de l'IA
Si vous utilisez aussi l'enregistreur, passez-lui les touches du bot (peer-input n'apporte pas celles de l'hôte lui-même) :
const gravador = new Gravador(room, placar);
const ia = new JogadorIA(room, placar, policy, olhos, (id, tecla) => gravador.teclaPropria(id, tecla));Changer de modèle sans redémarrer le salon
Dans les salons BonkTools, le modèle était changé salon plein : chaque minute, le bot vérifiait la date du fichier et, si elle avait changé, chargeait le nouveau (en gardant l'ancien si le nouveau était cassé). C'est une bonne idée si vous entraînez et mettez à jour souvent :
let mtime = 0;
setInterval(() => {
const m = statSync(arquivo).mtimeMs;
if (m === mtime) return;
try { policy = Policy.fromFile(arquivo); mtime = m; } catch { /* fichier invalide : on garde l'actuel */ }
}, 60_000);Idées
- Difficulté réglable : avec une probabilité p, remplacez la décision par une action aléatoire ou gardez la touche précédente un tick de plus. C'est ainsi que l'adversaire scripté de l'entraînement a de l'« habileté ».
- 2v2 avec IA : deux
JogadorIAne fonctionnent pas sur le même compte (un compte = un joueur). Pour deux bots, connectez un second compte avecjoinRoom()et donnez-lui son propreJogadorIA. Les autres modèles (gardien, mbappa) sont dans Télécharger les modèles. - Entraîner avec les matchs de votre salon : enregistrez les matchs contre des humains et utilisez les vraies actions comme scénarios d'entraînement. C'est ce qui a le plus aidé notre IA à défendre (voir Ce que nous avons appris).