vimp-engine 0.28.0 → 0.29.0

package/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vimp-engine-core"
-version = "0.9.2"
+version = "0.10.0"
 edition = "2024"
 description = "VIMP — движковый каркас симуляции (физика, карта, снапшот-фрейминг, интерполяция/предикт/raycast-примитивы, нав-утилиты). Без wasm-bindgen — обёртки для WASM-ABI собирает game-crate."
 license = "MIT"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vimp-engine",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "VIMP — движок-приложение (мастер, P2P-транспорт, Worker-хост, мета, MVC-каркас клиента)",
   "license": "MIT",
   "repository": {

package/src/client/main.js

@@ -586,6 +586,11 @@ function applyMapData(data, { notifyHost = true } = {}) {
         setId,
         physicsStatic,
         physicsDynamic: data.physicsDynamic,
+        // 2.5D: надземные уровни и переходы. Клиентское ядро строит из них
+        // ту же `MapLevels`, что и хост, — иначе предсказание уровня
+        // разъедется с авторитетным молча
+        levels: data.levels,
+        ramps: data.ramps,
       }),
     );
   } catch (e) {
@@ -625,23 +630,47 @@ function applyMapData(data, { notifyHost = true } = {}) {
     currentMapSetId = setId;
   };
 
-  const staticData = Object.entries(layers).reduce(
-    (acc, [layer, tiles], index) => {
-      acc[`s${index}`] = {
+  // рендер-слои по уровням: уровень 0 — из `layers` над гридом `map`,
+  // надземные — из `levels[n].layers` над гридом `levels[n].map`.
+  // Ключи `s0..sN` сквозные: парт получает `level`, `solid` и `floor`
+  // своего уровня и не обязан ничего знать про соседний
+  const staticData = {};
+  let staticIndex = 0;
+
+  const pushLayers = (levelLayers, levelMap, level, solid, floor) => {
+    for (const [layer, tiles] of Object.entries(levelLayers || {})) {
+      staticData[`s${staticIndex}`] = {
         type: 'static',
         spriteSheet,
-        map,
+        map: levelMap,
         step,
         layer,
         tiles,
+        level,
+        solid,
+        floor,
+        // прежнее имя оставлено для парта, который его уже читает
         physicsStatic,
         scale,
       };
 
-      return acc;
-    },
-    {},
-  );
+      staticIndex += 1;
+    }
+  };
+
+  pushLayers(layers, map, 0, physicsStatic, []);
+
+  for (const [key, levelData] of Object.entries(data.levels || {})) {
+    const level = Number(key);
+
+    pushLayers(
+      levelData.layers,
+      levelData.map,
+      level,
+      levelData.walls || [],
+      levelData.floor || [],
+    );
+  }
 
   removeMap(currentMapSetId);
   createMap(setId, staticData);

package/src/devtools/VirtualClient.js

@@ -201,6 +201,11 @@ class VirtualClient {
           setId: data.setId,
           physicsStatic: data.physicsStatic,
           physicsDynamic: data.physicsDynamic,
+          // 2.5D: надземные уровни и переходы. Клиентское ядро строит из
+          // них ту же `MapLevels`, что и хост, — иначе предсказание уровня
+          // разъедется с авторитетным молча
+          levels: data.levels,
+          ramps: data.ramps,
         }),
       );
     } catch (e) {

package/src/devtools/contract/rules/e4-map-layers.js

@@ -0,0 +1,196 @@
+import { ERROR, skip, verdict } from '../result.js';
+
+// Слоёная (2.5D) карта проверяется в ядре (`MapConfig::validate`), но там
+// это ошибка загрузки уже запущенного матча. Здесь то же самое ловится до
+// сборки и без ядра: рассинхрон размерностей гридов даёт танк,
+// проваливающийся в пустоту, и ни одной строки в консоли.
+//
+// Правило безвредно для одноуровневой игры: без `levels` ни одна проверка
+// не срабатывает.
+export default {
+  id: 'E4',
+  name: 'mapLayers',
+  level: ERROR,
+  title: 'layered maps are structurally sound',
+
+  check(ctx) {
+    const maps = ctx.gameConfig?.maps;
+
+    if (!maps) {
+      return skip('no gameConfig.maps');
+    }
+
+    const layered = Object.entries(maps).filter(
+      ([, map]) => map?.levels && Object.keys(map.levels).length > 0,
+    );
+
+    if (!layered.length) {
+      return skip('no layered maps');
+    }
+
+    const violations = [];
+
+    for (const [name, map] of layered) {
+      checkMap(name, map, violations);
+    }
+
+    return verdict(violations);
+  },
+};
+
+const RAMP_DIRS = ['north', 'south', 'west', 'east'];
+
+function checkMap(name, map, violations) {
+  const at = `map "${name}"`;
+  const levels = map.levels ?? {};
+  // уровень 0 живёт в map/physicsStatic/layers и в `levels` не значится
+  const levelCount = Object.keys(levels).length + 1;
+
+  // 1. ключи — целые >= 1, подряд от 1
+  const keys = Object.keys(levels).map(Number);
+
+  for (const key of Object.keys(levels)) {
+    if (!/^\d+$/.test(key) || Number(key) < 1) {
+      violations.push(
+        `${at}: levels key "${key}" is not a level number >= 1 ` +
+          '(level 0 lives in map/physicsStatic)',
+      );
+    }
+  }
+
+  const sorted = [...keys].sort((a, b) => a - b);
+
+  sorted.forEach((level, index) => {
+    if (level !== index + 1) {
+      violations.push(
+        `${at}: levels must run from 1 without gaps, got ${level} at ` +
+          `position ${index + 1}`,
+      );
+    }
+  });
+
+  const grid = map.map ?? [];
+
+  for (const [key, level] of Object.entries(levels)) {
+    // 2. размерность грида уровня совпадает с гридом уровня 0
+    const levelGrid = level?.map ?? [];
+
+    if (levelGrid.length !== grid.length) {
+      violations.push(
+        `${at}: level ${key} grid has ${levelGrid.length} rows, ` +
+          `map has ${grid.length}`,
+      );
+    }
+
+    levelGrid.forEach((row, y) => {
+      const expected = grid[y]?.length;
+
+      if (expected !== undefined && row.length !== expected) {
+        violations.push(
+          `${at}: level ${key} row ${y} has ${row.length} cells, ` +
+            `map has ${expected}`,
+        );
+      }
+    });
+
+    // 3. перила — часть плиты: тайл вне floor не экранирует луч снизу
+    const floor = level?.floor ?? [];
+
+    for (const tile of level?.walls ?? []) {
+      if (!floor.includes(tile)) {
+        violations.push(
+          `${at}: level ${key} wall tile ${tile} is not part of floor`,
+        );
+      }
+    }
+
+    // 8. тайл рендер-слоя обязан существовать в тайл-листе по индексу
+    checkLayerFrames(at, `level ${key}`, level?.layers, map.spriteSheet, violations);
+  }
+
+  for (const [index, ramp] of (map.ramps ?? []).entries()) {
+    const from = ramp?.from ?? 0;
+    const to = ramp?.to ?? 1;
+
+    // 5. направление и осмысленность перехода
+    if (!RAMP_DIRS.includes(ramp?.dir)) {
+      violations.push(
+        `${at}: ramp ${index} dir "${ramp?.dir}" is not one of ` +
+          RAMP_DIRS.join('|'),
+      );
+    }
+
+    if (from === to) {
+      violations.push(`${at}: ramp ${index} goes from level ${from} to itself`);
+    }
+
+    if (from >= levelCount || to >= levelCount) {
+      violations.push(
+        `${at}: ramp ${index} references a level out of range ` +
+          `(levels: ${levelCount})`,
+      );
+    }
+
+    // 4. тайл рампы обязан встречаться в гриде уровня, с которого она идёт
+    const fromGrid = from === 0 ? grid : levels[String(from)]?.map;
+    const found = (fromGrid ?? []).some(row => row.includes(ramp?.tile));
+
+    if (!found) {
+      violations.push(
+        `${at}: ramp ${index} tile ${ramp?.tile} is missing from ` +
+          `level ${from} grid`,
+      );
+    }
+  }
+
+  // 6. точка респауна: [x, y, angle] либо [x, y, angle, level]
+  for (const [team, points] of Object.entries(map.respawns ?? {})) {
+    for (const [index, point] of (points ?? []).entries()) {
+      if (point.length !== 3 && point.length !== 4) {
+        violations.push(
+          `${at}: respawns ${team}[${index}] has ${point.length} numbers, ` +
+            'expected 3 or 4',
+        );
+        continue;
+      }
+
+      if (point.length === 4 && point[3] >= levelCount) {
+        violations.push(
+          `${at}: respawns ${team}[${index}] level ${point[3]} is out of ` +
+            `range (levels: ${levelCount})`,
+        );
+      }
+    }
+  }
+
+  // 7. уровень динамического тела
+  for (const [index, object] of (map.physicsDynamic ?? []).entries()) {
+    const level = object?.level ?? 0;
+
+    if (level >= levelCount) {
+      violations.push(
+        `${at}: physicsDynamic ${index} level ${level} is out of range ` +
+          `(levels: ${levelCount})`,
+      );
+    }
+  }
+}
+
+function checkLayerFrames(at, where, layers, spriteSheet, violations) {
+  const frames = spriteSheet?.frames;
+
+  if (!Array.isArray(frames)) {
+    return;
+  }
+
+  for (const [layer, tiles] of Object.entries(layers ?? {})) {
+    for (const tile of tiles ?? []) {
+      if (frames[tile] === undefined) {
+        violations.push(
+          `${at}: ${where} layer ${layer} names tile ${tile}, ` +
+            `spriteSheet.frames has ${frames.length}`,
+        );
+      }
+    }
+  }
+}

package/src/devtools/contract/rules/index.js

@@ -32,6 +32,7 @@ import d3 from './d3-snapshot-interp.js';
 import e1 from './e1-sound-pairs.js';
 import e2 from './e2-map-images.js';
 import e3 from './e3-sound-registry.js';
+import e4 from './e4-map-layers.js';
 
 // Порядок групп — порядок отчёта: A пакет и сборка, B host, C client,
 // D снапшот, E ассеты (plan/create-vimp-game/stage_1.md).
@@ -40,7 +41,7 @@ export const rules = [
   b1, b2, b3, b4, b5, b6, b7, b8, b9, b10,
   c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11,
   d1, d2, d3,
-  e1, e2, e3,
+  e1, e2, e3, e4,
 ];
 
 export default rules;

package/src/host/GameCoreAdapter.js

@@ -74,6 +74,22 @@ export default class GameCoreAdapter {
     } else {
       this._core.spawn_actor(gameId, model, teamId, x, y, angle);
     }
+
+    this._applyActorLevel(gameId, data);
+  }
+
+  // явный уровень точки респауна на 2.5D-карте (respawns[i][3]); ядро,
+  // собранное до появления метода, его просто не экспортирует — тогда
+  // уровень выведется из геометрии внутри ядра
+  _applyActorLevel(gameId, data) {
+    const level = data[3];
+
+    if (
+      typeof level === 'number' &&
+      typeof this._core.set_actor_level === 'function'
+    ) {
+      this._core.set_actor_level(gameId, level);
+    }
   }
 
   // удаляет танк (Game.removePlayer). Scripted → удаляет и ИИ-контроллер
@@ -98,6 +114,7 @@ export default class GameCoreAdapter {
     const [x, y, angle] = data.respawnData;
 
     this._core.reset_actor(gameId, data.teamId, x, y, angle);
+    this._applyActorLevel(gameId, data.respawnData);
   }
 
   // ***** ввод ***** //

package/src/host/meta/core/RoundManager.js

@@ -15,7 +15,9 @@ function scaleMapData(mapData) {
   const respawns = Object.fromEntries(
     Object.entries(mapData.respawns || {}).map(([team, arr]) => [
       team,
-      arr.map(([x, y, angle]) => [x * scale, y * scale, angle]),
+      // 4-й элемент точки — уровень 2.5D-карты; масштабируются ТОЛЬКО
+      // координаты, всё остальное едет как есть
+      arr.map(point => [point[0] * scale, point[1] * scale, ...point.slice(2)]),
     ]),
   );
 

package/src/lib/buildClientConfig.js

@@ -43,6 +43,11 @@ export const buildClientConfig = (game, defaults, gameClient) => {
     playerKeys: game.playerKeys,
     models: game.parts.models,
     weapons: game.parts.weapons,
+    // собственные параметры ядра игры (те же, что едут в хостовое ядро
+    // через lib/coreConfig.js): движок их не читает и не валидирует, а
+    // клиентская реплика обязана видеть правила ровно те же, что хост —
+    // иначе предсказание разъедется с авторитетным молча
+    coreParams: game.coreParams,
   };
 
   // снапшот-схема игры: клиент собирает по ней конфиг клиентского ядра и

package/src/lib/capabilities.js

@@ -24,6 +24,9 @@ export const ENGINE_CAPABILITIES = createRegistry('engine-capabilities', [
   { value: 'accolades', since: '0.21.0' },
   // dispatch/abi_describe в ядре (этап 4): опциональные вызовы ядра
   { value: 'dispatch', since: '0.23.0' },
+  // слоёные карты: `levels`/`ramps` в формате карты, маски уровней в
+  // физике, уровень участника (`set_actor_level`), слоёный нав-граф
+  { value: 'map.layers', since: '0.25.0' },
 ]);
 
 // плоский список имён — то, чем правило контракта B2 проверяет `requires`

package/src/lib/clientCoreConfig.js

@@ -13,7 +13,10 @@ import wsports from '../config/wsports.js';
  * игровая (models/weapons/playerKeys/seed трассеров).
  * @param {Object} options
  * @param {Object} options.prediction - Секция prediction CONFIG_DATA
- *   (timeStep в мс, playerKeys, models, weapons).
+ *   (timeStep в мс, playerKeys, models, weapons, coreParams). Поле
+ *   `coreParams` (необязательное) — непрозрачный словарь параметров ядра
+ *   игры: попадает в игровую половину как есть, движок его не читает;
+ *   известные движку ключи имеют приоритет.
  * @param {Object} options.interpolation - Секция interpolation CONFIG_DATA
  *   (delay, maxFrameAge в мс).
  * @param {Object} options.snapshot - Секция snapshot CONFIG_DATA —
@@ -32,6 +35,7 @@ export const buildClientCoreConfig = (
     playerKeys: prediction.playerKeys,
     models: prediction.models,
     weapons: prediction.weapons,
+    coreParams: prediction.coreParams,
     // keys — игровая схема из CONFIG_DATA; version/port — движковые
     snapshot: {
       version: SNAPSHOT_FORMAT_VERSION,
@@ -54,6 +58,11 @@ export const buildClientCoreConfig = (
       divergence: flat.divergence,
     },
     game: {
+      // собственные параметры ядра игры: движок их не читает и не
+      // валидирует — он лишь довозит их до `GameClientDef::new`. Известные
+      // ключи ниже перекрывают одноимённые, чтобы игра не могла подменить
+      // движковую часть контракта (то же правило, что в lib/coreConfig.js)
+      ...(flat.coreParams || {}),
       playerKeys: flat.playerKeys,
       models: flat.models,
       weapons: flat.weapons,

package/src/lib/coreConfig.js

@@ -13,7 +13,10 @@ import wsports from '../config/wsports.js';
  * Собирает объект конфигурации ядра.
  * @param {Object} gameConfig - Представление HostPlugin.gameConfig
  *   (lib/gameConfigView.js): поля игры плюс движковые умолчания. Прямой
- *   gameConfig сюда не передаётся — он обходит умолчания (И2).
+ *   gameConfig сюда не передаётся — он обходит умолчания (И2). Поле
+ *   `coreParams` (необязательное) — непрозрачный словарь параметров
+ *   ядра игры: попадает в игровую половину конфига как есть, движок его
+ *   не читает и не валидирует; известные движку ключи имеют приоритет.
  * @param {Object} [overrides] - Переопределения плоским объектом (например,
  *   seed для воспроизводимых прогонов или friendlyFire) — распределяются
  *   по движковой/игровой половине автоматически.
@@ -50,6 +53,11 @@ export const buildCoreConfig = (gameConfig, overrides = {}) => {
       seed: flat.seed,
     },
     game: {
+      // собственные параметры ядра игры: движок их не читает и не
+      // валидирует — он лишь довозит их до `GameSim::new`. Известные ключи
+      // ниже перекрывают одноимённые, чтобы игра не могла подменить
+      // движковую часть контракта
+      ...(gameConfig.coreParams || {}),
       friendlyFire: flat.friendlyFire,
       models: flat.models,
       weapons: flat.weapons,