vimp-engine 0.1.0

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

@@ -0,0 +1,71 @@
+// Координатор голосований: создание, кулдаун и сброс опросов.
+// Инфраструктура поверх Vote + TimerManager; не знает о round/map-логике
+// (вызывающие передают готовые payload и resultFunc).
+class VoteCoordinator {
+  constructor({ vote, chat, timerManager }) {
+    this._vote = vote;
+    this._chat = chat;
+    this._timerManager = timerManager;
+  }
+
+  // проверяет возможность создать голосование в данной категории
+  canCreateVote(voteCategory, gameId) {
+    if (
+      this._timerManager.isVoteBlocked(voteCategory) ||
+      this._vote.hasVoteCategory(voteCategory)
+    ) {
+      if (gameId) {
+        this._chat.pushSystemByUser(gameId, 'VOTE_UNAVAILABLE');
+      }
+
+      return false;
+    }
+
+    return true;
+  }
+
+  // создаёт опрос
+  createVote(data) {
+    const { voteName, voteCategory, payload, resultFunc, userList, gameId } =
+      data;
+
+    // если голосование инициировано пользователем
+    if (gameId) {
+      this._chat.pushSystemByUser(gameId, 'VOTE_CREATED');
+    }
+
+    const onStart = () => {
+      if (gameId) {
+        this._chat.pushSystemByUser(gameId, 'VOTE_STARTED');
+        this._vote.addInVote(voteName, 'Yes');
+      }
+
+      // таймер на сбор результатов
+      this._timerManager.startVoteTimer(voteName, () => {
+        // таймер временной блокировки повторного голосования
+        this._timerManager.startVoteBlockTimer(voteCategory, () => {});
+
+        const result = this._vote.getResult(voteName);
+
+        resultFunc(result);
+      });
+    };
+
+    this._vote.createVote({
+      name: voteName,
+      category: voteCategory,
+      payload,
+      userList,
+      onStartCallback: onStart,
+    });
+  }
+
+  // сбрасывает активные и запланированные опросы и таймеры по ним
+  reset() {
+    this._timerManager.stopAllVoteTimers();
+    this._timerManager.stopAllBlockedVoteTimers();
+    this._vote.reset();
+  }
+}
+
+export default VoteCoordinator;

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

@@ -0,0 +1,181 @@
+// Singleton Panel
+
+let panel;
+
+class Panel {
+  // config — схема панели игры: { fields: { имя: { key, value } }, activeKey }
+  constructor(config) {
+    if (panel) {
+      return panel;
+    }
+
+    panel = this;
+
+    this._fields = config.fields;
+    this._activeKey = config.activeKey;
+
+    this._data = {};
+    this._timerManager = null;
+
+    this._emptyPanel = Object.values(this._fields).map(item => item.key);
+    this._defaultPanel = {};
+
+    this._lastSentRoundTime = -1; // кеширование последнего значения времени
+
+    for (const key of Object.keys(this._fields)) {
+      this._defaultPanel[key] = this._fields[key].value;
+    }
+  }
+
+  // внедряет зависимость TimerManager
+  injectTimerManager(timerManager) {
+    this._timerManager = timerManager;
+    this._lastSentRoundTime = this._timerManager.getRoundTimeLeft();
+  }
+
+  // сбрасывает внутреннее состояние пользователей к дефолтному
+  reset() {
+    for (const gameId in this._data) {
+      if (Object.hasOwn(this._data, gameId)) {
+        const user = this._data[gameId];
+
+        user.values = { ...this._defaultPanel };
+        user.pendingChanges = {}; // очистка, без добавления новых данных
+      }
+    }
+  }
+
+  // добавляет пользователя
+  addUser(gameId) {
+    this._data[gameId] = {
+      values: { ...this._defaultPanel },
+      pendingChanges: {}, // объект для хранения только измененных данных
+    };
+  }
+
+  // удаляет пользователя
+  removeUser(gameId) {
+    delete this._data[gameId];
+  }
+
+  // очищает ожидающие изменения для пользователя
+  // требуется, когда состояние пользователя резко меняется
+  // (например при уничтожении)
+  invalidate(gameId) {
+    const user = this._data[gameId];
+
+    if (user) {
+      user.pendingChanges = {};
+    }
+  }
+
+  // обновляет данные пользователя
+  // param: имя поля из схемы (например, 'health', 'w1')
+  // value: значение
+  // operation: 'set', 'decrement', 'increment'
+  updateUser(gameId, param, value, operation = 'decrement') {
+    const user = this._data[gameId];
+    const values = user.values;
+    const currentValue = values[param];
+    let newValue;
+
+    if (operation === 'set') {
+      newValue = value;
+    } else if (operation === 'decrement') {
+      newValue = currentValue - value;
+    } else if (operation === 'increment') {
+      newValue = currentValue + value;
+    }
+
+    if (newValue < 0) {
+      newValue = 0;
+    }
+
+    values[param] = newValue;
+    user.pendingChanges[this._fields[param].key] = newValue;
+  }
+
+  // устанавливает активное оружие (ключ кадра — activeKey схемы)
+  setActiveWeapon(gameId, weaponKey) {
+    const user = this._data[gameId];
+    user.pendingChanges[this._activeKey] = weaponKey;
+  }
+
+  // проверяет, достаточно ли у пользователя ресурсов для действия
+  hasResources(gameId, param, value) {
+    const user = this._data[gameId];
+    const currentValue = user.values[param];
+
+    return currentValue >= value;
+  }
+
+  // возвращает текущее значение параметра для пользователя
+  getCurrentValue(gameId, param) {
+    const user = this._data[gameId];
+
+    return user.values[param];
+  }
+
+  // вычисляет все обновления панели за один тик
+  processUpdates() {
+    const updates = {};
+    const currentTime = this._timerManager.getRoundTimeLeft();
+    const timeChanged = currentTime !== this._lastSentRoundTime;
+
+    if (timeChanged) {
+      this._lastSentRoundTime = currentTime;
+    }
+
+    for (const gameId in this._data) {
+      if (Object.hasOwn(this._data, gameId)) {
+        const user = this._data[gameId];
+        const userChanges = user.pendingChanges;
+        const userData = [];
+
+        if (timeChanged) {
+          userData.push(`t:${currentTime}`);
+        }
+
+        for (const key in userChanges) {
+          if (Object.hasOwn(userChanges, key)) {
+            userData.push(`${key}:${userChanges[key]}`);
+          }
+        }
+
+        if (userData.length) {
+          updates[gameId] = userData;
+        }
+
+        user.pendingChanges = {};
+      }
+    }
+
+    return updates;
+  }
+
+  // возвращает полный набор данных для инициализации панели игрока
+  getFullPanel(gameId) {
+    const user = this._data[gameId];
+    user.pendingChanges = {}; // очистка старых изменений
+
+    const panelData = [`t:${this._lastSentRoundTime}`];
+    const values = user.values;
+
+    for (const param in values) {
+      if (Object.hasOwn(values, param)) {
+        const key = this._fields[param].key;
+        const value = values[param];
+
+        panelData.push(`${key}:${value}`);
+      }
+    }
+    return panelData;
+  }
+
+  // возвращает пустые данные (ключи без значений)
+  getEmptyPanel() {
+    return [`t:${this._lastSentRoundTime}`].concat(this._emptyPanel);
+  }
+}
+
+export default Panel;

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

@@ -0,0 +1,176 @@
+import lobbyConfig from '../../../config/lobby.js';
+
+// Rank/state участника (Этап B4). Игрок приходит в игру с ником из JWT —
+// rank (числовой рейтинг) и state (непрозрачный для движка JSON, "скиллы")
+// подгружаются с мастера (прокси central auth-сервиса) при входе и
+// синхронизируются обратно по естественным границам жизненного цикла
+// (RoundManager: смена карты, конец раунда). Схему/дефолты state объявляет
+// игра — здесь это чёрный ящик.
+export default class PlayerDataSync {
+  constructor(gameId, { fetchImpl = fetch, defaultState = {} } = {}) {
+    this._gameId = gameId;
+    this._fetch = fetchImpl;
+    this._defaultState = defaultState;
+    this._entries = new Map(); // participantId -> { token, rank, state }
+    // hostId + per-room секрет комнаты (кодревью №1, plan/server-rating/
+    // review.md): неизвестны при создании (назначаются мастером на
+    // register_host, после запуска Worker'а) — проставляются позже через
+    // setHostId(). Едут в теле PUT rank/state; мастер сверяет секрет с
+    // реестром и по нему подставляет проверенную атрибуцию, не доверяя
+    // hostId из тела напрямую (иначе можно было бы подставить чужую комнату)
+    this._hostId = null;
+    this._hostSecret = null;
+  }
+
+  // вызывается HostGame, когда мастер подтвердил регистрацию комнаты
+  // (host_registered) — до этого flush уходит без атрибуции
+  setHostId(hostId, hostSecret = null) {
+    this._hostId = hostId;
+    this._hostSecret = hostSecret;
+  }
+
+  _authedFetch(url, token, { method = 'GET', body } = {}) {
+    return this._fetch(`${url}?game=${this._gameId}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${token}`,
+        ...(body ? { 'content-type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  // подгружает rank+state с мастера при входе игрока. Сбой auth-сервиса не
+  // должен блокировать вход — участник стартует с дефолтами (rank 0, пустой
+  // state) и попробует синхронизироваться на следующем flush.
+  // rankLoaded/stateLoaded (F4 кодревью) отражают, был ли реально получен
+  // серверный rank/state — flush не должен PUT'ить дефолт поверх настоящих
+  // сохранённых значений, если загрузка не удалась (auth недоступен на join)
+  async load(participantId, token) {
+    const entry = this._entries.get(participantId) ?? {
+      token,
+      rank: 0,
+      // server-rating этап 1: PUT /auth/rank шлёт дельту матча, не абсолют
+      // (auth ведёт леджер) — pendingRankDelta копит то, что ещё не flush'нуто
+      pendingRankDelta: 0,
+      state: structuredClone(this._defaultState),
+      rankLoaded: false,
+      stateLoaded: false,
+    };
+
+    entry.token = token;
+    this._entries.set(participantId, entry);
+
+    try {
+      const [rankRes, stateRes] = await Promise.all([
+        this._authedFetch(lobbyConfig.auth.rankUrl, token),
+        this._authedFetch(lobbyConfig.auth.stateUrl, token),
+      ]);
+
+      if (rankRes.ok && !entry.rankLoaded) {
+        // F9: во время await мог накопиться addRank-дельта поверх
+        // стартового 0 — прибавляем, а не перетираем серверным значением
+        entry.rank += (await rankRes.json()).rank ?? 0;
+        entry.rankLoaded = true;
+      }
+
+      if (stateRes.ok && !entry.stateLoaded) {
+        const { state } = await stateRes.json();
+
+        entry.state =
+          state && Object.keys(state).length ? state : structuredClone(this._defaultState);
+        entry.stateLoaded = true;
+      }
+    } catch {
+      // недоступность auth-сервиса — остаёмся на дефолтах, следующий
+      // flush повторит load() перед синхронизацией (см. flush)
+    }
+
+    return entry;
+  }
+
+  getRank(participantId) {
+    return this._entries.get(participantId)?.rank ?? 0;
+  }
+
+  getState(participantId) {
+    return this._entries.get(participantId)?.state ?? this._defaultState;
+  }
+
+  // прибавляет к рангу игрока (вызывается из RoundManager.reportKill —
+  // тот же чокпоинт, что и Stat score)
+  addRank(participantId, delta) {
+    const entry = this._entries.get(participantId);
+
+    if (entry) {
+      entry.rank += delta;
+      entry.pendingRankDelta += delta;
+    }
+  }
+
+  setState(participantId, state) {
+    const entry = this._entries.get(participantId);
+
+    if (entry) {
+      entry.state = state;
+    }
+  }
+
+  removeUser(participantId) {
+    this._entries.delete(participantId);
+  }
+
+  // синхронизирует накопленные rank+state участника на мастер. Сбой не
+  // бросается дальше — следующий flush попробует снова с уже накопленными
+  // (не потерянными) данными. F4: если исходная load() не удалась, PUT
+  // дефолтом затёр бы реальный сохранённый rank/state — вместо этого
+  // повторяем load() и шлём PUT только для того, что реально загрузилось
+  async flush(participantId) {
+    let entry = this._entries.get(participantId);
+
+    if (!entry) {
+      return;
+    }
+
+    if (!entry.rankLoaded || !entry.stateLoaded) {
+      entry = await this.load(participantId, entry.token);
+    }
+
+    const { token, state, rankLoaded, stateLoaded } = entry;
+    const requests = [];
+
+    if (rankLoaded) {
+      // отправляем именно накопленную на этот момент дельту и вычитаем её
+      // же после успеха — addRank во время await не теряется (тот же
+      // паттерн, что F9 в load())
+      const delta = entry.pendingRankDelta;
+
+      requests.push(
+        this._authedFetch(lobbyConfig.auth.rankUrl, token, {
+          method: 'PUT',
+          body: { delta, hostId: this._hostId, hostSecret: this._hostSecret },
+        }).then(res => {
+          if (res.ok) {
+            entry.pendingRankDelta -= delta;
+          }
+        }),
+      );
+    }
+
+    if (stateLoaded) {
+      requests.push(this._authedFetch(lobbyConfig.auth.stateUrl, token, {
+        method: 'PUT',
+        body: { state, hostId: this._hostId, hostSecret: this._hostSecret },
+      }));
+    }
+
+    await Promise.allSettled(requests);
+  }
+
+  // синхронизирует всех текущих участников (границы раунда/карты)
+  flushAll() {
+    return Promise.allSettled(
+      [...this._entries.keys()].map(id => this.flush(id)),
+    );
+  }
+}

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

@@ -0,0 +1,168 @@
+/**
+ * @class RTTManager
+ * @description Управляет расчетом Round Trip Time (RTT) для пользователя,
+ * отслеживает пропущенные пинги и инициирует кик игроков за высокую задержку
+ * или отсутствие ответов.
+ */
+export default class RTTManager {
+  /**
+   * @param {object} params - Параметры конфигурации RTT.
+   * @param {number} params.maxMissedPings - Максимальное количество
+   * пропущенных пингов перед киком.
+   * @param {number} params.maxLatency - Максимально допустимая
+   * задержка RTT (в мс) перед киком.
+   * @param {object} callbacks - Колбэки для взаимодействия с внешним модулем.
+   * @param {function(string): void} callbacks.onKickForMissedPings -
+   * Колбэк при кике за пропущенные пинги.
+   * @param {function(string): void} callbacks.onKickForMaxLatency -
+   * Колбэк при кике за высокую задержку.
+   */
+  constructor(params, callbacks) {
+    this._maxMissedPings = params.maxMissedPings;
+    this._maxLatency = params.maxLatency;
+    this._callbacks = callbacks;
+
+    /**
+     * @private
+     * @description Коэффициент сглаживания для
+     * экспоненциального скользящего среднего (EMA).
+     * Определяет, насколько сильно новый замер RTT влияет на текущее значение.
+     */
+    this._alpha = 0.1;
+
+    /**
+     * @private
+     * @description Коллекция Map для хранения RTT-данных
+     * по каждому пользователю.
+     * @type {Map<string, {
+     *     rtt: number,
+     *     missedPings: number,
+     *     outstandingPings: Map<number, number>,
+     *     pingIdCounter: number
+     *   }>
+     * }
+     * - rtt: сглаженное значение RTT
+     * - missedPings: счетчик пропущенных пингов подряд
+     * - outstandingPings: Map для отслеживания отправленных,
+     *   но еще не отвеченных пингов { pingID: time }
+     * - pingIdCounter: счетчик ID для следующего пинга
+     */
+    this._users = new Map();
+  }
+
+  /**
+   * @description Добавляет нового пользователя в систему отслеживания RTT.
+   * @param {string} gameId - Уникальный идентификатор пользователя.
+   */
+  addUser(gameId) {
+    this._users.set(gameId, {
+      rtt: 100, // начальное значение RTT (предположение)
+      missedPings: 0,
+      outstandingPings: new Map(),
+      pingIdCounter: 0,
+    });
+  }
+
+  /**
+   * @description Удаляет пользователя из системы отслеживания RTT.
+   * @param {string} gameId - Уникальный идентификатор пользователя.
+   */
+  removeUser(gameId) {
+    this._users.delete(gameId);
+  }
+
+  /**
+   * @description Планирует следующий пинг для всех пользователей.
+   * Обновляет счетчики пропущенных пингов и готовит новые ID для отправки.
+   * Инициирует кик для игроков, превысивших лимит пропущенных пингов.
+   * @returns {Iterator<[string, object]>} -
+   * Итератор пар [gameId, userData] для отправки пингов.
+   */
+  scheduleNextPing() {
+    const toKick = [];
+
+    this._users.forEach((user, gameId) => {
+      // если с прошлого раза остался неотвеченный пинг,
+      // он считается пропущенным
+      if (user.outstandingPings.size > 0) {
+        user.missedPings += 1;
+
+        // если пользователь превысил лимит пропущенных пингов
+        if (this._maxMissedPings && user.missedPings >= this._maxMissedPings) {
+          toKick.push(gameId);
+          return; // пропускается отправка нового пинга
+        }
+      }
+
+      // новый пинг
+      user.pingIdCounter += 1;
+      const time = Date.now();
+
+      // удаление старых пингов и запись нового
+      // `outstandingPings` содержит только один, последний отправленный пинг
+      user.outstandingPings.clear();
+      user.outstandingPings.set(user.pingIdCounter, time);
+    });
+
+    // кики после завершения итерации по коллекции
+    toKick.forEach(gameId => {
+      this._callbacks.onKickForMissedPings(gameId);
+    });
+
+    // итератор для внешнего модуля, для отправки пингов
+    return this._users.entries();
+  }
+
+  /**
+   * @description Обрабатывает ответное сообщение 'pong' от клиента.
+   * Вычисляет новый RTT, обновляет статистику и проверяет
+   * на превышение максимальной задержки.
+   * @param {string} gameId - Идентификатор пользователя,
+   * от которого пришел 'pong'.
+   * @param {number} pingId - ID пинга, на который пришел ответ.
+   * @returns {number|null} - Рассчитанное значение RTT (latency) или null,
+   * если 'pong' некорректен.
+   */
+  handlePong(gameId, pingId) {
+    const user = this._users.get(gameId);
+
+    // если пользователь был удален, пока 'pong' был в пути
+    if (!user) {
+      return null;
+    }
+
+    // игнорование ответов на устаревшие пинги,
+    // чтобы избежать ложных срабатываний
+    // обработка ответа на самый последний отправленный пинг
+    if (pingId !== user.pingIdCounter) {
+      return null;
+    }
+
+    const time = user.outstandingPings.get(pingId);
+
+    if (time) {
+      const newRttSample = Date.now() - time;
+      const oldRtt = user.rtt;
+
+      // сглаживание значения RTT
+      // с помощью экспоненциального скользящего среднего (EMA)
+      // (предотвращает резкие скачки RTT из-за единичных сетевых флуктуаций)
+      user.rtt = oldRtt * (1 - this._alpha) + newRttSample * this._alpha;
+
+      // если замер RTT превышает установленный порог
+      if (this._maxLatency && user.rtt > this._maxLatency) {
+        this._callbacks.onKickForMaxLatency(gameId);
+        return null; // не возвращается RTT, т.к. игрок будет кикнут
+      }
+
+      // сброс счетчика пропущенных пингов, т.к. игрок ответил
+      user.missedPings = 0;
+      user.outstandingPings.delete(pingId);
+
+      return Math.round(newRttSample);
+    }
+
+    // `pong` пришел для пинга, который уже не отслеживается (маловероятно)
+    return null;
+  }
+}