vimp-engine 0.2.0 → 0.4.0

package/tests/fixtures/miniGame/host/fakeCore.js

@@ -0,0 +1,233 @@
+// Фейковое 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 } });
+    }
+  }
+
+  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] : [];
+  }
+
+  players_data() {
+    return JSON.stringify(
+      [...this._actors.entries()].map(([id, a]) => ({
+        id: Number(id),
+        x: a.x,
+        y: a.y,
+        team: a.team,
+      })),
+    );
+  }
+
+  // ***** игровой тик ***** //
+
+  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/miniGame/host/index.js

@@ -0,0 +1,29 @@
+import { ENGINE_API_VERSION } from '../../../../src/config/opcodes.js';
+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: 'miniGame',
+  engineApi: ENGINE_API_VERSION,
+
+  async createCore(coreConfigJson) {
+    return new FakeGameCore(coreConfigJson);
+  },
+
+  gameConfig,
+  authSchema,
+  chatCommands: [spawnCommand],
+  systemMessages,
+  createModules,
+  buildClientGameConfig: () => clientConfig,
+};

package/tests/fixtures/miniGame/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/miniGame/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/miniGame.contract.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import hostPlugin from './miniGame/host/index.js';
+import clientPlugin from './miniGame/client/index.js';
+import { assertGameConfigShape } from '../../src/lib/gamePlugin.js';
+import { buildCoreConfig } from '../../src/lib/coreConfig.js';
+import { ENGINE_API_VERSION } from '../../src/config/opcodes.js';
+
+// Доказательство «второй игры» (Этап 7 плана отделения движка): миниигра-
+// фикстура удовлетворяет тем же контрактам (§3.2/§3.3 PLAN.md), что и
+// @vimp-games/tanks, — без единого общего файла с игрой.
+describe('miniGame fixture: HostPlugin/ClientPlugin contract', () => {
+  it('HostPlugin.engineApi совпадает с движковым', () => {
+    expect(hostPlugin.engineApi).toBe(ENGINE_API_VERSION);
+  });
+
+  it('gameConfig проходит движковую валидацию формы (§HostPlugin API)', () => {
+    expect(() => assertGameConfigShape(hostPlugin)).not.toThrow();
+  });
+
+  it('createCore возвращает объект с полной поверхностью Wasm Host ABI', async () => {
+    const core = await hostPlugin.createCore(JSON.stringify({ seed: 1 }));
+
+    const abiMethods = [
+      'load_map',
+      'map_info',
+      'clear',
+      'spawn_actor',
+      'remove_actor',
+      'reset_actor',
+      'spawn_scripted_actor',
+      'remove_scripted_actor',
+      'remove_players_and_shots',
+      'apply_input',
+      'last_input_seq',
+      'is_alive',
+      'position_of',
+      'players_data',
+      'step',
+      'take_events',
+      'pack_body',
+      'body_has_events',
+      'pack_frame',
+      'frame_bytes',
+      'reset_all_vitals',
+      'serialize_state',
+      'deserialize_state',
+    ];
+
+    for (const method of abiMethods) {
+      expect(typeof core[method]).toBe('function');
+    }
+  });
+
+  it('gameConfig совместим с общим коллектором конфига ядра (buildCoreConfig)', () => {
+    const config = buildCoreConfig(hostPlugin.gameConfig, { seed: 1 });
+
+    expect(config.engine.mapScale).toBe(hostPlugin.gameConfig.mapScale);
+    expect(config.game.models).toBe(hostPlugin.gameConfig.parts.models);
+    // схема снапшота — игровая (Д1): ядро получает раскладку фикстуры
+    expect(config.engine.snapshot.keys).toBe(hostPlugin.gameConfig.snapshot);
+  });
+
+  it('ClientPlugin несёт минимум 1-2 заглушечных part и совпадающий engineApi', () => {
+    expect(clientPlugin.engineApi).toBe(hostPlugin.engineApi);
+    expect(Object.keys(clientPlugin.parts).length).toBeGreaterThanOrEqual(1);
+    expect(Object.keys(clientPlugin.parts).length).toBeLessThanOrEqual(2);
+  });
+
+  it('stat/panel схемы фикстуры отличаются от танков (одна играющая команда)', () => {
+    const teams = Object.keys(hostPlugin.gameConfig.teams).filter(
+      name => name !== hostPlugin.gameConfig.spectatorTeam,
+    );
+
+    expect(teams).toHaveLength(1);
+  });
+});