vimp-engine 0.41.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vimp-engine",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "VIMP engine SDK: browser host and client runtime, standalone mode and CLI tools (vimp-sim, vimp-contract) for VIMP game plugins",
   "license": "MIT",
   "repository": {

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

@@ -3,7 +3,8 @@
 let roomMenuCtrl;
 
 export default class RoomMenuCtrl {
-  // actions — { onLeave, onHandover }: действия пунктов (client/main.js)
+  // actions — { onExit, onConfirmOpen, onConfirmClose } (client/main.js):
+  // выход подтверждён; окно открылось; окно закрыто без выхода
   constructor(model, view, actions = {}) {
     if (roomMenuCtrl) {
       return roomMenuCtrl;
@@ -13,22 +14,41 @@ export default class RoomMenuCtrl {
 
     this._model = model;
     this._view = view;
+    this._actions = actions;
 
     this._vPublic = view.publisher;
-    this._vPublic.on('toggle', () => model.toggle());
-    // меню остаётся открытым: на месте пунктов — статус передачи
-    this._vPublic.on('leave', () => actions.onLeave?.());
-    this._vPublic.on('handover', () => actions.onHandover?.());
+    this._vPublic.on('exit', () => {
+      if (model.openConfirm()) {
+        actions.onConfirmOpen?.();
+      }
+    });
+    this._vPublic.on('yes', () => {
+      if (!model.isConfirmOpen()) {
+        return;
+      }
+
+      model.closeConfirm();
+      actions.onExit?.();
+    });
+    this._vPublic.on('cancel', () => {
+      if (!model.isConfirmOpen()) {
+        return;
+      }
+
+      model.closeConfirm();
+      actions.onConfirmClose?.();
+    });
   }
 
-  // абсолютная ссылка на комнату, в которой вкладка; null — скрыть меню
+  // абсолютная ссылка на комнату, в которой вкладка; null — скрыть кнопку
   setLink(link) {
     this._model.setLink(link);
   }
 
-  // { role, othersPresent, hasSuccessor } — см. RoomMenuModel.setRole
-  setRole(state) {
-    this._model.setRole(state);
+  // закрыть окно без выхода и без возврата клавиш: пауза сессии сама ими
+  // управляет
+  closeConfirm() {
+    this._model.closeConfirm();
   }
 
   // true — кнопка внутри панели (игра её показывает), false — в углу
@@ -36,8 +56,16 @@ export default class RoomMenuCtrl {
     this._view.placeInPanel(inPanel);
   }
 
-  // null | 'pending' | 'slow' | 'failed'
+  // null | 'pending' | 'switching' | 'slow'. Передача закрывает открытое
+  // окно — как Cancel: клавиши, выключенные окном, возвращает onConfirmClose
+  // (иначе срыв передачи до заморозки оставил бы хоста без управления)
   setHandoff(status) {
+    const wasOpen = this._model.isConfirmOpen();
+
     this._model.setHandoff(status);
+
+    if (wasOpen && !this._model.isConfirmOpen()) {
+      this._actions.onConfirmClose?.();
+    }
   }
 }

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

@@ -2,19 +2,18 @@ import Publisher from '../../../lib/Publisher.js';
 
 // Singleton RoomMenuModel
 //
-// Меню комнаты внутри матча (host-migration, этапы 3 и 8d). Ссылка на
-// текущую комнату — признак «вкладка в комнате». Пункты:
-// - «Leave server» — у всех;
-// - «Hand over host» — только у текущего хоста, когда в комнате есть другие
-//   люди и мастер назначил бету (иначе передавать некому).
-// Пока идёт передача, пункты заблокированы, на их месте статус. Только
+// Выход из комнаты внутри матча: одна кнопка Exit у всех ролей, видна, пока
+// вкладка в комнате (ссылка на комнату — признак «в комнате»). Клик
+// открывает окно подтверждения «Leave the game?». Пока идёт плановая
+// передача хоста, кнопка заблокирована, на её месте статус. Только
 // лобби-режим: в solo ссылки на комнату нет
 
-// handoff: null | 'pending' | 'slow' | 'failed'
+// handoff: null | 'pending' (Exit хоста) | 'switching' (автопередача,
+// вкладка остаётся) | 'slow' (бета долго не отвечает)
 const STATUS_TEXT = {
-  pending: 'Handing over…',
+  pending: 'Leaving…',
+  switching: 'Switching host…',
   slow: 'Slow connection…',
-  failed: 'Host handover failed',
 };
 
 let roomMenuModel;
@@ -28,20 +27,18 @@ export default class RoomMenuModel {
     roomMenuModel = this;
 
     this._link = null;
-    this._open = false;
-    this._role = null; // null | 'host' | 'guest'
-    this._othersPresent = false;
-    this._hasSuccessor = false;
     this._handoff = null;
+    // окно подтверждения открыто
+    this._confirm = false;
     this.publisher = new Publisher();
   }
 
-  // абсолютная ссылка на комнату; null — вкладка не в комнате, меню скрыто
+  // абсолютная ссылка на комнату; null — вкладка не в комнате, кнопка скрыта
   setLink(link) {
     this._link = link || null;
 
     if (!this._link) {
-      this.setOpen(false);
+      this._confirm = false;
     }
 
     this._emitState();
@@ -51,70 +48,58 @@ export default class RoomMenuModel {
     return this._link;
   }
 
-  /**
-   * Роль вкладки в комнате.
-   * @param {Object} state
-   * @param {'host'|'guest'|null} state.role
-   * @param {boolean} [state.othersPresent] - в комнате есть другие люди.
-   * @param {boolean} [state.hasSuccessor] - мастер назначил бету.
-   */
-  setRole({ role, othersPresent = false, hasSuccessor = false }) {
-    this._role = role ?? null;
-    this._othersPresent = othersPresent === true;
-    this._hasSuccessor = hasSuccessor === true;
-    this._emitState();
-  }
-
-  // ход плановой передачи: null | 'pending' | 'slow' | 'failed'
+  // ход плановой передачи: null | 'pending' | 'switching' | 'slow'. Идущая
+  // передача закрывает окно: Yes посреди неё сорвал бы плановую передачу в
+  // аварийную
   setHandoff(status) {
     this._handoff = status ?? null;
+
+    if (this._handoff !== null) {
+      this._confirm = false;
+    }
+
     this._emitState();
   }
 
-  setOpen(open) {
-    const next = Boolean(open) && this._link !== null;
+  isConfirmOpen() {
+    return this._confirm;
+  }
 
-    if (next === this._open) {
-      return;
+  // окно открывается только у доступной кнопки; true — открылось сейчас
+  openConfirm() {
+    if (this._confirm || this._link === null || this._busy()) {
+      return false;
     }
 
-    this._open = next;
-    this.publisher.emit('open', next);
+    this._confirm = true;
+    this._emitState();
 
-    // ошибка передачи показана — закрытое меню её забывает
-    if (!next && this._handoff === 'failed') {
-      this.setHandoff(null);
-    }
+    return true;
   }
 
-  toggle() {
-    this.setOpen(!this._open);
+  closeConfirm() {
+    this._confirm = false;
+    this._emitState();
   }
 
   /**
    * Что показывать.
-   * @returns {{ visible: boolean, leave: Object, handover: Object,
-   *   status: string|null }} leave/handover — { visible, disabled }.
+   * @returns {{ visible: boolean, exit: { disabled: boolean },
+   *   status: string|null, confirm: boolean }}
    */
   getState() {
-    const inRoom = this._link !== null;
-    const busy = this._handoff === 'pending' || this._handoff === 'slow';
-
     return {
-      visible: inRoom,
-      leave: { visible: inRoom, disabled: busy },
-      handover: {
-        visible:
-          inRoom &&
-          this._role === 'host' &&
-          this._othersPresent &&
-          this._hasSuccessor,
-        disabled: busy,
-      },
+      visible: this._link !== null,
+      exit: { disabled: this._busy() },
       status: STATUS_TEXT[this._handoff] ?? null,
+      confirm: this._confirm,
     };
   }
 
+  _busy() {
+    return this._handoff !== null;
+  }
+
   _emitState() {
     this.publisher.emit('state', this.getState());
   }

package/src/client/components/view/RoomMenu.js

@@ -5,8 +5,8 @@ import Publisher from '../../../lib/Publisher.js';
 let roomMenuView;
 
 export default class RoomMenuView {
-  // config — lobbyConfig.roomMenu: { elems: { panelId, menuId, toggleId,
-  // listId, leaveId, handoverId, statusId } }
+  // config — lobbyConfig.roomMenu: { elems: { panelId, menuId, exitId,
+  // statusId, confirmId, confirmYesId, confirmCancelId } }
   constructor(model, config) {
     if (roomMenuView) {
       return roomMenuView;
@@ -17,39 +17,36 @@ export default class RoomMenuView {
     const { elems } = config;
 
     this._menu = document.getElementById(elems.menuId);
-    this._list = document.getElementById(elems.listId);
-    this._leave = document.getElementById(elems.leaveId);
-    this._handover = document.getElementById(elems.handoverId);
+    this._exit = document.getElementById(elems.exitId);
     this._status = document.getElementById(elems.statusId);
+    this._confirm = document.getElementById(elems.confirmId);
     this._panel = document.getElementById(elems.panelId);
     this._home = this._menu.parentElement;
+    this._onKeyDown = event => this._keyDown(event);
+    this._listening = false;
 
     this.publisher = new Publisher();
 
-    document
-      .getElementById(elems.toggleId)
-      .addEventListener('click', () => this.publisher.emit('toggle'));
-    this._leave.addEventListener('click', () => this.publisher.emit('leave'));
-    this._handover.addEventListener('click', () =>
-      this.publisher.emit('handover'),
-    );
+    this._bindButton(this._exit, 'exit');
+    this._bindButton(document.getElementById(elems.confirmYesId), 'yes');
+    this._bindButton(document.getElementById(elems.confirmCancelId), 'cancel');
 
     this._mPublic = model.publisher;
     this._mPublic.on('state', 'showState', this);
-    this._mPublic.on('open', 'showOpen', this);
   }
 
-  showState({ visible, leave, handover, status }) {
+  showState({ visible, exit, status, confirm }) {
     this._menu.style.display = visible ? 'block' : 'none';
-    showItem(this._leave, leave);
-    showItem(this._handover, handover);
+    this._exit.disabled = exit.disabled;
     this._status.textContent = status ?? '';
     this._status.style.display = status ? 'block' : 'none';
+    this._confirm.style.display = confirm ? 'flex' : 'none';
+    this._listen(confirm);
   }
 
-  // меню — часть панели (справа от таблицы), но разметка отдельная: каркас
-  // панели общий со standalone SDK, где меню комнаты нет. Игра без панели в
-  // initIdList держит её скрытой — тогда меню остаётся кнопкой в углу
+  // кнопка — часть панели (справа от таблицы), но разметка отдельная: каркас
+  // панели общий со standalone SDK, где выхода из комнаты нет. Игра без
+  // панели в initIdList держит её скрытой — тогда кнопка остаётся в углу
   placeInPanel(inPanel) {
     const parent = inPanel && this._panel ? this._panel : this._home;
 
@@ -58,12 +55,69 @@ export default class RoomMenuView {
     }
   }
 
-  showOpen(open) {
-    this._list.style.display = open ? 'block' : 'none';
+  // фокус с кнопки снимается: иначе Space/Enter в бою нажали бы её снова
+  _bindButton(elem, type) {
+    elem.addEventListener('click', () => {
+      elem.blur();
+      this.publisher.emit(type);
+    });
+  }
+
+  // фаза захвата, только пока окно открыто: Enter/Esc окна не доходят до
+  // игры
+  _listen(on) {
+    if (on === this._listening) {
+      return;
+    }
+
+    this._listening = on;
+
+    if (on) {
+      document.addEventListener('keydown', this._onKeyDown, true);
+    } else {
+      document.removeEventListener('keydown', this._onKeyDown, true);
+    }
+  }
+
+  _keyDown(event) {
+    // Enter/Esc в поле ввода (чат) принадлежат ему
+    if (isTextInput(event.target)) {
+      return;
+    }
+
+    const type =
+      event.key === 'Enter' ? 'yes' : event.key === 'Escape' ? 'cancel' : null;
+
+    if (!type) {
+      return;
+    }
+
+    event.stopPropagation();
+    event.preventDefault();
+    this.publisher.emit(type);
   }
 }
 
-function showItem(elem, { visible, disabled }) {
-  elem.style.display = visible ? 'block' : 'none';
-  elem.disabled = disabled;
+const TEXT_INPUT_TYPES = new Set([
+  'text',
+  'search',
+  'email',
+  'password',
+  'url',
+  'tel',
+  'number',
+]);
+
+function isTextInput(elem) {
+  if (!elem || elem.nodeType !== 1) {
+    return false;
+  }
+
+  if (elem.isContentEditable || elem.tagName === 'TEXTAREA') {
+    return true;
+  }
+
+  return (
+    elem.tagName === 'INPUT' && TEXT_INPUT_TYPES.has(elem.type.toLowerCase())
+  );
 }

package/src/client/lib/autoRejoin.js

@@ -0,0 +1,161 @@
+// Автовход после перезагрузки в ту же комнату: место в матче потеряно
+// (отказ возобновления, холодный рестарт, ошибка протокола), страница
+// перезагружается на ссылку комнаты — и форма входа игры не показывается,
+// клиент отвечает хосту сохранёнными значениями формы.
+//
+// Метка — в sessionStorage: живёт только в этой вкладке и переживает
+// перезагрузку. Забирается (и удаляется) при разборе маршрута: взводится в
+// памяти, только если маршрут ведёт в ту же комнату. Схема — как у
+// отложенного промоушена (network/Promotion.js).
+
+export const AUTO_REJOIN_STORAGE_KEY = 'vimp.autoRejoin';
+
+// перезагрузка с загрузкой ассетов укладывается с запасом; столько же после
+// автовхода повторная метка не ставится (цикл перезагрузок)
+export const AUTO_REJOIN_TTL_MS = 60000;
+
+const isString = value => typeof value === 'string' && value !== '';
+
+/**
+ * Ставит метку автовхода перед перезагрузкой.
+ * @param {Storage|null} storage - sessionStorage.
+ * @param {{ gameId: string, roomId: string }} target
+ * @param {number} now
+ * @returns {boolean} false — сохранить не удалось.
+ */
+export function saveAutoRejoin(storage, { gameId, roomId } = {}, now) {
+  if (!storage || !isString(gameId) || !isString(roomId)) {
+    return false;
+  }
+
+  try {
+    storage.setItem(
+      AUTO_REJOIN_STORAGE_KEY,
+      JSON.stringify({ gameId, roomId, until: now + AUTO_REJOIN_TTL_MS }),
+    );
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Забирает метку: удаляется при любом исходе.
+ * @param {Storage|null} storage - sessionStorage.
+ * @param {number} now
+ * @returns {{ gameId: string, roomId: string, until: number }|null}
+ *   null — метки нет, она битая или просрочена.
+ */
+export function takeAutoRejoin(storage, now) {
+  if (!storage) {
+    return null;
+  }
+
+  let raw = null;
+
+  try {
+    raw = storage.getItem(AUTO_REJOIN_STORAGE_KEY);
+    storage.removeItem(AUTO_REJOIN_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+
+  if (!raw) {
+    return null;
+  }
+
+  let value;
+
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  if (
+    !isString(value?.gameId) ||
+    !isString(value.roomId) ||
+    !Number.isFinite(value.until) ||
+    now >= value.until
+  ) {
+    return null;
+  }
+
+  return { gameId: value.gameId, roomId: value.roomId, until: value.until };
+}
+
+/**
+ * Автовход в пределах одной загрузки страницы: взвод маршрутом, ответ без
+ * формы, отказ хоста и запрет повторной метки сразу после автовхода.
+ */
+export class AutoRejoin {
+  /**
+   * @param {Object} [options]
+   * @param {Function} [options.now]
+   */
+  constructor({ now = () => Date.now() } = {}) {
+    this._now = now;
+    // { roomId, until } — маршрут ведёт в комнату метки
+    this._armed = null;
+    // ответ без формы ушёл хосту, AUTH_RESULT ещё не пришёл
+    this._pending = false;
+    // когда эта загрузка вошла автовходом
+    this._usedAt = null;
+  }
+
+  /**
+   * Маршрут после перезагрузки входит в комнату метки.
+   * @param {{ roomId: string, until: number }} mark
+   */
+  arm({ roomId, until }) {
+    this._armed = { roomId, until };
+  }
+
+  /**
+   * PS_AUTH_DATA комнаты: true — ответить без формы. Взвод снимается при
+   * любом исходе.
+   * @param {string|null} roomId
+   * @returns {boolean}
+   */
+  begin(roomId) {
+    const armed = this._armed;
+    const now = this._now();
+
+    this._armed = null;
+
+    if (!armed || armed.roomId !== roomId || now >= armed.until) {
+      return false;
+    }
+
+    this._pending = true;
+    this._usedAt = now;
+
+    return true;
+  }
+
+  /**
+   * PS_AUTH_RESULT: true — хост отбил автовход, нужна форма с ошибкой.
+   * @param {*} err
+   * @returns {boolean}
+   */
+  result(err) {
+    const pending = this._pending;
+
+    this._pending = false;
+
+    return pending && Boolean(err);
+  }
+
+  /**
+   * Можно ли ставить метку перед перезагрузкой: сразу после автовхода —
+   * нет, иначе повторяющийся сбой (ошибка протокола) перезагружал бы
+   * страницу без конца; следующий круг покажет форму.
+   * @returns {boolean}
+   */
+  canMark() {
+    return (
+      this._usedAt === null || this._now() - this._usedAt >= AUTO_REJOIN_TTL_MS
+    );
+  }
+}

package/src/client/lib/hostUnloadGuard.js

@@ -1,25 +1,29 @@
-// Защита комнаты от случайного закрытия вкладки хоста (host-migration этап
-// 8.4).
+// Защита комнаты от случайного закрытия вкладки хоста.
 //
 // beforeunload висит, только пока вкладка — текущий хост и в комнате есть
-// другие люди: Ctrl+W/F5 спросит «Leave site?». Финального дампа во время
-// диалога не будет — пока он открыт, главный поток стоит, а именно он
-// ретранслирует Worker → DataChannel; гости это время видят замерший матч.
+// другие люди. При назначенной бете обработчик сразу объявляет уход мастеру
+// (host_leaving — аварийная миграция к ней начинается, пока висит диалог
+// «Leave site?»); без беты — нет: мастер закрыл бы комнату всем, даже если
+// вкладка останется. Затем просит диалог. «Leave» — вкладка закрывается;
+// «Cancel» — мастер снимает её с роли (host_revoked), и она остаётся в
+// комнате гостем. Финального дампа нет: пока диалог открыт, главный поток
+// стоит, а именно он ретранслирует Worker → DataChannel, — откат не больше
+// интервала периодических точек.
 //
 // pagehide срабатывает и после «Leave», и при закрытии без диалога (на
-// мобильных beforeunload ненадёжен — там остаётся только он): хост сразу
-// говорит мастеру host_leaving (аварийная миграция без ожидания обрыва WS),
-// гость — LEAVE хосту и leave_room мастеру (его место освобождается сразу,
-// а не через resumeGraceMs). Всё best-effort: недошедшее перекроет обрыв
-// соединений.
+// мобильных beforeunload ненадёжен — там остаётся только он): хост, ещё не
+// объявивший уход, говорит мастеру host_leaving, гость — LEAVE хосту и
+// leave_room мастеру (его место освобождается сразу, а не через
+// resumeGraceMs). Всё best-effort: недошедшее перекроет обрыв соединений.
 //
-// exit() — вкладка уходит сама («Leave server», переход в лобби): диалог не
-// нужен, уход уже объявлен.
+// exit() — вкладка уходит сама (Exit, переход в лобби): диалог не нужен,
+// уход уже объявлен.
 
 export default class HostUnloadGuard {
   /**
    * @param {Object} options
-   * @param {Function} options.onHostLeave - () pagehide у хоста.
+   * @param {Function} options.onHostLeave - () → boolean: хост уходит
+   *   (beforeunload при бете или pagehide); true — host_leaving отправлен.
    * @param {Function} options.onGuestLeave - () pagehide у гостя комнаты.
    * @param {EventTarget} [options.target] - window (тесты — свой).
    */
@@ -31,10 +35,17 @@ export default class HostUnloadGuard {
     // null — не в комнате | 'host' | 'guest'
     this._role = null;
     this._othersPresent = false;
+    this._hasSuccessor = false;
     this._armed = false;
     this._exiting = false;
+    // host_leaving уже отправлен из beforeunload этой роли хоста
+    this._hostLeaveSent = false;
 
     this._onBeforeUnload = event => {
+      if (this._role === 'host' && this._hasSuccessor) {
+        this._announceHostLeave();
+      }
+
       event.preventDefault();
       // старые браузеры показывают диалог только по returnValue
       event.returnValue = '';
@@ -54,10 +65,17 @@ export default class HostUnloadGuard {
    * @param {Object} state
    * @param {'host'|'guest'|null} state.role
    * @param {boolean} [state.othersPresent]
+   * @param {boolean} [state.hasSuccessor] - мастер назначил бету.
    */
-  update({ role, othersPresent = false }) {
+  update({ role, othersPresent = false, hasSuccessor = false }) {
     this._role = role ?? null;
     this._othersPresent = othersPresent === true;
+    this._hasSuccessor = hasSuccessor === true;
+
+    if (this._role !== 'host') {
+      this._hostLeaveSent = false;
+    }
+
     this._sync();
   }
 
@@ -98,11 +116,18 @@ export default class HostUnloadGuard {
     this._exiting = true;
 
     if (this._role === 'host') {
-      this._onHostLeave();
+      this._announceHostLeave();
     } else if (this._role === 'guest') {
       this._onGuestLeave();
     }
 
     this._sync();
   }
+
+  // host_leaving один раз на роль хоста; флаг — только если ушёл
+  _announceHostLeave() {
+    if (!this._hostLeaveSent && this._onHostLeave() === true) {
+      this._hostLeaveSent = true;
+    }
+  }
 }