vimp-engine 0.18.0 → 0.19.0

package/package.json

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

package/src/client/components/model/Vote.js

@@ -14,8 +14,10 @@ export default class VoteModel {
 
     this._formatMessage = data.formatMessage;
 
-    this._menu = data.menu; // меню
-    this._templates = data.templates; // шаблоны голосований
+    // игра может не объявлять голосований вовсе (noSpectators): меню по 'm'
+    // тогда пустое, а не падение на длине undefined
+    this._menu = data.menu || []; // меню
+    this._templates = data.templates || {}; // шаблоны голосований
 
     this._type = ''; // тип ('menu', 'vote')
     this._waitingValues = false; // ожидания значений

package/src/client/style.css

@@ -32,6 +32,38 @@ body {
   display: none;
 }
 
+/* Леттербокс по центру. `CanvasManagerModel.resize` считает размер полотна
+   под `aspectRatio` (видимая ширина мира при этом всегда `designWidth /
+   baseScale`, от размера окна она не зависит), но само полотно
+   `ensureCanvas` кладёт в контейнер обычным потоком — и чёрная полоса
+   оказывалась вся с одной стороны. Здесь позиционируется готовый элемент,
+   математику `resize` правило не трогает.
+
+   Целится в тот же маркер каркаса, что и `.vimp-shell > *`, чтобы в
+   standalone SDK не задеть встраивающую страницу. Раскладку контейнера
+   правило не меняет — центрируется само полотно (`inset` + `margin: auto`
+   на элементе известного размера), поэтому остальные экраны движка
+   (#panel, #stat, #chat, #auth, #lobby, информеры — все `position:
+   absolute`) остаются как были. Контейнер обязан быть позиционированным —
+   того же требуют #panel и #stat.
+
+   Класс обязателен, селектора по типу мало: `ensureCanvas` вешает
+   `vimp-letterbox` только на полотно без `fixSize`, то есть на то, размер
+   которого движок считает сам. Полотно фиксированного размера — оверлей
+   игры (радар в vimp-tanks: `position: absolute; right: 1%; top: 35px`), и
+   правило по типу `canvas` подмешивало бы ему `bottom`/`left`/`margin`,
+   которых в игровом правиле нет: при `top`/`bottom` и `left`/`right`
+   одновременно `margin: auto` центрирует элемент, и оверлей уезжал на
+   середину экрана. Правил на такие полотна у движка нет вовсе. */
+.vimp-shell > canvas.vimp-letterbox {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  margin: auto;
+}
+
 body.hide-cursor {
   cursor: none;
 }
@@ -466,7 +498,7 @@ body.hide-cursor {
   color: #e00;
   font-size: 12px;
   line-height: 15px;
-  margin: 0 5px;
+  margin: 0 5px 10px;
 }
 
 /* пустой блок ошибок не должен занимать место: #lobby-error — флекс-элемент
@@ -549,12 +581,6 @@ body.hide-cursor {
   border: 1px solid #999;
 }
 
-/* вертикаль внутри #lobby-create держит его gap — собственный margin
-   коробки удвоил бы отступ до соседей */
-#lobby-fields {
-  margin: 0;
-}
-
 .auth-inform h4 {
   margin: 0 0 4px 0;
   text-align: center;

package/src/client/views/gameShell.js

@@ -75,6 +75,14 @@ const SHELL = [
 // правило совпадает с прежним `body > *`; в SDK это чужой div
 export const SHELL_CLASS = 'vimp-shell';
 
+// Класс полотна, которое движок сам кладёт по центру контейнера (леттербокс,
+// см. `.vimp-shell > canvas.vimp-letterbox` в style.css). Он достаётся ТОЛЬКО
+// полотну без `fixSize`: полотно фиксированного размера — это оверлей
+// (радар в vimp-tanks), его раскладку держит игра, и общее правило по типу
+// `canvas` подмешивало бы такому элементу `bottom`/`left`/`margin`, которых
+// в игровом правиле нет, — оверлей уезжал в центр экрана
+export const LETTERBOX_CLASS = 'vimp-letterbox';
+
 /**
  * Достраивает недостающие контейнеры игрового интерфейса.
  *
@@ -97,7 +105,8 @@ export function ensureGameShell(container = document.body) {
  * документе элемент переиспользуется как есть — если игра положила
  * <canvas id="vimp"> в свою разметку, движок его не переносит.
  * @param {string} canvasId
- * @param {Object} size - { width, height } из конфига канвасов.
+ * @param {Object} size - запись канваса из конфига: { width, height } и
+ *   раскладочные ключи (`fixSize`, `aspectRatio`).
  * @param {HTMLElement} [container] - Точка монтирования (по умолчанию body).
  * @returns {HTMLCanvasElement}
  */
@@ -112,6 +121,14 @@ export function ensureCanvas(canvasId, size, container = document.body) {
     // палец на полотне ведёт игру, а не страницу: без этого браузер
     // смартфона забирает жест себе — прокрутка, pull-to-refresh, зум
     canvas.style.touchAction = 'none';
+
+    // центрирует движок, и только то полотно, которое он же и растягивает
+    // (`CanvasManagerModel.resize`): у `fixSize`-полотна размер задан игрой,
+    // и место на экране — тоже её дело
+    if (!size.fixSize) {
+      canvas.classList.add(LETTERBOX_CLASS);
+    }
+
     container.appendChild(canvas);
   }
 

package/src/devtools/contract/rules/b3-game-config-shape.js

@@ -2,14 +2,15 @@ import { assertGameConfigShape } from '../../../lib/gamePlugin.js';
 import { ERROR, skip, verdict } from '../result.js';
 
 // Тот же гейт, что стоит на боевом пути загрузки плагина
-// (lib/gamePlugin.js): девять обязательных путей gameConfig плюс связь
-// spectatorTeam ↔ teams. Дублировать его список здесь нельзя — он обязан
-// эволюционировать в одном месте.
+// (lib/gamePlugin.js): обязательные пути gameConfig плюс связь
+// spectatorTeam ↔ teams (под noSpectators — «ровно одна команда»).
+// Дублировать его список здесь нельзя — он обязан эволюционировать в одном
+// месте.
 export default {
   id: 'B3',
   name: 'gameConfigShape',
   level: ERROR,
-  title: 'gameConfig has the nine paths the engine reads before any logic',
+  title: 'gameConfig has the paths the engine reads before any logic',
 
   check(ctx) {
     if (!ctx.hostPlugin) {

package/src/devtools/contract/rules/b4-teams.js

@@ -3,6 +3,7 @@ import { ERROR, skip, verdict } from '../result.js';
 // teams/spectatorTeam. Опечатка в spectatorTeam ловится гейтом B3; здесь —
 // вторая половина контракта: играющая команда должна быть хотя бы одна,
 // иначе раунд некому начинать, а все участники висят наблюдателями.
+// Под noSpectators наблюдателей нет вовсе: команда обязана быть ровно одна.
 export default {
   id: 'B4',
   name: 'teams',
@@ -19,6 +20,19 @@ export default {
     const { spectatorTeam } = ctx.gameConfig;
     const violations = [];
 
+    if (ctx.gameConfig.noSpectators === true) {
+      const names = Object.keys(teams);
+
+      if (names.length !== 1) {
+        violations.push(
+          `noSpectators requires exactly one team, got ${names.length} ` +
+            `(${names.join(', ')})`,
+        );
+      }
+
+      return verdict(violations);
+    }
+
     if (teams[spectatorTeam] === undefined) {
       violations.push(
         `spectatorTeam "${spectatorTeam}" is not a key of teams ` +

package/src/host/HostGame.js

@@ -111,8 +111,16 @@ export default class HostGame {
     this._idleTimeoutForSpectator = data.idleKickTimeout?.spectator || null;
 
     this._teams = data.teams;
-    this._spectatorTeam = data.spectatorTeam;
-    this._spectatorId = this._teams[this._spectatorTeam];
+
+    // opt-in флаги игры: noSpectators — наблюдателей нет как концепции
+    // (spectatorTeam/spectatorId равны null, вход ведёт прямо в игру),
+    // endlessRound — раунд не перезапускается сам. Флаги независимы
+    this._noSpectators = data.noSpectators === true;
+    this._endlessRound = data.endlessRound === true;
+    this._spectatorTeam = this._noSpectators ? null : data.spectatorTeam;
+    this._spectatorId = this._noSpectators
+      ? null
+      : this._teams[this._spectatorTeam];
 
     // единый реестр участников (игроки + scripted)
     this._participants = new ParticipantManager(
@@ -168,7 +176,7 @@ export default class HostGame {
 
     this._timerManager = new TimerManager(data.timers, {
       onMapTimeEnd: () => this._roundManager.onMapTimeEnd(),
-      onRoundTimeEnd: () => this._roundManager.initiateNewRound(),
+      onRoundTimeEnd: () => this._roundManager.onRoundTimeEnd(),
       onShotTick: dt => this._onShotTick(dt),
       onIdleCheck: () => this._kickIdleUsers(),
       onSendPing: () => this._sendPing(),
@@ -195,6 +203,8 @@ export default class HostGame {
       teams: this._teams,
       spectatorTeam: this._spectatorTeam,
       spectatorId: this._spectatorId,
+      noSpectators: this._noSpectators,
+      endlessRound: this._endlessRound,
       maps: data.maps,
       mapList: this._mapList,
       mapsInVote: data.mapsInVote,
@@ -501,6 +511,13 @@ export default class HostGame {
     this._socketManager.sendTechInform(socketId);
     this._socketManager.sendFirstVote(socketId);
     this._chat.pushSystem('USER_JOINED', [user.name]);
+
+    // noSpectators: голосования за вход нет — участник уже в играющей
+    // команде, осталось выдать ему актора. Именно здесь, а не в createUser:
+    // sendFirstShot выше шлёт keyset наблюдателя и затёр бы клавиши игрока
+    if (this._noSpectators) {
+      this._roundManager.admitPlayer(gameId);
+    }
   }
 
   // обрабатывает уничтожение игрока (прокси к RoundManager; из событий ядра)
@@ -836,7 +853,9 @@ export default class HostGame {
 
     this._chat.addUser(gameId);
     this._vote.addUser(gameId);
-    this._stat.addUser(gameId, this._spectatorId, { name });
+    // строка stat заводится в той команде, куда участник и попал:
+    // наблюдатели, а под noSpectators — сразу играющая команда
+    this._stat.addUser(gameId, this._participants.joinTeamId, { name });
     this._panel.addUser(gameId);
     this._RTTManager.addUser(gameId);
 
@@ -1015,6 +1034,13 @@ export default class HostGame {
     return this._playerDataSync.getRank(gameId);
   }
 
+  // загружен ли ранг с мастера. getPlayerRank отвечает 0 и для незнакомого
+  // id, и до ответа auth — игре, которая пишет ранг в stat колонкой '=',
+  // нужно отличать «ранг 0» от «ранга ещё нет»
+  isPlayerRankLoaded(gameId) {
+    return this._playerDataSync.isRankLoaded(gameId);
+  }
+
   getPlayerState(gameId) {
     return this._playerDataSync.getState(gameId);
   }
@@ -1023,6 +1049,20 @@ export default class HostGame {
     this._playerDataSync.setState(gameId, state);
   }
 
+  // карта, по которой движок расставляет участников на старте раунда — для
+  // игр, которые пересобирают геометрию на лету, минуя смену карты (прокси к
+  // RoundManager; карта комнаты и текущий раунд не трогаются)
+  overrideMapData(mapData) {
+    this._roundManager.overrideMapData(mapData);
+  }
+
+  // прибавка к рангу для игр, которые не эмитят CoreEvent::Death и потому
+  // никогда не проходят через RoundManager.reportKill: прямая прокладка к
+  // PlayerDataSync, без раунд-логики и без проверки team-wipe
+  addPlayerRank(gameId, delta) {
+    this._playerDataSync.addRank(gameId, delta);
+  }
+
   // hostId + per-room секрет комнаты, подтверждённые мастером при
   // register_host (кодревью №1) — не известны при создании HostGame (Worker
   // стартует раньше ответа мастера); нужны PlayerDataSync для атрибуции

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

@@ -49,6 +49,13 @@ class RoundManager {
     this._teams = deps.teams;
     this._spectatorTeam = deps.spectatorTeam;
     this._spectatorId = deps.spectatorId;
+
+    // opt-in флаги игры (gameConfig): noSpectators — наблюдателей нет как
+    // концепции (spectatorTeam/spectatorId равны null, вход ведёт прямо в
+    // игру); endlessRound — раунд не перезапускается сам, только по явной
+    // команде игры или игрока. Флаги независимы
+    this._noSpectators = deps.noSpectators === true;
+    this._endlessRound = deps.endlessRound === true;
     this._maps = deps.maps;
     this._mapList = deps.mapList;
     this._mapsInVote = deps.mapsInVote;
@@ -79,6 +86,16 @@ class RoundManager {
     return this._removedPlayersList;
   }
 
+  // истечение времени раунда. Под endlessRound раунд не заканчивается сам:
+  // явные перезапуски (/nr, смена карты) продолжают работать
+  onRoundTimeEnd() {
+    if (this._endlessRound) {
+      return;
+    }
+
+    this.initiateNewRound();
+  }
+
   // запускает голосование за смену карты по истечении времени карты
   onMapTimeEnd() {
     this._voteCoordinator.reset();
@@ -147,18 +164,24 @@ class RoundManager {
       this._socketManager.sendSpectatorDefaultShot(user.socketId);
       this._socketManager.sendClear(user.socketId);
 
-      // перемещение пользователя в наблюдатели
-      this._stat.moveUser(gameId, user.teamId, this._spectatorId);
+      // перемещение пользователя в наблюдатели. Под noSpectators переводить
+      // некуда: участник остаётся в своей играющей команде и получит актора
+      // заново, как только загрузит карту (admitPlayer)
+      if (!this._noSpectators) {
+        this._stat.moveUser(gameId, user.teamId, this._spectatorId);
+        user.team = this._spectatorTeam;
+        user.teamId = this._spectatorId;
+      }
 
       // обнулить параметры
-      user.team = this._spectatorTeam;
-      user.teamId = this._spectatorId;
       user.status = 'spectator';
       user.isWatching = true;
+      // акторов на новой карте ещё нет, значит и занятых слотов нет
+      user.respawnIndex = null;
       user.watchedGameId = this._participants.getActiveList()[0] || null;
       user.forceCameraReset = true;
 
-      this._participants.addToTeam(gameId, this._spectatorTeam);
+      this._participants.addToTeam(gameId, user.team);
 
       this.sendMap(gameId);
     }
@@ -184,6 +207,20 @@ class RoundManager {
     this._socketManager.sendMap(socketId, this._currentMapData);
   }
 
+  // Подменяет карту, которую движок раздаёт при старте раунда, НЕ меняя
+  // карту комнаты и не начиная раунд.
+  //
+  // Для игр, которые пересобирают геометрию на лету и не могут пройти через
+  // `forceChangeMap` (он чистит мир, панель и таблицу): без этого
+  // `_startRound` раздавал бы точки респауна карты каталога, то есть исходного
+  // размера, и расставлял всех по геометрии, которой в ядре уже нет
+  // (`@vimp-games/snakes`, `src/host/ArenaScaler.js`).
+  overrideMapData(mapData) {
+    if (mapData) {
+      this._scaledMapData = mapData;
+    }
+  }
+
   // немедленная смена карты (когда голосование не требуется)
   forceChangeMap(mapName) {
     this._currentMap = mapName;
@@ -228,17 +265,25 @@ class RoundManager {
       .filter(key => key !== this._spectatorTeam)
       .reduce((acc, key) => ({ ...acc, [key]: 0 }), {});
 
-    function getRespawnData(team) {
+    // индекс точки, а не сама точка: занятый слот запоминается на участнике
+    // (`Participant.respawnIndex`), и `admitPlayer` потом раздаёт свободные,
+    // а не «размер команды минус один»
+    function getRespawnIndex(team) {
       const number = respId[team];
 
       respId[team] += 1;
 
-      return respawns[team][number];
+      return number;
     }
 
-    // очищение списка играющих
+    // очищение списка играющих: акторов сняли со всех, поэтому и слоты
+    // респауна свободны — раздача ниже начинается с чистого листа
     this._participants.clearActive();
 
+    for (const participant of this._participants.getAll()) {
+      participant.respawnIndex = null;
+    }
+
     this._panel.reset();
 
     const setIdList = this._game.removePlayersAndShots();
@@ -258,9 +303,12 @@ class RoundManager {
       if (team === this._spectatorTeam) {
         user.isWatching = true;
         user.forceCameraReset = true;
+        user.respawnIndex = null;
         this._socketManager.sendSpectatorDefaultShot(socketId);
       } else {
-        this._setActivePlayer(user, getRespawnData(team));
+        const index = getRespawnIndex(team);
+
+        this._setActivePlayer(user, respawns[team][index], index);
       }
 
       this._socketManager.sendSoundCue(socketId, 'roundStart');
@@ -269,8 +317,100 @@ class RoundManager {
 
     // размещение scripted-участников на карте
     for (const participant of this._participants.getScripted()) {
-      this._setActivePlayer(participant, getRespawnData(participant.team));
+      const team = participant.team;
+      const index = getRespawnIndex(team);
+
+      this._setActivePlayer(participant, respawns[team][index], index);
+    }
+  }
+
+  // Первый не занятый слот респауна команды, или -1, если свободных нет.
+  //
+  // Занятость считается по участникам, у которых актор УЖЕ есть
+  // (`Participant.respawnIndex`), а не по размеру команды: между попаданием
+  // в команду (`createUser`) и выдачей актора (`firstShotReady`) проходит вся
+  // загрузка карты клиентом, а команда за это время успевает вырасти. Двое
+  // зашедших одновременно получали от «размера минус один» ОДИН индекс, и
+  // после смены карты его получали разом вообще все — `createMap` добавляет
+  // в команду всех до того, как хоть кто-то дойдёт до первого кадра.
+  //
+  // `exceptGameId` — участник, чей собственный слот занятостью не считается
+  // (changeTeam: переходящий ищет место в новой команде, ещё держа старое).
+  // Иначе его пришлось бы обнулять ДО проверки, и неудачный переход оставлял
+  // бы активного игрока с `respawnIndex === null` — его физически занятая
+  // точка выглядела бы свободной для следующего вызова.
+  _freeRespawnIndex(team, exceptGameId = null) {
+    const respawns = this._scaledMapData?.respawns?.[team] ?? [];
+    const taken = new Set();
+
+    for (const participant of this._participants.getAll()) {
+      if (
+        participant.team === team &&
+        participant.respawnIndex !== null &&
+        participant.gameId !== exceptGameId
+      ) {
+        taken.add(participant.respawnIndex);
+      }
+    }
+
+    for (let i = 0; i < respawns.length; i += 1) {
+      if (!taken.has(i)) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  // Впускает участника прямо в играющую команду — путь входа игр с
+  // noSpectators: ни голосования, ни смены команды, ни правила «<2 игроков».
+  // Команду участник получил ещё в ParticipantManager.createHuman, здесь
+  // выдаётся только актор.
+  //
+  // Если свободной точки нет, освобождается одна за счёт scripted-участника —
+  // то же правило, что и в changeTeam: человек важнее бота. Если и это не
+  // помогло, возвращается false и игрок узнаёт об этом из чата: под
+  // noSpectators попросить место больше негде — голосования нет, а changeTeam
+  // в единственную команду отвечает «это ваша текущая команда». Место
+  // освободит чужой выход, а актора выдаст следующий _startRound.
+  admitPlayer(gameId) {
+    const user = this._participants.get(gameId);
+
+    if (!user || user.team === this._spectatorTeam) {
+      return false;
+    }
+
+    const respawns = this._scaledMapData?.respawns?.[user.team];
+    let index = this._freeRespawnIndex(user.team);
+
+    // бот вытесняется только там, где вытеснение помогает: `index === -1` —
+    // это «слоты кончились», тогда как пустой (или ещё не загруженный) список
+    // точек даёт то же самое отсутствие respawnData, но освободившееся место
+    // в нём всё равно не появится
+    const hasSlots = Boolean(respawns?.length);
+
+    if (
+      hasSlots &&
+      index === -1 &&
+      this._scripted.removeOneForHuman?.(user.team)
+    ) {
+      index = this._freeRespawnIndex(user.team);
+    }
+
+    const respawnData = respawns?.[index];
+
+    if (!respawnData) {
+      this._chat.pushSystemByUser(gameId, 'TEAMS_TEAM_FULL', [
+        user.team,
+        user.team,
+      ]);
+
+      return false;
     }
+
+    this._setActivePlayer(user, respawnData, index);
+
+    return true;
   }
 
   // меняет ник игрока
@@ -332,8 +472,10 @@ class RoundManager {
 
     this._stat.moveUser(gameId, oldTeamId, newTeamId);
 
-    // если активных игроков меньше 2-х, рестарт раунда
+    // если активных игроков меньше 2-х, рестарт раунда (под endlessRound
+    // правило выключено: оно обнуляло бы stat на каждом входе и выходе)
     if (
+      !this._endlessRound &&
       this._participants
         .getHumans()
         .filter(u => u.teamId !== this._spectatorId && u.gameId !== gameId)
@@ -368,12 +510,29 @@ class RoundManager {
       }
       // игра активным игроком возможна в текущем раунде
     } else {
-      const respawnIndex = this._participants.getTeamSize(newTeam) - 1;
+      // тот же аллокатор, что и у admitPlayer: слот берётся свободный, а не
+      // «размер команды минус один» — серия входов и выходов сдвигает размер
+      // на уже занятые точки. Свой собственный слот при этом не считается
+      // занятым, а старый не обнуляется до успеха: ранний return ниже уходит
+      // уже после смены команды, и участник остался бы активным игроком без
+      // записанного слота
+      const respawnIndex = this._freeRespawnIndex(newTeam, gameId);
       const respawnData = respawns[newTeam][respawnIndex];
 
+      if (!respawnData) {
+        this._chat.pushSystemByUser(gameId, 'TEAMS_TEAM_FULL', [
+          newTeam,
+          currentTeam,
+        ]);
+
+        return;
+      }
+
+      user.respawnIndex = respawnIndex;
+
       // переход из наблюдателя в игрока
       if (oldTeamId === this._spectatorId) {
-        this._setActivePlayer(user, respawnData);
+        this._setActivePlayer(user, respawnData, respawnIndex);
         // смена игровой команды
       } else {
         this._game.changePlayerData(gameId, {
@@ -394,6 +553,8 @@ class RoundManager {
     user.isWatching = true;
     user.watchedGameId = this._participants.getActiveList()[0] || null;
     user.forceCameraReset = true;
+    // слот освобождается вместе с актором, иначе он держится за наблюдателем
+    user.respawnIndex = null;
 
     this._participants.removeActive(gameId);
     this._removedPlayersList.push({ gameId, model });
@@ -401,8 +562,9 @@ class RoundManager {
     this._socketManager.sendSpectatorDefaultShot(user.socketId);
   }
 
-  // перевод игрока в активные игроки
-  _setActivePlayer(user, respawnData) {
+  // перевод игрока в активные игроки. `respawnIndex` — слот, который участник
+  // с этого момента занимает (см. `_freeRespawnIndex`)
+  _setActivePlayer(user, respawnData, respawnIndex = null) {
     const gameId = user.gameId;
     const teamId = user.teamId;
     const name = user.name;
@@ -412,6 +574,7 @@ class RoundManager {
     user.isWatching = false;
     user.watchedGameId = null;
     user.forceCameraReset = true;
+    user.respawnIndex = respawnIndex;
 
     // если это реальный игрок (есть сокет)
     if (user.isNetworked) {
@@ -489,6 +652,12 @@ class RoundManager {
 
   // проверяет уничтожение всей команды
   _checkTeamWipe(victimTeamId, killerTeamId) {
+    // под endlessRound раунд не заканчивается вообще: вычищенная команда —
+    // не повод для результата и отложенного перезапуска
+    if (this._endlessRound) {
+      return;
+    }
+
     // если раунд уже в процессе завершения
     if (this._isRoundEnding) {
       return;

package/src/host/meta/modules/PlayerDataSync.js

@@ -105,12 +105,20 @@ export default class PlayerDataSync {
     return this._entries.get(participantId)?.rank ?? 0;
   }
 
+  // приехал ли rank с мастера. getRank отвечает 0 и незнакомому id, и
+  // знакомому, чей load() ещё не вернулся — игре, которая пишет ранг в stat
+  // колонкой '=', нужно отличать «ранг 0» от «ранга ещё нет»
+  isRankLoaded(participantId) {
+    return this._entries.get(participantId)?.rankLoaded === true;
+  }
+
   getState(participantId) {
     return this._entries.get(participantId)?.state ?? this._defaultState;
   }
 
-  // прибавляет к рангу игрока (вызывается из RoundManager.reportKill —
-  // тот же чокпоинт, что и Stat score)
+  // прибавляет к рангу игрока. Два вызывающих: RoundManager.reportKill (тот
+  // же чокпоинт, что и Stat score) и HostGame.addPlayerRank — прямой путь для
+  // игр, которые не эмитят CoreEvent::Death и до reportKill не доходят
   addRank(participantId, delta) {
     const entry = this._entries.get(participantId);
 

package/src/host/meta/player/Participant.js

@@ -7,6 +7,11 @@ class Participant {
     this.team = team;
     this.teamId = teamId;
     this.status = 'spectator'; // 'spectator' | 'active' | 'dead'
+    // индекс точки респауна, занятой этим участником, или null. Раздаёт и
+    // освобождает его RoundManager: размер команды для этого не годится —
+    // он меняется на входах и выходах, а между попаданием в команду и
+    // выдачей актора может пройти вся загрузка карты клиентом
+    this.respawnIndex = null;
   }
 
   // участник, управляемый кодом (ИИ), а не сетевым игроком

package/src/host/meta/player/ParticipantManager.js

@@ -9,8 +9,15 @@ class ParticipantManager {
   // { namePrefix, defaultModel }
   constructor(teams, spectatorTeam, maxPlayers, scripted = {}) {
     this._teams = teams; // { team1: 1, team2: 2, spectators: 3 }
-    this._spectatorTeam = spectatorTeam;
-    this._spectatorId = teams[spectatorTeam];
+
+    // noSpectators (opt-in движка): наблюдателей нет как концепции, и
+    // spectatorTeam приходит null. Команда входа тогда — единственная
+    // играющая, а не резервная: человек заходит сразу в игру
+    this._spectatorTeam = spectatorTeam ?? null;
+    this._spectatorId =
+      this._spectatorTeam === null ? null : teams[spectatorTeam];
+    this._joinTeam = this._spectatorTeam ?? Object.keys(teams)[0];
+    this._joinTeamId = teams[this._joinTeam];
     this._maxPlayers = maxPlayers;
     this._scripted = scripted;
 
@@ -32,7 +39,18 @@ class ParticipantManager {
     return counter.toString(10);
   }
 
-  // создаёт участника-человека (спектатор), возвращает gameId
+  // команда, в которую попадает подключившийся человек: наблюдатели, а под
+  // noSpectators — единственная играющая команда
+  get joinTeam() {
+    return this._joinTeam;
+  }
+
+  get joinTeamId() {
+    return this._joinTeamId;
+  }
+
+  // создаёт участника-человека (наблюдателя, а под noSpectators — игрока),
+  // возвращает gameId
   createHuman(params, socketId) {
     const gameId = this._nextGameId();
     const name = this.checkName(params.name);
@@ -41,15 +59,15 @@ class ParticipantManager {
       gameId,
       name,
       model: params.model,
-      team: this._spectatorTeam,
-      teamId: this._spectatorId,
+      team: this._joinTeam,
+      teamId: this._joinTeamId,
       socketId,
       watchedGameId: this._activePlayersList[0] || null,
       token: params.token,
     });
 
     this._participants.set(gameId, participant);
-    this._teamSizes[this._spectatorTeam].add(gameId);
+    this._teamSizes[this._joinTeam].add(gameId);
 
     return gameId;
   }

package/src/lib/buildClientConfig.js

@@ -28,8 +28,13 @@ export const buildClientConfig = (game, defaults, gameClient) => {
     structuredClone(gameClient),
   );
 
-  // время ожидания vote-модуля
-  config.modules.vote.params.time = game.timers.voteTime;
+  // время ожидания vote-модуля. Игра без голосований (noSpectators) не
+  // объявляет modules.vote.params вовсе — движковые дефолты дают только
+  // elems, поэтому params здесь и заводится
+  config.modules.vote.params = {
+    ...config.modules.vote.params,
+    time: game.timers.voteTime,
+  };
 
   // данные для client-side prediction (реплика движения своего танка
   // и визуального спавна его снарядов)

package/src/lib/gamePlugin.js

@@ -54,9 +54,12 @@ const REQUIRED_GAME_CONFIG_PATHS = [
   // без них HostGame разыменовывает undefined (this._teams[spectatorTeam])
   // и игра умирает тремя разными сообщениями вместо одного контрактного
   'teams',
-  'spectatorTeam',
 ];
 
+// spectatorTeam обязателен ровно до тех пор, пока игра не объявила
+// noSpectators: там наблюдателей нет как концепции и ключа тоже нет
+const SPECTATOR_CONFIG_PATH = 'spectatorTeam';
+
 function getPath(obj, dottedPath) {
   return dottedPath
     .split('.')
@@ -68,7 +71,12 @@ export function assertGameConfigShape(hostPlugin) {
   // null проходил бы проверку присутствия, хотя ни одно из этих полей не
   // бывает пустым по контракту: движок разыменовывает их сразу, и гейт,
   // заведённый ради текста вместо TypeError, сам отвечал бы TypeError
-  const missing = REQUIRED_GAME_CONFIG_PATHS.filter(p => {
+  const noSpectators = hostPlugin.gameConfig?.noSpectators === true;
+  const required = noSpectators
+    ? REQUIRED_GAME_CONFIG_PATHS
+    : [...REQUIRED_GAME_CONFIG_PATHS, SPECTATOR_CONFIG_PATH];
+
+  const missing = required.filter(p => {
     const value = getPath(hostPlugin.gameConfig, p);
 
     return value === undefined || value === null;
@@ -87,6 +95,20 @@ export function assertGameConfigShape(hostPlugin) {
   // (ParticipantManager.createHuman валится на её счётчике)
   const { teams, spectatorTeam } = hostPlugin.gameConfig;
 
+  // noSpectators: связывать нечего — зато команда обязана быть ровно одна.
+  // Вторая играющая команда без наблюдателей означала бы вход «куда-нибудь»,
+  // а ParticipantManager выбирает команду входа однозначно
+  if (noSpectators) {
+    if (Object.keys(teams).length !== 1) {
+      throw new Error(
+        `game "${hostPlugin.id}": noSpectators requires exactly one team, ` +
+          `got ${Object.keys(teams).length} (${Object.keys(teams).join(', ')})`,
+      );
+    }
+
+    return;
+  }
+
   if (teams[spectatorTeam] === undefined) {
     throw new Error(
       `game "${hostPlugin.id}": spectatorTeam '${spectatorTeam}' is not a ` +

package/src/lib/packageLink.js

@@ -30,9 +30,12 @@ export function resolveProjectUrl(pkg) {
 
   // repository бывает и строкой ("github:user/repo"), и объектом {type, url}
   const declared =
-    (typeof repository === 'string' ? repository : repository?.url) ?? homepage;
+    typeof repository === 'string' ? repository : repository?.url;
 
-  return normalize(declared);
+  // объявленный, но не приводящийся к http(s) repository (пустая строка,
+  // внутренний git-хост) не повод терять валидный homepage: поле проверяется
+  // по результату, а не по факту наличия
+  return normalizeRepository(declared) ?? normalize(homepage);
 }
 
 /**
@@ -41,11 +44,26 @@ export function resolveProjectUrl(pkg) {
  * @returns {{url: string, label: string}|null} null, если адреса нет
  */
 export function projectLink(url) {
-  if (typeof url !== 'string' || !url.trim()) {
+  // адрес перепроверяется, хотя свои вызовы приходят уже из
+  // resolveProjectUrl: функция — публичный экспорт ("./lib/*"), а результат
+  // уходит прямо в href якоря (client/lib/footerLink.js)
+  const value = typeof url === 'string' ? url.trim() : '';
+
+  if (!/^https?:\/\//.test(value)) {
     return null;
   }
 
-  return { url, label: labelFor(url) };
+  return { url: value, label: labelFor(value) };
+}
+
+// шорткат "user/repo" — семантика поля repository (так его читает npm), в
+// homepage такая строка означала бы относительный путь, а не адрес на GitHub
+function normalizeRepository(raw) {
+  const value = typeof raw === 'string' ? raw.trim() : '';
+
+  return /^[\w.-]+\/[\w.-]+$/.test(value)
+    ? `https://github.com/${value}`
+    : normalize(raw);
 }
 
 // приводит объявленный адрес к https-виду; всё, что после нормализации не
@@ -61,14 +79,7 @@ function normalize(raw) {
     return null;
   }
 
-  // npm-шорткаты: "github:user/repo", "gitlab:...", "bitbucket:...", а также
-  // голое "user/repo" — его принимает флаг --repository скаффолдера
-  const bare = /^([\w.-]+\/[\w.-]+)$/.exec(url);
-
-  if (bare) {
-    return `https://github.com/${bare[1]}`;
-  }
-
+  // npm-шорткаты: "github:user/repo", "gitlab:...", "bitbucket:..."
   const shorthand = /^(github|gitlab|bitbucket):([\w.-]+\/[\w.-]+)$/.exec(url);
 
   if (shorthand) {
@@ -101,6 +112,9 @@ function normalize(raw) {
 
   return (
     url
+      // логин (и тем более пароль) из ssh-формы адреса — не часть проекта, а
+      // в href он уехал бы в DOM и историю браузера
+      .replace(/^(https?:\/\/)[^/@]*@/, '$1')
       .replace(/\.git(?=$|[#?])/, '')
       // npm сам дописывает "#readme" в homepage при генерации package.json
       .replace(/#readme$/, '')
@@ -111,11 +125,13 @@ function normalize(raw) {
 // подпись ячейки: у наших пакетов это всегда GitHub, у чужого хостинга —
 // его хост, чтобы подпись не врала об источнике
 function labelFor(url) {
-  if (/^https?:\/\/(www\.)?github\.com\//.test(url)) {
-    return 'GitHub';
-  }
+  let host;
 
-  const host = /^https?:\/\/(?:www\.)?([^/:]+)/.exec(url);
+  try {
+    host = new URL(url).hostname.replace(/^www\./, '');
+  } catch {
+    return 'Website';
+  }
 
-  return host ? host[1] : 'Website';
+  return host === 'github.com' ? 'GitHub' : host;
 }