vimp-engine 0.22.0 → 0.23.0

package/tests/fixtures/generations/gen-api4/config/game.js

@@ -0,0 +1,156 @@
+// Игровая конфигурация фикстуры «миниигра» (Этап 7 плана отделения
+// движка — HostPlugin.gameConfig): нарочно минимальна и структурно
+// отличается от vimp-tanks/src/config/game.js — доказывает, что
+// движковая мета (Panel/Stat/RoundManager/ParticipantManager/
+// CommandProcessor) настраивается произвольной схемой, а не только
+// схемой танков. Одна играющая команда (team1) вместо двух у танков —
+// проверка нижней границы настраиваемости Stat/RoundManager.
+export default {
+  parts: {
+    models: { m1: { radius: 10 } },
+    weapons: {},
+    friendlyFire: false,
+  },
+
+  // собственная снапшот-схема (нарочно не танковая: один hot-ключ актора
+  // с 4 полями и один event-ключ) — движок обязан работать с любой
+  // раскладкой из gameConfig.snapshot, а не только m1/w1/…/c2
+  snapshot: {
+    a1: {
+      id: 1,
+      kind: 'indexed8',
+      class: 'hot',
+      fields: [
+        { name: 'x', ty: 'f32', interp: 'lerp' },
+        { name: 'y', ty: 'f32', interp: 'lerp' },
+        { name: 'angle', ty: 'f32', interp: 'lerpAngle' },
+        { name: 'team', ty: 'u8' },
+      ],
+    },
+    e1: {
+      id: 2,
+      kind: 'list16',
+      class: 'event',
+      fields: [
+        { name: 'x', ty: 'f32' },
+        { name: 'y', ty: 'f32' },
+      ],
+    },
+  },
+
+  soundCues: {},
+  initialVote: 'teamChange',
+
+  maps: {
+    arena: {
+      setId: 'm1',
+      scale: 1,
+      // имя файла — инертные данные: фикстура host-only, рендера в ней нет
+      // и картинку никто не грузит. Реальные тайлы везёт пакет игры
+      // (`${assetsBase}img/`), движок картинок не раздаёт
+      spriteSheet: { img: 'fixture-tiles.png', frames: [[0, 0, 32, 32]] },
+      layers: { 1: [0] },
+      physicsStatic: [1],
+      physicsDynamic: [],
+      step: 32,
+      // точек не меньше, чем roomDefaults.maxPlayers: длина списка —
+      // жёсткая вместимость команды на карте (RoundManager), и комната
+      // молча вмещала бы меньше, чем обещает лобби
+      respawns: {
+        team1: [
+          [100, 100, 0],
+          [200, 100, 0],
+          [100, 200, 0],
+          [200, 200, 0],
+        ],
+      },
+      map: [
+        [1, 1, 1, 1],
+        [1, 0, 0, 1],
+        [1, 0, 0, 1],
+        [1, 1, 1, 1],
+      ],
+    },
+  },
+  mapScale: 1,
+  currentMap: 'arena',
+  mapsInVote: 1,
+  mapSetId: 'm1',
+
+  roomDefaults: {
+    maxPlayers: 4,
+  },
+
+  // RoundManager/RTTManager (движковые) обновляют status/score/deaths/latency
+  // безусловно (не через схему) — поэтому набор колонок такой же, как у
+  // танков; отличие фикстуры — ОДНА играющая команда (см. teams ниже)
+  stat: {
+    name: {
+      key: 0,
+      bodyMethod: '=',
+      headSync: true,
+      headMethod: '#',
+    },
+    status: {
+      key: 1,
+      bodyMethod: '=',
+      bodyValue: '',
+      headValue: '',
+    },
+    score: {
+      key: 2,
+      bodyMethod: '+',
+      bodyValue: 0,
+      headMethod: '+',
+      headValue: 0,
+    },
+    deaths: {
+      key: 3,
+      bodyMethod: '+',
+      bodyValue: 0,
+      headMethod: '+',
+      headValue: 0,
+    },
+    latency: {
+      key: 4,
+      bodyMethod: '=',
+    },
+  },
+
+  panel: {
+    // поле нарочно не health (Д2): семантику ячейки клиенту задаёт
+    // type в схеме client.js, а не имя поля
+    fields: {
+      energy: {
+        key: 'h',
+        value: 100,
+      },
+    },
+    activeKey: null,
+  },
+
+  scripted: {
+    namePrefix: 'Scripted',
+    defaultModel: 'm1',
+  },
+
+  spectatorTeam: 'spectators',
+
+  teams: {
+    team1: 1,
+    spectators: 2,
+  },
+
+  playerKeys: {
+    forward: {
+      key: 1 << 0,
+    },
+    back: {
+      key: 1 << 1,
+    },
+    fire: {
+      key: 1 << 2,
+      type: 1,
+    },
+  },
+};

package/tests/fixtures/generations/gen-api4/core/pkg-node/core.js

@@ -0,0 +1,4 @@
+// ЗАМОРОЖЕНО. Заглушка node-сборки ядра: ядро поколения — обычный JS
+// (host/fakeCore.js), но манифест обязан объявлять entries.wasmNode,
+// а загрузчик пакета проверяет, что файл на месте.
+export default {};

package/tests/fixtures/generations/gen-api4/host/ScriptedManager.js

@@ -0,0 +1,129 @@
+// Игровой scripted-модуль фикстуры: зеркало
+// vimp-tanks/src/host/TanksBotManager.js — тот же контракт (createMap,
+// createScripted, removeScripted, removeOneForHuman, getCount,
+// getCountsPerTeam), проверяющий, что RoundManager/HostGame/CommandProcessor
+// работают с любым HostPlugin.createModules(ctx), а не только с ботами
+// танков. Worker-safe.
+export default class ScriptedManager {
+  constructor({ participants, coreAdapter, panel, stat, scripted }) {
+    this._participants = participants;
+    this._coreAdapter = coreAdapter;
+    this._panel = panel;
+    this._stat = stat;
+
+    this._model = scripted.defaultModel;
+    this._respawns = null;
+  }
+
+  createMap(mapData) {
+    this._respawns = mapData.respawns;
+  }
+
+  createScripted(count, teamName = null) {
+    if (!this._respawns) {
+      return 0;
+    }
+
+    const playableTeams = this._participants.getPlayableTeams();
+    let createdCount = 0;
+
+    for (let i = 0; i < count; i += 1) {
+      if (this._participants.isFull) {
+        break;
+      }
+
+      let targetTeam = teamName;
+
+      if (!targetTeam) {
+        targetTeam = playableTeams.sort(
+          (a, b) =>
+            this._participants.getTeamSize(a) -
+            this._participants.getTeamSize(b),
+        )[0];
+      }
+
+      if (
+        !targetTeam ||
+        !this._respawns[targetTeam] ||
+        this._participants.getTeamSize(targetTeam) >=
+          this._respawns[targetTeam].length
+      ) {
+        continue;
+      }
+
+      const gameId = this._participants.createScripted({
+        team: targetTeam,
+        model: this._model,
+      });
+      const participant = this._participants.get(gameId);
+
+      this._stat.addUser(gameId, participant.teamId, {
+        name: participant.name,
+        status: 'dead',
+        latency: 'SCRIPTED',
+      });
+      this._panel.addUser(gameId);
+
+      createdCount += 1;
+    }
+
+    return createdCount;
+  }
+
+  removeScripted(teamName = null) {
+    const toRemove = teamName
+      ? this._participants.getScripted().filter(p => p.team === teamName)
+      : this._participants.getScripted();
+
+    toRemove.forEach(p => this._removeById(p.gameId));
+  }
+
+  removeOneForHuman(teamName) {
+    for (const participant of this._participants.getScripted()) {
+      if (participant.team === teamName) {
+        this._removeById(participant.gameId);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  _removeById(gameId) {
+    const participant = this._participants.get(gameId);
+
+    if (!participant || !participant.isScripted) {
+      return;
+    }
+
+    this._stat.removeUser(gameId, participant.teamId);
+    this._panel.removeUser(gameId);
+    this._coreAdapter.removePlayer(gameId);
+
+    this._participants.remove(gameId);
+  }
+
+  getScripted() {
+    return this._participants.getScripted();
+  }
+
+  getCount() {
+    return this._participants.getScripted().length;
+  }
+
+  getCountForTeam(teamName) {
+    return this._participants
+      .getScripted()
+      .filter(p => p.team === teamName).length;
+  }
+
+  getCountsPerTeam() {
+    const counts = {};
+
+    for (const participant of this._participants.getScripted()) {
+      counts[participant.team] = (counts[participant.team] || 0) + 1;
+    }
+
+    return counts;
+  }
+}

package/tests/fixtures/generations/gen-api4/host/createModules.js

@@ -0,0 +1,6 @@
+import ScriptedManager from './ScriptedManager.js';
+
+// Фабрика игровых host-модулей фикстуры (HostPlugin.createModules).
+export default function createModules(ctx) {
+  return { scripted: new ScriptedManager(ctx) };
+}

package/tests/fixtures/generations/gen-api4/host/fakeCore.js

@@ -0,0 +1,263 @@
+// Фейковое JS-ядро миниигры-фикстуры (Этап 7 плана отделения движка,
+// PLAN.md §4/Wasm Host ABI §3.4): реализует полную поверхность методов,
+// которую вызывает GameCoreAdapter, без Rust/WASM — доказательство, что
+// движок не завязан на конкретную реализацию ядра. Актёры — плоские
+// объекты { x, y, angle, team, alive }; тик — тривиальная линейная
+// интеграция скорости (та же идея, что у Rust-фикстуры TestClient,
+// core/src/client/game.rs: форма ABI важнее физики).
+export default class FakeGameCore {
+  constructor(configJson) {
+    this._config = JSON.parse(configJson);
+    this._actors = new Map(); // gameId -> { x, y, angle, team, alive, vx, vy, lastInputSeq }
+    this._map = null;
+    this._events = [];
+    this._lastBody = [];
+    this._lastFrame = null;
+  }
+
+  // ***** карта ***** //
+
+  load_map(mapJson) {
+    this._map = JSON.parse(mapJson);
+  }
+
+  map_info() {
+    if (!this._map) {
+      return 'null';
+    }
+
+    return JSON.stringify({
+      setId: this._map.setId,
+      respawns: this._map.respawns || {},
+    });
+  }
+
+  clear() {
+    this._actors.clear();
+    this._events.length = 0;
+    this._lastBody = [];
+  }
+
+  // ***** участники ***** //
+
+  spawn_actor(gameId, model, teamId, x, y, angle) {
+    this._actors.set(gameId, {
+      x,
+      y,
+      angle,
+      team: teamId,
+      alive: true,
+      vx: 0,
+      vy: 0,
+      lastInputSeq: 0,
+    });
+
+    this._events.push({ type: 'panelSet', id: gameId, field: 'energy', value: 100 });
+  }
+
+  remove_actor(gameId) {
+    this._actors.delete(gameId);
+  }
+
+  reset_actor(gameId, teamId, x, y, angle) {
+    const actor = this._actors.get(gameId);
+
+    if (actor) {
+      Object.assign(actor, { x, y, angle, team: teamId, alive: true, vx: 0, vy: 0 });
+    }
+  }
+
+  reset_all_vitals() {
+    for (const actor of this._actors.values()) {
+      actor.alive = true;
+    }
+  }
+
+  spawn_scripted_actor(gameId, model, teamId, x, y, angle) {
+    this.spawn_actor(gameId, model, teamId, x, y, angle);
+    this._actors.get(gameId).scripted = true;
+  }
+
+  remove_scripted_actor(gameId) {
+    this.remove_actor(gameId);
+  }
+
+  remove_players_and_shots() {
+    const names = [...this._actors.keys()].map(String);
+
+    this._actors.clear();
+
+    return JSON.stringify(names);
+  }
+
+  // ***** ввод ***** //
+
+  apply_input(gameId, seq, action, name) {
+    const actor = this._actors.get(gameId);
+
+    if (!actor) {
+      return;
+    }
+
+    actor.lastInputSeq = seq;
+
+    const magnitude = action === 'down' ? 40 : 0;
+
+    if (name === 'forward') {
+      actor.vy = -magnitude;
+    } else if (name === 'back') {
+      actor.vy = magnitude;
+    } else if (name === 'fire' && action === 'down') {
+      this._events.push({ type: 'custom', data: { kind: 'fire', id: gameId } });
+    }
+  }
+
+  // ввод указателем: миниигра просто запоминает последнюю точку и биты —
+  // движковым тестам важно, что канал доходит до ядра
+  apply_aim(gameId, seq, x, y, flags) {
+    const actor = this._actors.get(gameId);
+
+    if (!actor) {
+      return;
+    }
+
+    actor.lastInputSeq = seq;
+    actor.aim = { x, y, flags };
+  }
+
+  aim_of(gameId) {
+    return this._actors.get(gameId)?.aim ?? null;
+  }
+
+  last_input_seq(gameId) {
+    return this._actors.get(gameId)?.lastInputSeq ?? 0;
+  }
+
+  // ***** запросы состояния ***** //
+
+  is_alive(gameId) {
+    return Boolean(this._actors.get(gameId)?.alive);
+  }
+
+  position_of(gameId) {
+    const actor = this._actors.get(gameId);
+
+    return actor ? [actor.x, actor.y] : [];
+  }
+
+  // FIRST_SHOT_DATA: полный снапшот игроков в раскладке снапшот-схемы
+  // (ключ схемы -> id -> поля), а не плоским списком: ровно её разбирает
+  // клиент (applyShot браузера и VirtualClient._applyGameData). Плоский
+  // список доезжал до клиента ключами '0', '1' — сущность первого кадра
+  // не появлялась на холсте, и видно это только со второго участника
+  players_data() {
+    const entry = Object.entries(
+      this._config.engine?.snapshot?.keys ?? {},
+    ).find(([, spec]) => spec.class === 'hot' && spec.kind === 'indexed8');
+
+    if (!entry) {
+      return '{}';
+    }
+
+    const [key, spec] = entry;
+    const rows = {};
+
+    for (const [id, actor] of this._actors) {
+      rows[id] = spec.fields.map(field => Number(actor[field.name] ?? 0));
+    }
+
+    return JSON.stringify({ [key]: rows });
+  }
+
+  // ***** игровой тик ***** //
+
+  step(dt) {
+    for (const actor of this._actors.values()) {
+      actor.x += actor.vx * dt;
+      actor.y += actor.vy * dt;
+    }
+  }
+
+  take_events() {
+    const events = this._events;
+
+    this._events = [];
+
+    return JSON.stringify(events);
+  }
+
+  // ***** упаковка снапшота (фикстурный формат — не бинарный кодек ядра;
+  // достаточно для тестов меты, которые не декодируют реальный фрейминг) ***** //
+
+  // поля записи — по снапшот-схеме фикстуры (config/game.js, ключ a1):
+  // x, y, angle, team; клиентская половина фикстуры раскладывает их в
+  // hot-буфер той же ширины, что заявлена схемой
+  pack_body() {
+    this._lastBody = [...this._actors.entries()].map(([id, a]) => ({
+      id: Number(id),
+      x: a.x,
+      y: a.y,
+      angle: a.angle,
+      team: a.team,
+    }));
+  }
+
+  body_has_events() {
+    return false;
+  }
+
+  pack_frame(serverTime, seq, hasCamera, camX, camY, forceReset, shake, playerId) {
+    this._lastFrame = {
+      serverTime,
+      seq,
+      camera: hasCamera ? [camX, camY, Boolean(forceReset), shake ?? null] : null,
+      playerId,
+      body: this._lastBody,
+    };
+  }
+
+  frame_bytes() {
+    return new TextEncoder().encode(JSON.stringify(this._lastFrame));
+  }
+
+  // ***** отладка ***** //
+
+  // форма дампа — та же, что у движкового crate::debug (тела/карта/rng),
+  // с поправкой на фикстуру без физики: актёры и есть тела
+  debug_json() {
+    return JSON.stringify({
+      bodies: [...this._actors.entries()].map(([id, a]) => ({
+        handle: Number(id),
+        tag: 2,
+        userData: String(id),
+        translation: [a.x, a.y],
+        rotation: a.angle,
+        linvel: [a.vx, a.vy],
+        angvel: 0,
+        mass: 1,
+        bodyType: 'Dynamic',
+        ccd: false,
+      })),
+      colliders: [],
+      map: this._map
+        ? { setId: this._map.setId, step: this._map.step ?? null }
+        : null,
+      nav: null,
+      spatial: { cells: 0, entities: 0, cellCounts: [] },
+      rng: { state: '0' },
+      step: { timeStep: this._config.timeStep ?? null, accumulator: 0 },
+    });
+  }
+
+  // ***** handoff (задел, PLAN.md §6 «открытые вопросы») ***** //
+
+  serialize_state() {
+    return new TextEncoder().encode(JSON.stringify([...this._actors.entries()]));
+  }
+
+  deserialize_state(bytes) {
+    const entries = JSON.parse(new TextDecoder().decode(bytes));
+
+    this._actors = new Map(entries);
+  }
+}

package/tests/fixtures/generations/gen-api4/host/index.js

@@ -0,0 +1,30 @@
+// ЗАМОРОЖЕНО. Снимок плагина 2026-08-29 (поколение engineApi: 4).
+// Не править: правка фикстуры маскирует слом совместимости.
+import FakeGameCore from './fakeCore.js';
+import gameConfig from '../config/game.js';
+import authSchema from '../config/auth.js';
+import clientConfig from '../config/client.js';
+import systemMessages from './systemMessages.js';
+import spawnCommand from './spawnCommand.js';
+import createModules from './createModules.js';
+
+// HostPlugin миниигры-фикстуры (Этап 7 плана отделения движка, PLAN.md
+// §3.2): доказывает, что HostGame и движковая мета работают с любым
+// HostPlugin, реализующим контракт — не только с @vimp-games/tanks. createCore
+// не грузит WASM (fake-core — обычный JS-класс), поэтому фикстура не
+// требует собранного Rust-ядра игры.
+export default {
+  id: 'gen-api4',
+  engineApi: 4,
+
+  async createCore(coreConfigJson) {
+    return new FakeGameCore(coreConfigJson);
+  },
+
+  gameConfig,
+  authSchema,
+  chatCommands: [spawnCommand],
+  systemMessages,
+  createModules,
+  buildClientGameConfig: () => clientConfig,
+};

package/tests/fixtures/generations/gen-api4/host/spawnCommand.js

@@ -0,0 +1,14 @@
+// Игровая чат-команда фикстуры: '/spawn <count>' — создаёт scripted-
+// участников без голосования (зеркало vimp-tanks/src/host/botCommand.js,
+// упрощённое — доказывает только регистрацию HostPlugin.chatCommands).
+// Регистрируется в движковом CommandProcessor.
+export default {
+  name: '/spawn',
+  handler(ctx, gameId, args) {
+    const count = Number(args[0]) || 1;
+    const created = ctx.scripted.createScripted(count);
+
+    ctx.chat.pushSystem('SCRIPTED_SPAWNED', [created]);
+    ctx.roundManager.initiateNewRound();
+  },
+};

package/tests/fixtures/generations/gen-api4/host/systemMessages.js

@@ -0,0 +1,6 @@
+// Игровые коды системных сообщений фикстуры (группа g:*) — зеркало
+// vimp-tanks/src/host/systemMessages.js (группа b:*). Merge в движковый
+// реестр через registerCodes (HostGame конструктор).
+export default {
+  SCRIPTED_SPAWNED: 'g:0', // {0} scripted participant(s) spawned
+};

package/tests/fixtures/generations/gen-api4/manifest.json

@@ -0,0 +1,17 @@
+{
+  "id": "gen-api4",
+  "engineApi": 4,
+  "assetsBase": "",
+  "entries": {
+    "host": "host/index.js",
+    "client": "client/index.js",
+    "wasm": "core/pkg-web/core_bg.wasm",
+    "wasmNode": "core/pkg-node/core.js"
+  },
+  "roomDefaults": {
+    "maxPlayers": 4
+  },
+  "maps": [
+    "arena"
+  ]
+}

package/tests/fixtures/miniGame/client/fakeClientCore.js

@@ -301,4 +301,21 @@ export default class FakeClientCore {
       return 'null';
     }
   }
+
+  // ***** расширение (этап 4 плана plugin-forward-compat) ***** //
+
+  // самоописание: фикстура представляет ядро текущего поколения, поэтому
+  // отвечает так же, как раскрытие движкового макроса
+  abi_describe() {
+    return JSON.stringify({ abi: 1, core: 'fixture', ops: ['debug.json'] });
+  }
+
+  // опкод вместо нового символа: пустой ответ — «не обработан»
+  dispatch(op) {
+    if (op === 'debug.json') {
+      return new TextEncoder().encode(this.debug_json());
+    }
+
+    return new Uint8Array(0);
+  }
 }