vimp-engine 0.35.6 → 0.36.0

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

@@ -17,6 +17,17 @@ import lobbyConfig from '../../../config/lobby.js';
 
 const PERIODS = ['day', 'month', 'all'];
 
+// старт номеров записей (host-migration 7.7): 48 случайных бит из CSPRNG
+// (crypto изоморфен — Worker, браузер, Node). Ключ дубля в auth — (игрок,
+// игра, номер) без комнаты, поэтому разные записи профиля одного игрока
+// (перевход, другая комната, хост из точки) обязаны не пересекаться: 2^48
+// диапазонов на это хватает, и до Number.MAX_SAFE_INTEGER далеко
+const randomWriteSeq = () => {
+  const [high, low] = crypto.getRandomValues(new Uint32Array(2));
+
+  return (high % 2 ** 16) * 2 ** 32 + low;
+};
+
 export default class PlayerDataSync {
   // дефолт fetchImpl обёрнут стрелкой, а не взят как голый `fetch`: из поля
   // объекта он вызывался бы с `this` экземпляра, а в браузере/воркере у
@@ -33,6 +44,7 @@ export default class PlayerDataSync {
       now = () => Date.now(),
       sleep = ms => new Promise(resolve => setTimeout(resolve, ms)),
       random = () => Math.random(),
+      writeSeqStart = randomWriteSeq,
     } = {},
   ) {
     this._gameId = gameId;
@@ -40,22 +52,24 @@ export default class PlayerDataSync {
     this._defaultState = defaultState;
     this._now = now;
     this._sleep = sleep;
+    this._writeSeqStart = writeSeqStart;
     this._entries = new Map(); // participantId -> запись профиля (_makeEntry)
-    // hostId + per-room секрет комнаты (кодревью №1, plan/server-rating/
-    // review.md): неизвестны при создании (назначаются мастером на
-    // register_host, после запуска Worker'а) — проставляются позже через
-    // setHostId(). Едут в теле PUT rank/state; мастер сверяет секрет с
-    // реестром и по нему подставляет проверенную атрибуцию, не доверяя
-    // hostId из тела напрямую (иначе можно было бы подставить чужую комнату)
-    this._hostId = null;
-    this._hostSecret = null;
+    // roomId + секрет эпохи комнаты (host-migration, этап 2): неизвестны при
+    // создании (назначаются мастером на register_host, после запуска
+    // Worker'а) — проставляются позже через setRoom(). Едут в теле PUT
+    // rank/state; мастер сверяет секрет с реестром и по нему подставляет
+    // проверенную атрибуцию, не доверяя roomId из тела напрямую (иначе можно
+    // было бы подставить чужую комнату)
+    this._roomId = null;
+    this._roomSecret = null;
 
     const settings = lobbyConfig.playerData;
 
     // джиттер считается один раз на комнату: сотни серверов, синхронно
     // проснувшихся по круглому минутному таймеру, дают мастеру пик
     this._flushInterval = Math.round(
-      settings.minFlushInterval * (1 + (random() * 2 - 1) * settings.flushJitter),
+      settings.minFlushInterval *
+        (1 + (random() * 2 - 1) * settings.flushJitter),
     );
     // вверх, а не как получится: слот, округлённый вниз, выпускал бы чуть
     // больше запросов в секунду, чем объявленный потолок
@@ -74,9 +88,9 @@ export default class PlayerDataSync {
 
   // вызывается HostGame, когда мастер подтвердил регистрацию комнаты
   // (host_registered) — до этого flush уходит без атрибуции
-  setHostId(hostId, hostSecret = null) {
-    this._hostId = hostId;
-    this._hostSecret = hostSecret;
+  setRoom({ roomId = null, roomSecret = null } = {}) {
+    this._roomId = roomId;
+    this._roomSecret = roomSecret;
   }
 
   _makeEntry(token) {
@@ -89,7 +103,10 @@ export default class PlayerDataSync {
       lastSyncedState: null,
       // значения на момент входа + локальные правки finishGame
       ratings: Object.fromEntries(
-        PERIODS.map(period => [period, { value: 0, placement: null, total: 0 }]),
+        PERIODS.map(period => [
+          period,
+          { value: 0, placement: null, total: 0 },
+        ]),
       ),
       // ПО СРЕЗАМ, а не общим флагом: агрегирующий /auth/placements отдаёт
       // 200, если приехал хоть один срез, и кладёт провалившийся как null.
@@ -100,7 +117,9 @@ export default class PlayerDataSync {
       currentGamePoints: 0, // очки незавершённой игры
       pendingPoints: 0, // сумма завершённых игр, ещё не отправленная
       pendingBest: 0, // лучшая завершённая игра, ещё не отправленная
-      placementRefreshedAt: Object.fromEntries(PERIODS.map(period => [period, 0])),
+      placementRefreshedAt: Object.fromEntries(
+        PERIODS.map(period => [period, 0]),
+      ),
       inFlight: false,
       // промис текущей серии flush: его отдают повторные вызовы, чтобы
       // граница, которая ждёт записи (destroy, уход участника), ждала её
@@ -108,6 +127,22 @@ export default class PlayerDataSync {
       inFlightPromise: null,
       flushAgain: false,
       lastFlushAt: 0,
+      // номер последней записи результата участника (host-migration 7.7),
+      // auth по нему отсеивает повтор. Старт случайный (randomWriteSeq), а не
+      // с нуля: участник, вышедший и вернувшийся в комнату, получает новую
+      // запись — счёт с нуля совпал бы с номерами прошлого входа, и auth
+      // выбросил бы честные очки как дубль
+      writeSeq: this._writeSeqStart(),
+      // записи результата, которым уже выдан номер, по порядку — { writeSeq,
+      // points, best }. Сумма вычтена из pending в момент выдачи номера, и
+      // до ответа auth запись живёт здесь: повтор (сбой сети, 5xx/429, хост
+      // из точки) уходит с ТЕМ ЖЕ номером и той же суммой — дошедший до auth
+      // запрос не засчитается дважды. Больше одной бывает только после
+      // restore (см. там)
+      writes: [],
+      // запись восстановлена из контрольной точки без токена (токены по сети
+      // не ездят): писать нечем, пока участник не вернётся (attachToken)
+      awaitingToken: false,
     };
   }
 
@@ -151,7 +186,10 @@ export default class PlayerDataSync {
   _noteFailure() {
     const { baseMs, maxMs } = lobbyConfig.playerData.backoff;
 
-    this._backoffMs = Math.min(this._backoffMs ? this._backoffMs * 2 : baseMs, maxMs);
+    this._backoffMs = Math.min(
+      this._backoffMs ? this._backoffMs * 2 : baseMs,
+      maxMs,
+    );
     this._backoffUntil = this._now() + this._backoffMs;
   }
 
@@ -180,6 +218,7 @@ export default class PlayerDataSync {
     const entry = this._entries.get(participantId) ?? this._makeEntry(token);
 
     entry.token = token;
+    entry.awaitingToken = false;
     this._entries.set(participantId, entry);
 
     try {
@@ -205,7 +244,9 @@ export default class PlayerDataSync {
       // навсегда выключает её и выглядит снаружи как «данных просто нет»
       if (!ratingsRes.ok) {
         this._noteStatus(ratingsRes.status);
-        console.warn(`[playerData] GET placements ${ratingsRes.status} for ${participantId}`);
+        console.warn(
+          `[playerData] GET placements ${ratingsRes.status} for ${participantId}`,
+        );
       } else {
         const json = (await ratingsRes.json()) ?? {};
         const at = this._now();
@@ -244,7 +285,9 @@ export default class PlayerDataSync {
           // сумму вместо максимума, и refreshPlacement её бы не исправил
           // (при непустом pending он берёт Math.max с показанным)
           rating.value =
-            period === 'month' ? rating.value + server : Math.max(rating.value, server);
+            period === 'month'
+              ? rating.value + server
+              : Math.max(rating.value, server);
           rating.placement = slice.placement ?? null;
           rating.total = Number(slice.total) || 0;
           entry.placementRefreshedAt[period] = at;
@@ -254,14 +297,18 @@ export default class PlayerDataSync {
 
       if (!stateRes.ok) {
         this._noteStatus(stateRes.status);
-        console.warn(`[playerData] GET state ${stateRes.status} for ${participantId}`);
+        console.warn(
+          `[playerData] GET state ${stateRes.status} for ${participantId}`,
+        );
       } else if (!entry.stateLoaded) {
         this._noteSuccess();
 
         const { state } = await stateRes.json();
 
         entry.state =
-          state && Object.keys(state).length ? state : structuredClone(this._defaultState);
+          state && Object.keys(state).length
+            ? state
+            : structuredClone(this._defaultState);
         entry.stateLoaded = true;
         // то, что только что приехало, отправлять обратно незачем
         entry.lastSyncedState = JSON.stringify(entry.state);
@@ -275,7 +322,10 @@ export default class PlayerDataSync {
       // в игре) бэкофф обходит, а именно он и тянет за собой повторный
       // load(), пока рейтинги не загружены
       this._noteFailure();
-      console.warn(`[playerData] load failed for ${participantId}:`, err.message);
+      console.warn(
+        `[playerData] load failed for ${participantId}:`,
+        err.message,
+      );
     }
 
     return entry;
@@ -323,7 +373,10 @@ export default class PlayerDataSync {
 
     const now = this._now();
 
-    if (now - entry.placementRefreshedAt[period] < lobbyConfig.playerData.placementTtl) {
+    if (
+      now - entry.placementRefreshedAt[period] <
+      lobbyConfig.playerData.placementTtl
+    ) {
       return this.getRating(participantId, period);
     }
 
@@ -342,7 +395,9 @@ export default class PlayerDataSync {
 
       if (!res.ok) {
         this._noteStatus(res.status);
-        console.warn(`[playerData] GET placement ${res.status} for ${participantId}`);
+        console.warn(
+          `[playerData] GET placement ${res.status} for ${participantId}`,
+        );
       } else {
         const { placement, total, rank } = (await res.json()) ?? {};
         const rating = entry.ratings[period];
@@ -353,7 +408,9 @@ export default class PlayerDataSync {
         // ноль после смены суток); есть неотправленное — оно ещё не учтено
         // сервером, и показывать меньше уже показанного нельзя
         rating.value =
-          entry.pendingPoints > 0 || entry.pendingBest > 0
+          entry.pendingPoints > 0 ||
+          entry.pendingBest > 0 ||
+          entry.writes.length > 0
             ? Math.max(rating.value, server)
             : server;
         rating.placement = placement ?? null;
@@ -361,7 +418,10 @@ export default class PlayerDataSync {
       }
     } catch (err) {
       this._noteFailure();
-      console.warn(`[playerData] placement failed for ${participantId}:`, err.message);
+      console.warn(
+        `[playerData] placement failed for ${participantId}:`,
+        err.message,
+      );
     }
 
     return this.getRating(participantId, period);
@@ -445,6 +505,114 @@ export default class PlayerDataSync {
     this._entries.delete(participantId);
   }
 
+  // свежий токен участника, вернувшегося в матч новым соединением
+  // (host-migration этап 4): старый мог истечь за время жизни комнаты, а
+  // следующие flush идут с токеном записи. Подгрузку не повторяет —
+  // профиль уже в памяти. false — записи участника нет
+  attachToken(participantId, token) {
+    const entry = this._entries.get(participantId);
+
+    if (!entry || typeof token !== 'string' || token === '') {
+      return false;
+    }
+
+    entry.token = token;
+    entry.awaitingToken = false;
+
+    return true;
+  }
+
+  // ***** контрольная точка (host-migration этап 5) ***** //
+
+  // профили участников без токенов: точка уезжает по сети к другому игроку.
+  // Записи с номерами едут отдельно (writes) и в pending не входят: новый
+  // хост повторит их с теми же номерами, и дошедшая до auth не засчитается
+  // второй раз (host-migration 7.7)
+  serialize() {
+    const out = {};
+
+    for (const [id, entry] of this._entries) {
+      out[id] = {
+        ratings: structuredClone(entry.ratings),
+        ratingsLoaded: { ...entry.ratingsLoaded },
+        currentGamePoints: entry.currentGamePoints,
+        pendingPoints: entry.pendingPoints,
+        pendingBest: entry.pendingBest,
+        state: structuredClone(entry.state),
+        stateLoaded: entry.stateLoaded,
+        lastSyncedState: entry.lastSyncedState,
+        writeSeq: entry.writeSeq,
+        writes: entry.writes.map(write => ({ ...write })),
+      };
+    }
+
+    return out;
+  }
+
+  // поднимает профили из точки. tokens — { [id]: token } только для эстафеты
+  // внутри вкладки; без токена запись ждёт возврата участника (attachToken)
+  restore(state = {}, { tokens = {} } = {}) {
+    for (const [id, saved] of Object.entries(state)) {
+      const token = tokens[id] ?? null;
+      const entry = this._makeEntry(token);
+
+      entry.ratings = structuredClone(saved.ratings ?? entry.ratings);
+      entry.ratingsLoaded = { ...entry.ratingsLoaded, ...saved.ratingsLoaded };
+      entry.currentGamePoints = Number(saved.currentGamePoints) || 0;
+      entry.pendingPoints = Number(saved.pendingPoints) || 0;
+      entry.pendingBest = Number(saved.pendingBest) || 0;
+      entry.state = structuredClone(saved.state ?? this._defaultState);
+      entry.stateLoaded = saved.stateLoaded === true;
+      entry.lastSyncedState = saved.lastSyncedState ?? null;
+      entry.writes = (Array.isArray(saved.writes) ? saved.writes : [])
+        .map(write => this._restoreWrite(write))
+        .filter(Boolean);
+
+      // Номера точки НЕ продолжаются: старый хост мог после неё занять
+      // writeSeq+1, +2…, и свежие очки этого хоста под теми же номерами auth
+      // выбросил бы как дубль. Накопленное на момент точки закрепляется под
+      // writeSeq+1 — этот номер дал бы ему старый хост, и если он его успел
+      // отправить, auth отсеет повтор. Всё дальше — из нового случайного
+      // диапазона (writeSeq из _makeEntry). Точка без номера (Worker до 7.7)
+      // своих записей с номерами не слала — её накопленное остаётся в pending
+      if (
+        Number.isSafeInteger(saved.writeSeq) &&
+        (entry.pendingPoints > 0 || entry.pendingBest > 0)
+      ) {
+        entry.writes.push({
+          writeSeq: saved.writeSeq + 1,
+          points: entry.pendingPoints,
+          best: entry.pendingBest,
+        });
+        entry.pendingPoints = 0;
+        entry.pendingBest = 0;
+      }
+
+      entry.awaitingToken = token === null;
+
+      this._entries.set(id, entry);
+    }
+  }
+
+  _restoreWrite(saved) {
+    if (!saved || !Number.isSafeInteger(saved.writeSeq)) {
+      return null;
+    }
+
+    return {
+      writeSeq: saved.writeSeq,
+      points: Number(saved.points) || 0,
+      best: Number(saved.best) || 0,
+    };
+  }
+
+  // всё ли с мастера уже приехало: тогда повторная загрузка не нужна
+  isLoaded(participantId) {
+    const entry = this._entries.get(participantId);
+
+    return Boolean(entry && entry.stateLoaded && this._ratingsComplete(entry));
+  }
+
   // синхронизирует накопленный результат+state участника на мастер. Сбой не
   // бросается дальше — следующий flush попробует снова с уже накопленными
   // (не потерянными) данными.
@@ -455,7 +623,9 @@ export default class PlayerDataSync {
   async flush(participantId, { urgent = false } = {}) {
     const entry = this._entries.get(participantId);
 
-    if (!entry) {
+    // восстановлен из точки без токена — писать нечем; накопленное ждёт
+    // возврата участника
+    if (!entry || entry.awaitingToken) {
       return;
     }
 
@@ -464,7 +634,10 @@ export default class PlayerDataSync {
 
       // предел владеет движком: просьба игры синхронизироваться чаще
       // minFlushInterval — это просьба, а не команда (решение пользователя 9)
-      if (now - entry.lastFlushAt < this._flushInterval || now < this._backoffUntil) {
+      if (
+        now - entry.lastFlushAt < this._flushInterval ||
+        now < this._backoffUntil
+      ) {
         return;
       }
     }
@@ -514,11 +687,9 @@ export default class PlayerDataSync {
 
     const { token } = entry;
     const requests = [];
-    // отправляем именно накопленное на этот момент и вычитаем его же после
-    // успеха — finishGame во время await не теряется (тот же паттерн, что
-    // F9 в load())
-    const points = entry.pendingPoints;
-    const best = entry.pendingBest;
+    // незакрытая запись прошлой попытки (или предшественника — точка,
+    // эстафета) уходит первой и как есть: тот же номер, та же сумма
+    const carried = entry.writes.length > 0;
 
     // РЕЗУЛЬТАТ ИГРЫ ОТПРАВЛЯЕТСЯ БЕЗУСЛОВНО. Гейт по загруженности здесь
     // был бы вреден: это не абсолютное значение, а строка в леджер (auth
@@ -526,22 +697,49 @@ export default class PlayerDataSync {
     // /auth/placements держал бы очки в pending до конца жизни комнаты и
     // терял бы их вместе с ней. Гейт нужен ровно state ниже: тот PUT
     // ЗАМЕЩАЕТ сохранённый JSON, и дефолтом поверх настоящего нельзя (F4)
-    if (points > 0 || best > 0) {
+    if (!carried && (entry.pendingPoints > 0 || entry.pendingBest > 0)) {
+      // накопленное на этот момент получает номер и уходит из pending сразу:
+      // finishGame во время await копит уже следующую запись
+      entry.writeSeq += 1;
+      entry.writes.push({
+        writeSeq: entry.writeSeq,
+        points: entry.pendingPoints,
+        best: entry.pendingBest,
+      });
+      entry.pendingPoints = 0;
+      entry.pendingBest = 0;
+    }
+
+    const [write] = entry.writes;
+
+    if (write) {
       requests.push(
         this._enqueue(() =>
           this._authedFetch(lobbyConfig.playerData.rankUrl, token, {
             method: 'PUT',
-            body: { points, best, hostId: this._hostId, hostSecret: this._hostSecret },
+            body: {
+              points: write.points,
+              best: write.best,
+              writeSeq: write.writeSeq,
+              roomId: this._roomId,
+              roomSecret: this._roomSecret,
+            },
           }),
         ).then(res => {
-          // pendingBest только растёт: если он тот же — отправленное учтено
-          // целиком; если больше — во время запроса закончилась игра лучше,
-          // и её максимум ещё не отправлен
+          // запись закрыта: следующая получит новый номер. Закрыта старая
+          // (повтор, запись из точки) — оставшиеся записи и накопленное за
+          // время сбоев уходят в этой же серии, а не ждут следующей границы:
+          // срочный flush ухода участника иначе увёз бы их вместе с записью
           const drop = () => {
-            entry.pendingPoints -= points;
+            if (entry.writes[0] === write) {
+              entry.writes.shift();
+            }
 
-            if (entry.pendingBest === best) {
-              entry.pendingBest = 0;
+            if (
+              entry.writes.length > 0 ||
+              (carried && (entry.pendingPoints > 0 || entry.pendingBest > 0))
+            ) {
+              entry.flushAgain = true;
             }
           };
 
@@ -550,13 +748,15 @@ export default class PlayerDataSync {
             drop();
           } else {
             this._noteStatus(res.status);
-            console.warn(`[playerData] PUT rank ${res.status} for ${participantId}`);
+            console.warn(
+              `[playerData] PUT rank ${res.status} for ${participantId}`,
+            );
 
             // 4xx (кроме 429) — отказ ПО СОДЕРЖАНИЮ: повтор того же тела
-            // получит тот же ответ. Оставить его в pending значит слать
+            // получит тот же ответ. Оставить запись открытой значит слать
             // заведомый мусор на каждом flush до конца жизни комнаты, а
-            // накопленное сверху — сверх него. Очки теряются, и это честнее
-            // вечного цикла (сам отказ уже в логе выше)
+            // накопленное после неё не ушло бы вовсе. Очки теряются, и это
+            // честнее вечного цикла (сам отказ уже в логе выше)
             if (res.status >= 400 && res.status < 500 && res.status !== 429) {
               drop();
             }
@@ -572,7 +772,11 @@ export default class PlayerDataSync {
         this._enqueue(() =>
           this._authedFetch(lobbyConfig.playerData.stateUrl, token, {
             method: 'PUT',
-            body: { state: entry.state, hostId: this._hostId, hostSecret: this._hostSecret },
+            body: {
+              state: entry.state,
+              roomId: this._roomId,
+              roomSecret: this._roomSecret,
+            },
           }),
         ).then(res => {
           if (res.ok) {
@@ -580,7 +784,9 @@ export default class PlayerDataSync {
             entry.lastSyncedState = state;
           } else {
             this._noteStatus(res.status);
-            console.warn(`[playerData] PUT state ${res.status} for ${participantId}`);
+            console.warn(
+              `[playerData] PUT state ${res.status} for ${participantId}`,
+            );
           }
         }),
       );
@@ -591,7 +797,10 @@ export default class PlayerDataSync {
     for (const result of await Promise.allSettled(requests)) {
       if (result.status === 'rejected') {
         this._noteFailure();
-        console.warn(`[playerData] flush failed for ${participantId}:`, result.reason?.message);
+        console.warn(
+          `[playerData] flush failed for ${participantId}:`,
+          result.reason?.message,
+        );
       }
     }
   }

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

@@ -59,6 +59,7 @@ export default class RTTManager {
   addUser(gameId) {
     this._users.set(gameId, {
       rtt: 100, // начальное значение RTT (предположение)
+      measured: false, // был ли хоть один pong (иначе rtt — догадка)
       missedPings: 0,
       outstandingPings: new Map(),
       pingIdCounter: 0,
@@ -150,6 +151,7 @@ export default class RTTManager {
       // с помощью экспоненциального скользящего среднего (EMA)
       // (предотвращает резкие скачки RTT из-за единичных сетевых флуктуаций)
       user.rtt = oldRtt * (1 - this._alpha) + newRttSample * this._alpha;
+      user.measured = true;
 
       // если замер RTT превышает установленный порог
       if (this._maxLatency && user.rtt > this._maxLatency) {
@@ -167,4 +169,36 @@ export default class RTTManager {
     // `pong` пришел для пинга, который уже не отслеживается (маловероятно)
     return null;
   }
+
+  /**
+   * @description Медиана сглаженного RTT по измеренным пользователям
+   * (host-migration этап 9a: здоровье хоста). Пользователь без единого pong
+   * не считается — его rtt лишь стартовая догадка.
+   * @param {Function} [include] - (gameId) => boolean; например, без
+   * хост-игрока на loopback.
+   * @returns {{ median: number|null, count: number }}
+   */
+  getRttStats(include = () => true) {
+    const values = [];
+
+    this._users.forEach((user, gameId) => {
+      if (user.measured && include(gameId)) {
+        values.push(user.rtt);
+      }
+    });
+
+    if (values.length === 0) {
+      return { median: null, count: 0 };
+    }
+
+    values.sort((a, b) => a - b);
+
+    const mid = values.length >> 1;
+    const median =
+      values.length % 2 === 1
+        ? values[mid]
+        : (values[mid - 1] + values[mid]) / 2;
+
+    return { median: Math.round(median), count: values.length };
+  }
 }