vimp-engine 0.18.1 → 0.20.0

package/package.json

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

package/src/client/components/controller/Lobby.js

@@ -27,6 +27,7 @@ export default class LobbyCtrl {
     this._model = model;
     this._view = view;
     this._clock = clock;
+    this._periods = [];
 
     this.publisher = new Publisher();
 
@@ -37,6 +38,12 @@ export default class LobbyCtrl {
     vp.on('visible', 'pingHost', this);
     vp.on('join', 'join', this);
     vp.on('show-tab', 'showTab', this);
+    vp.on('show-period', 'showPeriod', this);
+
+    // активная игра и открытый срез рейтинга (rank-periods): запрос за
+    // лидербордом всегда несёт обе координаты, а меняется каждый раз одна
+    this._gameId = null;
+    this._period = null;
   }
 
   // показывает лобби и запрашивает первую страницу
@@ -69,13 +76,47 @@ export default class LobbyCtrl {
     this._view.showTab(tab);
   }
 
+  // срез рейтинга: подсветить кнопку и перезапросить список. Данных за день
+  // и за месяц у клиента нет — это другой ответ сервера, а не другая
+  // сортировка того же (rank-periods)
+  showPeriod(period) {
+    if (period === this._period) {
+      return;
+    }
+
+    this._period = period;
+    this._view.setPeriod(period, this._titleOf(period));
+
+    if (this._gameId !== null) {
+      this.publisher.emit('leaderboard-needed', {
+        gameId: this._gameId,
+        period,
+      });
+    }
+  }
+
+  // подпись среза для заголовка списка; неизвестный id остаётся без подписи
+  _titleOf(period) {
+    return this._periods.find(item => item.id === period)?.title ?? '';
+  }
+
   // вызывается main.js при смене #lobby-game (селектор игры вне этого MVC),
   // а также один раз при открытии лобби для активной по умолчанию игры —
   // Leaderboard всегда готов заранее, до того как пользователь откроет
   // вкладку (см. класс-комментарий выше)
   gameChanged(gameId, title) {
+    this._gameId = gameId;
     this._view.setGameTitle(title);
 
-    this.publisher.emit('leaderboard-needed', gameId);
+    this.publisher.emit('leaderboard-needed', { gameId, period: this._period });
+  }
+
+  // срезы рейтинга и открытый по умолчанию (main.js передаёт их из
+  // lobbyConfig): контроллер не знает их наизусть, чтобы список срезов
+  // правился в конфиге, а не здесь
+  setPeriods(periods, defaultPeriod) {
+    this._periods = periods || [];
+    this._period = defaultPeriod;
+    this._view.setPeriod(defaultPeriod, this._titleOf(defaultPeriod));
   }
 }

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/components/view/Lobby.js

@@ -36,6 +36,15 @@ export default class LobbyView {
     this._leaderboardTotal = document.getElementById(elems.leaderboardTotalId);
     this._myPlacement = document.getElementById(elems.myPlacementId);
 
+    // кнопки срезов рейтинга (rank-periods): id периода -> элемент. Кнопки
+    // объявлены конфигом, а не захардкожены здесь, чтобы срез можно было
+    // убрать или добавить в одном месте
+    this._periodBtns = new Map(
+      Object.entries(elems.periodBtnIds || {})
+        .map(([period, id]) => [period, document.getElementById(id)])
+        .filter(([, el]) => el),
+    );
+
     // футер лобби: содержимое статично на всё время жизни вкладки, поэтому
     // пишется здесь, а не через модель и publisher
     const version = document.getElementById(elems.versionId);
@@ -56,6 +65,10 @@ export default class LobbyView {
     // игроков, чем лимит)
     this._leaderboardLimit = 0;
 
+    // заголовок открытого среза ("<TITLE> TOP-N — TODAY"): подпись, а не
+    // источник правды, срез хранит модель
+    this._periodTitle = '';
+
     // ник вызывающего (lobby-page-plan, code review M4-остаток) — задаётся
     // main.js один раз при открытии лобби; используется, чтобы решить,
     // виден ли вызывающий уже в отрисованном топе (по нику, не по числу
@@ -86,6 +99,10 @@ export default class LobbyView {
     this._tabServersBtn.onclick = () => this.publisher.emit('show-tab', 'servers');
     this._tabLeaderboardBtn.onclick = () => this.publisher.emit('show-tab', 'leaderboard');
 
+    for (const [period, btn] of this._periodBtns) {
+      btn.onclick = () => this.publisher.emit('show-period', period);
+    }
+
     this._mPublic = model.publisher;
     this._mPublic.on('list', 'renderList', this);
     this._mPublic.on('ping-update', 'updatePing', this);
@@ -118,6 +135,17 @@ export default class LobbyView {
     this._selfNick = nick || '';
   }
 
+  // подсвечивает открытый срез рейтинга и запоминает его подпись
+  // (rank-periods). Рисовать список здесь нечем: данные среза приезжают
+  // отдельным запросом, и до ответа список чистится моделью
+  setPeriod(period, title) {
+    this._periodTitle = title || '';
+
+    for (const [id, btn] of this._periodBtns) {
+      btn.classList.toggle('active', id === period);
+    }
+  }
+
   // переключает вкладки Active Servers / Leaderboard (lobby-page-plan)
   showTab(tab) {
     const showLeaderboard = tab === 'leaderboard';
@@ -130,7 +158,10 @@ export default class LobbyView {
 
   // рендер топ-N + позиции вызывающего (lobby-page-plan)
   renderLeaderboard({ leaderboard, total, myPlacement, loaded = true }) {
-    this._leaderboardTitle.textContent = `${this._gameTitle.toUpperCase()} TOP-${this._leaderboardLimit}`;
+    const period = this._periodTitle ? ` — ${this._periodTitle}` : '';
+
+    this._leaderboardTitle.textContent =
+      `${this._gameTitle.toUpperCase()} TOP-${this._leaderboardLimit}${period}`;
     this._leaderboardTotal.textContent = `Total: ${total} players`;
 
     this._leaderboardList.textContent = '';

package/src/client/main.js

@@ -1790,10 +1790,13 @@ async function fetchServers({ offset, limit, search }) {
 
 // топ-N рейтинга игры (lobby-page-plan) — публичный эндпоинт, доступен и до
 // логина, поэтому без Authorization
-async function fetchLeaderboard(gameId) {
+async function fetchLeaderboard(gameId, period) {
   const params = new URLSearchParams({
     game: gameId,
     limit: lobbyConfig.leaderboardLimit,
+    // rank-periods: срез времени. Мастер отвечает 400 на незнакомый —
+    // значение всегда из lobbyConfig.leaderboardPeriods
+    period,
   });
 
   try {
@@ -1807,7 +1810,7 @@ async function fetchLeaderboard(gameId) {
 
 // позиция вызывающего в рейтинге игры (lobby-page-plan) — требует identity-
 // токена, как и остальные /auth/* запросы игрока (rank/state)
-async function fetchPlacement(gameId) {
+async function fetchPlacement(gameId, period) {
   const token = lobbyAuthModel.getToken();
 
   if (!token) {
@@ -1816,7 +1819,9 @@ async function fetchPlacement(gameId) {
 
   try {
     const res = await fetch(
-      `${lobbyConfig.placementUrl}?${new URLSearchParams({ game: gameId })}`,
+      // тот же срез, что и у списка рядом: плашка позиции, посчитанная за
+      // всё время под заголовком «сегодня», противоречила бы списку
+      `${lobbyConfig.placementUrl}?${new URLSearchParams({ game: gameId, period })}`,
       { headers: { authorization: `Bearer ${token}` } },
     );
 
@@ -1954,6 +1959,13 @@ function initLobby() {
 
   lobby = new LobbyCtrl(lobbyModel, lobbyView);
 
+  // срезы рейтинга (rank-periods) — сразу после создания контроллера и до
+  // первого gameChanged: тот уже несёт открытый срез в запросе
+  lobby.setPeriods(
+    lobbyConfig.leaderboardPeriods,
+    lobbyConfig.defaultLeaderboardPeriod,
+  );
+
   // список серверов — REST-запросом к мастеру
   lobbyModel.publisher.on('fetch', async query => {
     const list = await fetchServers(query);
@@ -1989,17 +2001,17 @@ function initLobby() {
   // под заголовком новой, пока не пришёл ответ (и остаются навсегда при
   // сетевом сбое); reqId отбрасывает ответ устаревшего запроса, если игру
   // переключили быстрее, чем пришёл ответ (latest-wins)
-  lobby.publisher.on('leaderboard-needed', async gameId => {
+  lobby.publisher.on('leaderboard-needed', async ({ gameId, period }) => {
     lobbyModel.clearLeaderboard();
 
     const reqId = ++leaderboardReqId;
     const [leaderboard, placement] = await Promise.all([
-      fetchLeaderboard(gameId),
-      fetchPlacement(gameId),
+      fetchLeaderboard(gameId, period),
+      fetchPlacement(gameId, period),
     ]);
 
     if (reqId !== leaderboardReqId) {
-      return; // игру уже переключили ещё раз — этот ответ устарел
+      return; // игру или срез уже переключили ещё раз — ответ устарел
     }
 
     if (leaderboard) {

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;
 }
@@ -876,6 +908,32 @@ body.hide-cursor {
   border-bottom: 2px solid #fff;
 }
 
+/* срезы рейтинга (rank-periods): день/месяц/всё время. Ряд под вкладками
+   правой панели — это выбор ДАННЫХ, а не вкладка, поэтому кнопки выглядят
+   как переключатель, а не как заголовок раздела */
+.lobby-period-tabs {
+  display: flex;
+  gap: 4px;
+  margin-bottom: 10px;
+}
+
+.lobby-period-btn {
+  flex: 1 1 0;
+  background: rgb(255 255 255 / 6%);
+  border: none;
+  color: #888;
+  font-size: 12px;
+  font-weight: bold;
+  padding: 5px 4px;
+  margin: 0;
+  text-shadow: none;
+}
+
+.lobby-period-btn.active {
+  background: rgb(255 255 255 / 18%);
+  color: #fff;
+}
+
 .lobby-leaderboard-header {
   display: flex;
   justify-content: space-between;

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/client/views/includes/lobby.pug

@@ -50,6 +50,12 @@ div#lobby(style='display:none')
             p#lobby-empty= 'No servers available'
             input#lobby-more(type='button', value='Load more')
           div#lobby-leaderboard-content(style='display:none')
+            //- срез рейтинга (rank-periods): день/месяц считаются из леджера
+            //- дельт, all-time — из кэша ratings
+            div.lobby-period-tabs
+              input#btn-period-day.lobby-period-btn(type='button', value='Daily')
+              input#btn-period-month.lobby-period-btn(type='button', value='Monthly')
+              input#btn-period-all.lobby-period-btn.active(type='button', value='All-Time')
             div.lobby-leaderboard-header
               span#leaderboard-title
               span#leaderboard-total

package/src/config/lobby.js

@@ -50,6 +50,17 @@ export default {
   placementUrl: '/auth/placement',
   leaderboardLimit: 10,
 
+  // rank-periods: срезы рейтинга и тот, что открыт по умолчанию. Порядок
+  // здесь — порядок кнопок; `id` едет в auth как ?period=, `title` идёт в
+  // заголовок списка. Значения должны совпадать с RANK_PERIODS auth-сервиса:
+  // на всё прочее он отвечает 400
+  leaderboardPeriods: [
+    { id: 'day', title: 'TODAY' },
+    { id: 'month', title: 'THIS MONTH' },
+    { id: 'all', title: 'ALL-TIME' },
+  ],
+  defaultLeaderboardPeriod: 'all',
+
   // переподключение сигнального WS хоста (комната без него выпадает из
   // выдачи мастера): экспоненциальный бэкофф от baseDelay до maxDelay (мс)
   reconnect: {
@@ -93,6 +104,12 @@ export default {
     serversContentId: 'lobby-servers-content',
     leaderboardContentId: 'lobby-leaderboard-content',
     leaderboardListId: 'lobby-leaderboard-list',
+    // кнопки срезов (rank-periods): id периода -> id элемента
+    periodBtnIds: {
+      day: 'btn-period-day',
+      month: 'btn-period-month',
+      all: 'btn-period-all',
+    },
     leaderboardTitleId: 'leaderboard-title',
     leaderboardTotalId: 'leaderboard-total',
     myPlacementId: 'lobby-my-placement',

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,33 @@ 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);
+  }
+
+  // синхронизация профилей (rank/state) всех участников на мастер прямо
+  // сейчас — для игр, у которых нет ни конца раунда, ни смены карты
+  // (`endlessRound` + карта, пересобираемая через overrideMapData): обе
+  // штатные границы flushAll живут в RoundManager, и такая игра не проходит
+  // ни через одну из них. Без этого накопленный за матч ранг уезжает в auth
+  // только на выходе участника, а закрытая вкладка хоста теряет его вовсе.
+  //
+  // Best-effort, как и весь PlayerDataSync: промис не отвергается, сбой
+  // логируется в `[playerData]` и повторится следующим flush'ем.
+  flushPlayerData() {
+    return this._playerDataSync.flushAll();
+  }
+
   // 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 ` +