vimp-engine 0.3.0 → 0.4.0

package/tests/fixtures/miniGame/client/parts/Actor.js

@@ -0,0 +1,18 @@
+// Заглушечный part фикстуры (ClientPlugin.parts, PLAN.md §3.3) — минимальная
+// форма рендер-сущности: конструктор + update(state)/destroy(), без PixiJS
+// (тесты не поднимают живой канвас). Доказывает, что Factory/CanvasManager
+// не требуют конкретно PixiJS-Container-класса — только этот интерфейс.
+export default class Actor {
+  constructor(id) {
+    this.id = id;
+    this.destroyed = false;
+  }
+
+  update(state) {
+    this.state = state;
+  }
+
+  destroy() {
+    this.destroyed = true;
+  }
+}

package/tests/fixtures/miniGame/client/parts/ActorRadar.js

@@ -0,0 +1,7 @@
+import Actor from './Actor.js';
+
+// Второй заглушечный part фикстуры — радар-проекция того же актёра,
+// зеркало пары Tank/TankRadar танков (доказывает, что gameSets/
+// entitiesOnCanvas умеют распределять одну сущность по нескольким
+// полотнам произвольным числом part-классов).
+export default class ActorRadar extends Actor {}

package/tests/fixtures/miniGame/config/auth.js

@@ -0,0 +1,41 @@
+import gameConfig from './game.js';
+
+// Схема авторизации фикстуры (HostPlugin.authSchema, PLAN.md §3.2) —
+// зеркало vimp-tanks/src/config/auth.js с единственной моделью.
+export default {
+  elems: {
+    authId: 'auth',
+    formId: 'auth-form',
+    errorId: 'auth-error',
+    enterId: 'auth-enter',
+    titleId: 'auth-title',
+    informsId: 'auth-informs',
+  },
+  // собственные тексты фикстуры (Д2): каркас auth.pug нейтрален,
+  // заголовок/подсказки — данные игры
+  texts: {
+    title: 'Mini Game Fixture',
+    sections: [
+      {
+        heading: 'Controls',
+        lines: [
+          { keys: 'W, S', text: 'move' },
+          { keys: 'J', text: 'fire' },
+        ],
+      },
+    ],
+  },
+  params: [
+    {
+      name: 'model',
+      value: 'm1',
+      options: {
+        validator: 'isValidModel',
+        storage: 'model',
+      },
+    },
+  ],
+  validators: {
+    isValidModel: model => model in gameConfig.parts.models,
+  },
+};

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

@@ -0,0 +1,139 @@
+// Игровая половина клиентского CONFIG_DATA (HostPlugin.buildClientGameConfig,
+// PLAN.md §3.5) — зеркало vimp-tanks/src/config/client.js, минимальная
+// схема: одно полотно, одна колонка статистики сверх имени, один keySet.
+export default {
+  parts: {
+    gameSets: {
+      // ключ снапшот-схемы (a1) — по нему клиент разводит записи кадра по
+      // parts; setId карты (m1) — по нему создаётся статика полотна
+      a1: ['Actor'],
+      m1: ['Actor'],
+    },
+    entitiesOnCanvas: {
+      Actor: 'vimp',
+    },
+    bakedAssets: {},
+    componentDependencies: {},
+    sounds: {},
+  },
+
+  initIdList: ['vimp', 'panel', 'chat'],
+
+  modules: {
+    canvasManager: {
+      canvases: {
+        vimp: {
+          width: 640,
+          height: 400,
+          aspectRatio: '16:10',
+          baseScale: '5:1',
+          dynamicCamera: false,
+          shakeCamera: false,
+        },
+      },
+    },
+
+    controls: {
+      keySetList: [
+        // spectator keyset (пусто — у фикстуры нет наблюдательных команд)
+        {},
+        // player keyset
+        {
+          87: 'forward', // forward (w)
+          83: 'back', // back (s)
+          74: 'fire', // fire (j)
+        },
+      ],
+    },
+
+    chat: {
+      params: {
+        messages: {
+          s: [
+            'Team {0} is full. Your current team: {1}',
+            'Your team: {0}',
+            'Your new team: {0}',
+            'Your new status: spectator',
+            '{0} killed {1}',
+            '{0} joined the game',
+            '{0} left the game',
+          ],
+          v: [
+            'A vote has been created',
+            'Voting has started',
+            'Your vote has been accepted',
+            'Voting is temporarily unavailable',
+            'Vote passed',
+            'Vote failed',
+          ],
+          m: ['Current map: {0}', 'Next map: {0}'],
+          c: ['Command not found'],
+          n: ['Invalid name', '{0} changed name to {1}'],
+          g: ['{0} scripted participant(s) spawned'],
+        },
+      },
+    },
+
+    panel: {
+      // поле нарочно называется не health: бар обязан работать по
+      // type: 'bar', а не по имени поля (Д2)
+      // 't' — движковый ключ времени раунда: его шлёт Panel хоста, поэтому
+      // без маппинга клиент получал бы значение с именем undefined
+      keys: {
+        h: 'energy',
+        t: 'time',
+      },
+      fields: [
+        {
+          name: 'energy',
+          elem: 'panel-energy',
+          type: 'bar',
+          max: 100,
+          blocks: 10,
+        },
+        {
+          name: 'time',
+          elem: 'panel-time',
+          type: 'time',
+        },
+      ],
+    },
+
+    stat: {
+      params: {
+        columns: ['names', 'status', 'score', 'deaths', 'latency'],
+        heads: {
+          1: 'team1',
+        },
+        bodies: {
+          1: 'team1',
+          2: 'spectators',
+        },
+        sortList: {
+          team1: [
+            [2, true],
+            [3, false],
+          ],
+        },
+      },
+    },
+
+    vote: {
+      params: {
+        templates: {
+          teamChange: ['Choose a team', 'teams', true],
+          mapChangeBySystem: ['Choose the next map'],
+          mapChangeByUser: ['{0} suggested the map: {1}', ['Yes', 'No']],
+        },
+        menu: [
+          ['teamChange', ['Switch team', 'teams']],
+          ['mapChange', ['Suggest map', 'maps']],
+        ],
+      },
+    },
+  },
+
+  gameInform: {
+    list: ['{0} WINS!', 'ROUND START!', 'GAME OVER!'],
+  },
+};

package/tests/fixtures/miniGame/config/game.js

@@ -0,0 +1,148 @@
+// Игровая конфигурация фикстуры «миниигра» (Этап 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,
+      spriteSheet: { img: 'tiles.png', frames: [[0, 0, 32, 32]] },
+      layers: { 1: [0] },
+      physicsStatic: [1],
+      physicsDynamic: [],
+      step: 32,
+      respawns: {
+        team1: [
+          [100, 100, 0],
+          [200, 100, 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/miniGame/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/miniGame/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) };
+}