vimp-engine 0.35.5 → 0.36.0

package/src/client/network/SignalingClient.js

@@ -1,8 +1,10 @@
 import Publisher from '../../lib/Publisher.js';
 
 // Клиент сигнального WebSocket мастер-сервера (src/master/SignalingServer.js).
-// Только координация установки P2P: приём welcome (id соединения + iceServers),
-// обмен SDP-офферами/ответами и ICE-кандидатами, сигнальный ping/pong, жалобы.
+// Координация установки P2P и членство в комнате: приём welcome (id
+// соединения + iceServers), регистрация/возврат комнаты хостом, вход/выход
+// участника, обмен SDP-офферами/ответами и ICE-кандидатами, сигнальный
+// ping/pong.
 // Игровой трафик идёт по WebRTC-каналам (WebRtcManager), не через мастер.
 //
 // Входящие сообщения ретранслируются подписчикам через Publisher по полю type;
@@ -53,30 +55,192 @@ export default class SignalingClient {
     ws.onmessage = event => this._onMessage(event.data);
   }
 
-  // клиент → SDP-оффер конкретному хосту
-  sendOffer(hostId, sdp) {
-    this._send({ type: 'webrtc_offer', hostId, sdp });
+  // клиент → SDP-оффер текущему хосту комнаты (мастер резолвит roomId).
+  // resume — переподключение к матчу (host-migration этап 4): хост ждёт
+  // RESUME_REQUEST вместо хендшейка
+  sendOffer(roomId, sdp, memberId, { resume = false } = {}) {
+    this._send({
+      type: 'webrtc_offer',
+      roomId,
+      sdp,
+      memberId,
+      ...(resume ? { resume: true } : {}),
+    });
   }
 
-  // хост → регистрация комнаты у мастера (ответ — событие 'host_registered').
-  // token — Bearer identity-токен хостера (server-rating этап 2): без него
-  // мастер отклоняет регистрацию, т.к. не может атрибутировать комнату и
-  // проверить рейтинг хостера
-  registerHost({ name, maxPlayers, mapName, gameId, gameVersion, token }) {
+  // хост → регистрация комнаты у мастера (ответ — событие 'host_registered'
+  // с roomId/epoch/roomSecret). token — Bearer identity-токен хоста: без
+  // него мастер отклоняет регистрацию (комната привязана к проверенному
+  // пользователю)
+  // info — строка карточки лобби (gameConfig.lobbyInfo игры), null — нет;
+  // caps — возможности вкладки (host-migration этап 6, lib/hostCaps.js);
+  // settings — настройки комнаты для холодного перезапуска преемником
+  // (этап 7.6, lib/roomSettings.js); promotion — { roomId, epoch,
+  // promotionToken } из promote мастера (этап 7.4): преемник занимает
+  // существующую комнату, а не создаёт новую
+  registerHost({
+    gameId,
+    gameVersion,
+    maxPlayers,
+    info,
+    token,
+    memberId,
+    caps,
+    settings,
+    promotion = null,
+  }) {
     this._send({
       type: 'register_host',
-      name,
-      maxPlayers,
-      mapName,
       gameId,
       gameVersion,
+      maxPlayers,
+      info,
+      token,
+      memberId,
+      caps,
+      settings,
+      ...(promotion
+        ? {
+            roomId: promotion.roomId,
+            epoch: promotion.epoch,
+            promotionToken: promotion.promotionToken,
+          }
+        : {}),
+    });
+  }
+
+  // хост → та же комната после реконнекта сигналинга или рестарта мастера.
+  // Поля комнаты (игра, вместимость, карточка) нужны мастеру, чтобы создать её
+  // заново, если реестр пуст
+  reclaimHost({
+    roomId,
+    epoch,
+    roomSecret,
+    memberId,
+    token,
+    gameId,
+    gameVersion,
+    maxPlayers,
+    info,
+    caps,
+    settings,
+  }) {
+    this._send({
+      type: 'reclaim_host',
+      roomId,
+      epoch,
+      roomSecret,
+      memberId,
       token,
+      gameId,
+      gameVersion,
+      maxPlayers,
+      info,
+      caps,
+      settings,
+    });
+  }
+
+  // хост → актуализация карточки комнаты (заодно heartbeat); info: null
+  // очищает строку у мастера
+  updateHost({ info } = {}) {
+    this._send({ type: 'update_host', info });
+  }
+
+  // гость → вошёл в матч комнаты (ответ — 'room_joined'); повторяется с тем
+  // же memberId после реконнекта сигналинга
+  // caps — возможности вкладки: по ним мастер выбирает преемника хоста
+  joinRoom({ roomId, memberId, token, caps }) {
+    this._send({ type: 'join_room', roomId, memberId, token, caps });
+  }
+
+  // участник → возможности изменились (вкладка спрятана/показана, сменился
+  // тип ICE-кандидата) — host-migration этап 6
+  memberUpdate(roomId, caps) {
+    this._send({ type: 'member_update', roomId, caps });
+  }
+
+  // бета → у неё есть полная контрольная точка (id и свежесть: ageMs —
+  // сколько назад бета её получила)
+  standbyStatus({ roomId, epoch, checkpointId, createdAt, ageMs }) {
+    this._send({
+      type: 'standby_status',
+      roomId,
+      epoch,
+      checkpointId,
+      createdAt,
+      ageMs,
+    });
+  }
+
+  // хост → участники с открытыми каналами к нему: мастер считает игроков
+  // и кандидатов в беты только по ним
+  roomPeers({ roomId, epoch, memberIds }) {
+    this._send({ type: 'room_peers', roomId, epoch, memberIds });
+  }
+
+  // хост → ответ на пробу мастера (host-migration этап 7.3): главный поток
+  // жив и держит сигналинг
+  probeAck(nonce) {
+    this._send({ type: 'probe_ack', nonce });
+  }
+
+  // гость → WebRTC к хосту комнаты оборвался (host-migration этап 7.2):
+  // свидетельство мастеру, он решает — проба хоста или смена
+  hostUnreachable(roomId, epoch) {
+    this._send({ type: 'host_unreachable', roomId, epoch });
+  }
+
+  // преемник → поднять матч не удалось (плагин, wasm, init): мастер берёт
+  // следующего кандидата (host-migration этап 7.4)
+  promoteFailed({ roomId, epoch, promotionToken }) {
+    this._send({ type: 'promote_failed', roomId, epoch, promotionToken });
+  }
+
+  // хост → плановая передача роли бете (host-migration этап 8): ответ —
+  // handoff_go {epoch} или handoff_unavailable {reason}. stay — останется ли
+  // вкладка в комнате гостем (мастеру не нужно, для журнала)
+  handoffBegin({ roomId, epoch, reason, stay }) {
+    this._send({ type: 'handoff_begin', roomId, epoch, reason, stay });
+  }
+
+  // хост → здоровье матча (host-migration этап 9c, раз в ~2 с): мастер
+  // сравнивает сеть хоста и беты и при стойком лаге шлёт request_handoff
+  hostHealth({ roomId, epoch, tickRate, peerRttMedian, peerCount }) {
+    this._send({
+      type: 'host_health',
+      roomId,
+      epoch,
+      tickRate,
+      peerRttMedian,
+      peerCount,
     });
   }
 
-  // хост → актуализация комнаты (заодно heartbeat)
-  updateHost({ currentPlayers, mapName } = {}) {
-    this._send({ type: 'update_host', currentPlayers, mapName });
+  // хост → вкладка уходит (pagehide, «Leave server» без передачи): мастер
+  // начинает аварийную миграцию сразу, не дожидаясь обрыва WS
+  hostLeaving(roomId, epoch) {
+    this._send({ type: 'host_leaving', roomId, epoch });
+  }
+
+  // хост → в комнате нет людей, он пишет очки перед закрытием: мастер
+  // скрывает комнату и закрывает её для входа до host_leaving
+  hostClosing(roomId, epoch) {
+    this._send({ type: 'host_closing', roomId, epoch });
+  }
+
+  // гость → покинул комнату
+  leaveRoom(roomId) {
+    this._send({ type: 'leave_room', roomId });
+  }
+
+  // голосование «Change host» (host-migration этап 10): голоса считает мастер
+  hostVoteStart(roomId) {
+    this._send({ type: 'host_vote_start', roomId });
+  }
+
+  hostVoteAnswer({ roomId, voteId, value }) {
+    this._send({ type: 'host_vote_answer', roomId, voteId, value });
   }
 
   // хост → SDP-ответ конкретному клиенту
@@ -89,25 +253,14 @@ export default class SignalingClient {
     this._send({ type: 'pong_host', clientId, pingId });
   }
 
-  // обмен ICE-кандидатами (targetId — hostId со стороны клиента)
+  // обмен ICE-кандидатами (targetId — roomId со стороны клиента)
   sendIceCandidate(targetId, candidate) {
     this._send({ type: 'ice_candidate', targetId, candidate });
   }
 
   // сигнальный ping хосту (замер приблизительный: клиент→мастер→хост)
-  pingHost(hostId, pingId) {
-    this._send({ type: 'ping_host', hostId, pingId });
-  }
-
-  // /like·/unlike напрямую мастеру (минуя хоста-читера), server-rating
-  // этап 2: reason — причина (обязательна), token — Bearer identity-токен
-  // голосующего
-  likeHost(hostId, reason, token) {
-    this._send({ type: 'like_host', hostId, reason, token });
-  }
-
-  unlikeHost(hostId, reason, token) {
-    this._send({ type: 'unlike_host', hostId, reason, token });
+  pingHost(roomId, pingId) {
+    this._send({ type: 'ping_host', roomId, pingId });
   }
 
   close() {

package/src/client/network/StandbyReceiver.js

@@ -0,0 +1,287 @@
+import hostDefaults from '../../config/hostDefaults.js';
+import wsports from '../../config/wsports.js';
+import Publisher from '../../lib/Publisher.js';
+import { decodeStandbyChunk, parseStandbyStream } from './standbyChunks.js';
+
+const PS_SHOT_DATA = wsports.server.SHOT_DATA;
+
+// заголовок бинарного кадра: u8 port, u8 version, u32 seq (big-endian)
+const FRAME_SEQ_OFFSET = 2;
+const FRAME_MIN_BYTES = FRAME_SEQ_OFFSET + 4;
+
+// Преемник (бета, host-migration этап 6): собирает куски контрольных точек
+// из канала standby и держит последнюю полную. Незавершённая точка
+// выбрасывается, как только пошла более новая (в канале ordered куски одной
+// точки идут подряд). Заодно помнит seq последнего кадра хоста, который
+// видел этот клиент, — seqFloor восстановленного матча (этап 5).
+//
+// События publisher: 'checkpoint' (последняя полная точка).
+export default class StandbyReceiver {
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.maxBytes] - предел логического потока точки.
+   * @param {Function} [options.now] - часы (мс).
+   * @param {Object} [options.timers] - { setTimeout, clearTimeout } (тесты).
+   */
+  constructor({
+    maxBytes = hostDefaults.maxCheckpointBytes,
+    now = () => Date.now(),
+    timers = globalThis,
+  } = {}) {
+    this._maxBytes = maxBytes;
+    this._now = now;
+    this._timers = timers;
+
+    this._channel = null;
+    this._partial = null;
+    this._latest = null;
+    this._lastSeenSeq = null;
+    this._waiters = new Set();
+    // передача сорвалась раньше, чем дошла её финальная точка: та ещё может
+    // доехать (ждала разгрузки канала у хоста) и должна прийти периодической
+    this._expectStaleFinal = false;
+
+    this.publisher = new Publisher();
+  }
+
+  // seq последнего кадра хоста, который видел этот клиент (null — ни одного)
+  get lastSeenSeq() {
+    return this._lastSeenSeq;
+  }
+
+  /**
+   * Последняя полная точка.
+   * @returns {Object|null} { bytes, checkpointId, wireId, seq, createdAt,
+   *   final, mode, game, receivedAt }; game — { id, version } из
+   *   дескриптора или null (хост его не прислал).
+   */
+  latest() {
+    return this._latest;
+  }
+
+  /**
+   * Подключает канал standby (новый канал заменяет прежний).
+   * @param {RTCDataChannel} channel
+   */
+  attach(channel) {
+    this._detachChannel();
+    this._channel = channel;
+    channel.binaryType = 'arraybuffer';
+    channel.onmessage = event => this.receive(event.data);
+    channel.onclose = () => {
+      if (this._channel === channel) {
+        this._detachChannel();
+      }
+    };
+  }
+
+  /**
+   * Кадр хоста из игрового транспорта: запоминает его seq.
+   * @param {ArrayBuffer} data
+   */
+  noteFrame(data) {
+    if (!(data instanceof ArrayBuffer) || data.byteLength < FRAME_MIN_BYTES) {
+      return;
+    }
+
+    const view = new DataView(data);
+
+    if (view.getUint8(0) !== PS_SHOT_DATA) {
+      return;
+    }
+
+    this._lastSeenSeq = view.getUint32(FRAME_SEQ_OFFSET, false);
+  }
+
+  /**
+   * Один кусок из канала.
+   * @param {ArrayBuffer|Uint8Array} raw
+   */
+  receive(raw) {
+    const chunk = decodeStandbyChunk(raw);
+
+    if (!chunk || chunk.totalBytes > this._maxBytes) {
+      return;
+    }
+
+    // устаревшее: точка не новее уже собранной
+    if (this._latest && chunk.wireId <= this._latest.wireId) {
+      return;
+    }
+
+    // периодическая, снятая не позже финальной, её не вытесняет: бета
+    // поднимает матч из финальной (тот же тик, без отката)
+    if (
+      this._latest?.final &&
+      !chunk.final &&
+      Number.isInteger(chunk.seq) &&
+      chunk.seq <= this._latest.seq
+    ) {
+      return;
+    }
+
+    let partial = this._partial;
+
+    if (partial && chunk.wireId < partial.wireId) {
+      return;
+    }
+
+    if (!partial || chunk.wireId > partial.wireId) {
+      // пошла более новая — незавершённая выбрасывается
+      if (chunk.index !== 0) {
+        this._partial = null;
+        return;
+      }
+
+      partial = {
+        wireId: chunk.wireId,
+        count: chunk.count,
+        totalBytes: chunk.totalBytes,
+        seq: chunk.seq,
+        final: chunk.final,
+        buffer: new Uint8Array(chunk.totalBytes),
+        offset: 0,
+        next: 0,
+      };
+      this._partial = partial;
+    }
+
+    if (
+      chunk.index !== partial.next ||
+      chunk.count !== partial.count ||
+      chunk.totalBytes !== partial.totalBytes ||
+      partial.offset + chunk.data.byteLength > partial.totalBytes
+    ) {
+      this._partial = null; // дыра или несогласованный кусок — точка битая
+      return;
+    }
+
+    partial.buffer.set(chunk.data, partial.offset);
+    partial.offset += chunk.data.byteLength;
+    partial.next += 1;
+
+    if (partial.next < partial.count) {
+      return;
+    }
+
+    this._partial = null;
+
+    if (partial.offset !== partial.totalBytes) {
+      return;
+    }
+
+    const parsed = parseStandbyStream(partial.buffer);
+
+    if (!parsed) {
+      return;
+    }
+
+    // канал ordered, а хост после финальной не шлёт периодических, пока она
+    // не уйдёт: опоздавшая финальная сорвавшейся передачи — первая точка
+    // после discardFinal, если она вообще будет
+    const final = partial.final && !this._expectStaleFinal;
+
+    this._expectStaleFinal = false;
+    this._latest = {
+      ...parsed,
+      wireId: partial.wireId,
+      seq: partial.seq,
+      final,
+      receivedAt: this._now(),
+    };
+
+    this.publisher.emit('checkpoint', this._latest);
+
+    if (final) {
+      for (const waiter of [...this._waiters]) {
+        if (partial.wireId >= waiter.minWireId) {
+          waiter.resolve(this._latest);
+        }
+      }
+    }
+  }
+
+  /**
+   * Ждёт финальную точку (плановая передача, этап 8).
+   * @param {number} [minWireId] - не старше этого номера точки; уже
+   *   полученная финальная подходит сразу.
+   * @param {number} [timeoutMs]
+   * @returns {Promise<Object>} Точка, как latest().
+   */
+  waitForFinal(minWireId = 0, timeoutMs = 5000) {
+    const latest = this._latest;
+
+    if (latest?.final && latest.wireId >= minWireId) {
+      return Promise.resolve(latest);
+    }
+
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        minWireId,
+        resolve: checkpoint => {
+          this._timers.clearTimeout(waiter.timer);
+          this._waiters.delete(waiter);
+          resolve(checkpoint);
+        },
+        reject: error => {
+          this._timers.clearTimeout(waiter.timer);
+          this._waiters.delete(waiter);
+          reject(error);
+        },
+        timer: null,
+      };
+
+      waiter.timer = this._timers.setTimeout(
+        () => waiter.reject(new Error('final checkpoint timed out')),
+        timeoutMs,
+      );
+      this._waiters.add(waiter);
+    });
+  }
+
+  /**
+   * Плановая передача сорвалась (promote_cancelled): её финальная точка
+   * остаётся последней, но следующую передачу не завершит — хост разморожен
+   * и пришлёт новую финальную. Ещё не дошедшая финальная примется
+   * периодической.
+   */
+  discardFinal() {
+    if (this._latest?.final) {
+      this._latest = { ...this._latest, final: false };
+    } else {
+      this._expectStaleFinal = true;
+    }
+  }
+
+  // standby_released, уход из комнаты, смена эпохи: точки выбросить
+  destroy() {
+    this._detachChannel();
+    this._partial = null;
+    this._latest = null;
+    this._expectStaleFinal = false;
+
+    for (const waiter of [...this._waiters]) {
+      waiter.reject(new Error('standby released'));
+    }
+  }
+
+  _detachChannel() {
+    const channel = this._channel;
+
+    this._channel = null;
+    this._partial = null;
+
+    if (!channel) {
+      return;
+    }
+
+    channel.onmessage = null;
+    channel.onclose = null;
+
+    try {
+      channel.close();
+    } catch {
+      // уже закрыт
+    }
+  }
+}