vimp-engine 0.28.0 → 0.30.0

package/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vimp-engine-core"
-version = "0.9.2"
+version = "0.11.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.30.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/c4-component-dependencies.js

@@ -9,6 +9,11 @@ import { SERVICES } from '../../../config/clientServices.js';
 // assetsBase выглядит как чистый холст без единой строки в консоли, ради
 // этого правило и существует. Правило остаётся ERROR: оно работает на этапе
 // разработки игры, а не в рантайме.
+//
+// Что именно возвращает `hooks.services(core)`, статически не видно — хук
+// требует живого ядра. Поэтому у плагина есть необязательное поле
+// `serviceNames`: объявленный список имён снимает догадку, и правило снова
+// умеет краснеть (без него оно опускается до WARN и пропускает опечатку).
 export { SERVICES };
 
 export default {
@@ -24,16 +29,39 @@ export default {
       return skip('no client parts.componentDependencies');
     }
 
+    const declared = ctx.clientPlugin?.serviceNames;
+    const listed = Array.isArray(declared) ? declared : [];
+
+    if (declared !== undefined && !Array.isArray(declared)) {
+      return verdict([
+        `ClientPlugin.serviceNames is ${typeof declared}, expected an array ` +
+          'of service names returned by hooks.services(core)',
+      ]);
+    }
+
     // раскладка «сервис → парты, которым он нужен» (client.js игры)
     const unknown = Object.keys(deps).filter(
-      service => !SERVICES.includes(service),
+      service => !SERVICES.includes(service) && !listed.includes(service),
     );
 
     if (unknown.length === 0) {
       return verdict([]);
     }
 
-    const pool = SERVICES.join(', ');
+    const pool = [...SERVICES, ...listed].join(', ');
+
+    // список игровых сервисов объявлен — гадать больше не о чем: имя вне
+    // объединённого пула не даст парту ничего, кроме undefined
+    if (listed.length) {
+      return verdict(
+        unknown.map(
+          service =>
+            `componentDependencies declares service "${service}" — neither ` +
+            `the engine nor ClientPlugin.serviceNames provides it (${pool}), ` +
+            'so it is silently undefined in the part',
+        ),
+      );
+    }
     // hooks.services(core) требует живой инстанс ядра, а игровой код чекер не
     // запускает — статически перечислить игровые сервисы нечем. Поэтому при
     // объявленном хуке имя вне движкового пула остаётся строкой отчёта, но

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

@@ -0,0 +1,344 @@
+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`,
+      );
+      continue;
+    }
+
+    // 9. рампа, ведущая в пустоту: за верхним концом прогона обязана быть
+    // поверхность уровня `to`. Иначе танк доезжает до вершины и в тот же шаг
+    // срывается вниз — молча, потому что и подъём, и падение штатные правила
+    for (const [x, y] of rampRunExits(fromGrid ?? [], ramp?.tile, ramp?.dir)) {
+      if (!walkable(map, to, x, y)) {
+        violations.push(
+          `${at}: ramp ${index} run ends at (${x}, ${y}), which is not ` +
+            `walkable ground of level ${to}`,
+        );
+      }
+    }
+  }
+
+  // 10. край плиты без перил — обрыв; приземлиться с него нужно на
+  // проходимую землю, иначе танк уезжает за карту (стены уровня 0 плите не
+  // преграда) или приземляется внутри стены
+  checkLevelEdges(at, map, violations);
+
+  // 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})`,
+      );
+    }
+  }
+}
+
+// --- геометрия уровней (зеркало vimp_engine_core::map::validate_levels) ---
+
+function cellAt(grid, x, y) {
+  if (x < 0 || y < 0) {
+    return undefined;
+  }
+
+  return grid?.[y]?.[x];
+}
+
+// земля проходима, если клетка есть в гриде и её тайл не объявлен стеной
+function groundWalkable(map, x, y) {
+  const tile = cellAt(map.map ?? [], x, y);
+
+  return tile !== undefined && !(map.physicsStatic ?? []).includes(tile);
+}
+
+function walkable(map, level, x, y) {
+  if (level === 0) {
+    return groundWalkable(map, x, y);
+  }
+
+  const cfg = (map.levels ?? {})[String(level)];
+
+  if (!cfg) {
+    return false;
+  }
+
+  const tile = cellAt(cfg.map ?? [], x, y);
+
+  return (
+    tile !== undefined &&
+    (cfg.floor ?? []).includes(tile) &&
+    !(cfg.walls ?? []).includes(tile)
+  );
+}
+
+// клетки, следующие за верхними концами прогонов рампы (прогон —
+// непрерывная линия одинаковых тайлов вдоль оси рампы)
+function rampRunExits(grid, tile, dir) {
+  const sign = dir === 'south' || dir === 'east' ? 1 : -1;
+  const vertical = dir === 'north' || dir === 'south';
+  const out = [];
+
+  if (vertical) {
+    const cols = Math.max(0, ...grid.map(row => row.length));
+
+    for (let x = 0; x < cols; x += 1) {
+      let y = 0;
+
+      while (y < grid.length) {
+        if (grid[y][x] !== tile) {
+          y += 1;
+          continue;
+        }
+
+        const y0 = y;
+
+        while (y < grid.length && grid[y][x] === tile) {
+          y += 1;
+        }
+
+        out.push([x, sign > 0 ? y : y0 - 1]);
+      }
+    }
+
+    return out;
+  }
+
+  grid.forEach((row, y) => {
+    let x = 0;
+
+    while (x < row.length) {
+      if (row[x] !== tile) {
+        x += 1;
+        continue;
+      }
+
+      const x0 = x;
+
+      while (x < row.length && row[x] === tile) {
+        x += 1;
+      }
+
+      out.push([sign > 0 ? x : x0 - 1, y]);
+    }
+  });
+
+  return out;
+}
+
+const NEIGHBOURS = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+
+function checkLevelEdges(at, map, violations) {
+  for (const [key, level] of Object.entries(map.levels ?? {})) {
+    const floor = level?.floor ?? [];
+    const walls = level?.walls ?? [];
+    const grid = level?.map ?? [];
+
+    grid.forEach((row, y) => {
+      row.forEach((tile, x) => {
+        // перила закрывают край сами; клетка вне плиты краем не бывает
+        if (!floor.includes(tile) || walls.includes(tile)) {
+          return;
+        }
+
+        for (const [dx, dy] of NEIGHBOURS) {
+          const nx = x + dx;
+          const ny = y + dy;
+          const neighbour = cellAt(grid, nx, ny);
+
+          if (neighbour !== undefined && floor.includes(neighbour)) {
+            continue;
+          }
+
+          if (groundWalkable(map, nx, ny)) {
+            continue;
+          }
+
+          violations.push(
+            `${at}: level ${key} floor cell (${x}, ${y}) has an open edge ` +
+              `at (${nx}, ${ny}) with no walkable ground below — close it ` +
+              'with a wall tile',
+          );
+        }
+      });
+    });
+  }
+}
+
+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/e5-map-radar-walls.js

@@ -0,0 +1,79 @@
+import { ERROR, skip, verdict } from '../result.js';
+
+// Радар рисует стены не из физики, а из рендер-слоя: парт слоя берётся за
+// работу, только если его тайл-лист (`layers`) называет хотя бы один тайл из
+// `physicsStatic`/`walls`. Карта, где тайл стены не назван ни в одном слое,
+// физически стены имеет, а на радаре — нет, и ни одной строки в консоли при
+// этом не появляется. Правило безвредно для карты без `layers`: проверять
+// тогда нечего.
+export default {
+  id: 'E5',
+  name: 'mapRadarWalls',
+  level: ERROR,
+  title: 'solid tiles are named by a render layer',
+
+  check(ctx) {
+    const maps = ctx.gameConfig?.maps;
+
+    if (!maps) {
+      return skip('no gameConfig.maps');
+    }
+
+    const violations = [];
+    let checked = 0;
+
+    for (const [name, map] of Object.entries(maps)) {
+      checked += checkMap(`map "${name}"`, map, violations);
+    }
+
+    if (!checked) {
+      return skip('no map declares render layers');
+    }
+
+    return verdict(violations);
+  },
+};
+
+/**
+ * @param {string} at - Человекочитаемое место нарушения.
+ * @param {Object} map - Карта из gameConfig.maps.
+ * @param {Array<string>} violations - Копилка нарушений.
+ * @returns {number} Сколько гридов удалось проверить (0 — слоёв нет).
+ */
+function checkMap(at, map, violations) {
+  let checked = 0;
+
+  checked += checkGrid(at, 'level 0', map?.layers, map?.physicsStatic, violations);
+
+  for (const [key, level] of Object.entries(map?.levels ?? {})) {
+    checked += checkGrid(
+      at,
+      `level ${key}`,
+      level?.layers,
+      level?.walls,
+      violations,
+    );
+  }
+
+  return checked;
+}
+
+function checkGrid(at, where, layers, solid, violations) {
+  if (!layers || !Object.keys(layers).length) {
+    return 0;
+  }
+
+  const named = new Set(Object.values(layers).flat());
+
+  for (const tile of solid ?? []) {
+    if (!named.has(tile)) {
+      violations.push(
+        `${at}: ${where} solid tile ${tile} is not named by any render ` +
+          'layer — MapRadar draws walls only from a layer that lists a ' +
+          'solid tile, so the wall silently disappears from the radar',
+      );
+    }
+  }
+
+  return 1;
+}

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

@@ -32,6 +32,8 @@ 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';
+import e5 from './e5-map-radar-walls.js';
 
 // Порядок групп — порядок отчёта: A пакет и сборка, B host, C client,
 // D снапшот, E ассеты (plan/create-vimp-game/stage_1.md).
@@ -40,7 +42,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, e5,
 ];
 
 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) — распределяются
  *   по движковой/игровой половине автоматически.
@@ -31,6 +34,7 @@ export const buildCoreConfig = (gameConfig, overrides = {}) => {
     weapons,
     playerKeys: gameConfig.playerKeys,
     panel: gameConfig.panel.fields,
+    coreParams: gameConfig.coreParams,
     // keys — игровая схема (gameConfig.snapshot); version/port — движковые
     snapshot: {
       version: SNAPSHOT_FORMAT_VERSION,
@@ -50,6 +54,11 @@ export const buildCoreConfig = (gameConfig, overrides = {}) => {
       seed: flat.seed,
     },
     game: {
+      // собственные параметры ядра игры: движок их не читает и не
+      // валидирует — он лишь довозит их до `GameSim::new`. Известные ключи
+      // ниже перекрывают одноимённые, чтобы игра не могла подменить
+      // движковую часть контракта
+      ...(flat.coreParams || {}),
       friendlyFire: flat.friendlyFire,
       models: flat.models,
       weapons: flat.weapons,

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

@@ -48,8 +48,16 @@ export default {
       // имя файла — инертные данные: фикстура host-only, рендера в ней нет
       // и картинку никто не грузит. Реальные тайлы везёт пакет игры
       // (`${assetsBase}img/`), движок картинок не раздаёт
-      spriteSheet: { img: 'fixture-tiles.png', frames: [[0, 0, 32, 32]] },
-      layers: { 1: [0] },
+      spriteSheet: {
+        img: 'fixture-tiles.png',
+        frames: [
+          [0, 0, 32, 32],
+          [32, 0, 32, 32],
+        ],
+      },
+      // тайл стены обязан быть назван рендер-слоем: радар рисует стены
+      // только из слоя, который их перечисляет (правило E5)
+      layers: { 1: [0, 1] },
       physicsStatic: [1],
       physicsDynamic: [],
       step: 32,