vimp-engine 0.38.2 → 0.39.0

package/src/host/meta/SocketManager.js

@@ -41,6 +41,7 @@ export default class SocketManager {
     this._PORT_ACCOLADES_DATA = ports.ACCOLADES_DATA;
     this._PORT_SESSION_DATA = ports.SESSION_DATA;
     this._PORT_RESUME_RESULT = ports.RESUME_RESULT;
+    this._PORT_VOICE_DATA = ports.VOICE_DATA;
 
     this._soundCues = soundCues;
     this._initialVote = initialVote;
@@ -311,8 +312,8 @@ export default class SocketManager {
   }
 
   /**
-   * Отправка отладочного лога хоста в консоль клиента (порт CONSOLE,
-   * этап 6 плана plan/done/ai-debug). Worker изолирован от DevTools вкладки —
+   * Отправка отладочного лога хоста в консоль клиента (порт CONSOLE).
+   * Worker изолирован от DevTools вкладки —
    * без этого канала его события в браузере не видны вовсе.
    * @param {string} socketId
    * @param {*} data
@@ -349,6 +350,11 @@ export default class SocketManager {
     this._send(socketId, this._PORT_ACCOLADES_DATA, data);
   }
 
+  // голосовая связь: управление эфиром (lib/voiceMessages.js), персонально
+  sendVoice(socketId, data) {
+    this._send(socketId, this._PORT_VOICE_DATA, data);
+  }
+
   /**
    * Отправка сообщения чата.
    * @param {string} socketId

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

@@ -4,11 +4,19 @@
 // разных играх может делать разное или отсутствовать вовсе; незнакомая
 // команда — COMMANDS_NOT_FOUND.
 //
-// Всё, что раньше разбирал движковый switch, доступно играм через контекст:
-// roundManager (смена ника, новый раунд, текущая карта), timerManager
-// (остаток времени карты), playerDataSync (ранг), chat, isDevMode.
+// Контекст команд: roundManager (новый раунд, текущая карта, смена карты),
+// timerManager (остаток времени карты), playerDataSync (ранг), chat,
+// isDevMode и остальные поля deps.
+//
+// Обработчик — код игры и вызывается под защитой: его сбой (исключение или
+// отклонённый промис) уходит в onError, матч продолжается.
 class CommandProcessor {
-  constructor(deps) {
+  /**
+   * @param {Object} deps - контекст игровых команд.
+   * @param {Object} [options]
+   * @param {Function} [options.onError] - (command, error) сбой обработчика.
+   */
+  constructor(deps, { onError = null } = {}) {
     this._chat = deps.chat;
 
     // контекст игровых команд (participants, chat, scripted, roundManager,
@@ -17,6 +25,7 @@ class CommandProcessor {
     this._ctx = deps;
 
     this._commands = new Map();
+    this._onError = onError;
   }
 
   /**
@@ -36,10 +45,31 @@ class CommandProcessor {
     const cmd = arr.shift();
     const handler = this._commands.get(cmd);
 
-    if (handler) {
-      handler(this._ctx, gameId, arr);
-    } else {
+    if (!handler) {
       this._chat.pushSystemByUser(gameId, 'COMMANDS_NOT_FOUND');
+
+      return;
+    }
+
+    // в Worker'е сбой стал бы необработанным reject'ом, в dedicated-процессе —
+    // uncaughtException, то есть падением матча всех игроков
+    try {
+      const result = handler(this._ctx, gameId, arr);
+
+      if (result && typeof result.then === 'function') {
+        result.then(null, error => this._fail(cmd, error));
+      }
+    } catch (error) {
+      this._fail(cmd, error);
+    }
+  }
+
+  // сбой приёмника не должен породить новый сбой
+  _fail(command, error) {
+    try {
+      this._onError?.(command, error);
+    } catch {
+      // приёмник молчит о своих сбоях
     }
   }
 }

package/src/host/meta/modules/voice/Voice.js

@@ -0,0 +1,430 @@
+import clock from '../../../../lib/clock.js';
+import {
+  denyMessage,
+  endMessage,
+  grantMessage,
+  startMessage,
+  stopMessage,
+} from '../../../../lib/voiceMessages.js';
+import {
+  VOICE_DENY,
+  VOICE_END,
+  VOICE_HOST_GRACE_MS,
+  VOICE_MAX_TALK_ID,
+  VOICE_REQUEST_MIN_INTERVAL_MS,
+} from '../../../../config/voiceProtocol.js';
+import { isVoiceSpeakerId } from '../../../../lib/voicePacket.js';
+import { VOICE_DEFAULTS } from '../../../../config/voiceDefaults.js';
+import { listenChannel, speakChannel } from './channels.js';
+
+// Управление эфиром (floor control): кто говорит, кто слышит, таймауты,
+// отзыв. Аудио сюда не попадает никогда — пакеты раздаёт ретранслятор
+// транспортного уровня по маршрутам, которые модуль публикует через
+// setRouteSink. Состояние эфемерно: в контрольные точки не пишется.
+export default class Voice {
+  /**
+   * @param {Object} [config] - нормализованный gameConfig.voice; без него
+   *   берутся VOICE_DEFAULTS (связь выключена).
+   * @param {Object} deps
+   * @param {Object} deps.participants - ParticipantManager.
+   * @param {Object} deps.socketManager - sendVoice(socketId, data).
+   * @param {Function} [deps.isAvailable] - () => boolean: хост может выдавать
+   *   эфир (матч не стоит; причины паузы знает HostGame).
+   * @param {Function} [deps.now] - часы.
+   */
+  constructor(config, { participants, socketManager, isAvailable, now }) {
+    this._config = config ?? VOICE_DEFAULTS;
+    this._participants = participants;
+    this._socketManager = socketManager;
+    this._isAvailable = isAvailable ?? (() => true);
+    this._now = now ?? (() => clock.now());
+    this._routeSink = null;
+
+    // канал → эфир; gameId говорящего → эфир
+    this._talks = new Map();
+    this._speakerTalks = new Map();
+    this._cooldownUntil = new Map();
+    this._lastRequestAt = new Map();
+    this._nextTalkId = 1;
+  }
+
+  /**
+   * Приёмник маршрутов ретранслятора. Без приёмника модуль работает,
+   * маршруты не публикуются.
+   * @param {Function|null} sink - ({ speakerSocketId, route }) => void.
+   */
+  setRouteSink(sink) {
+    this._routeSink = typeof sink === 'function' ? sink : null;
+  }
+
+  get enabled() {
+    return this._config.enabled === true;
+  }
+
+  /**
+   * Запрос эфира. Порядок проверок фиксирован.
+   * @param {string} gameId
+   */
+  request(gameId) {
+    const participant = this._participants.get(gameId);
+
+    if (!participant?.isNetworked) {
+      return;
+    }
+
+    const now = this._now();
+
+    if (!this.enabled || !this._isAvailable()) {
+      this._sendTo(gameId, denyMessage(VOICE_DENY.UNAVAILABLE, 0));
+      return;
+    }
+
+    const wireId = Number(gameId);
+
+    // id на проводе — u8; при ≤ 64 участниках недостижимо
+    if (!isVoiceSpeakerId(wireId)) {
+      this._sendTo(gameId, denyMessage(VOICE_DENY.FORBIDDEN, 0));
+      return;
+    }
+
+    const lastRequestAt = this._lastRequestAt.get(gameId);
+
+    if (
+      lastRequestAt !== undefined &&
+      now - lastRequestAt < VOICE_REQUEST_MIN_INTERVAL_MS
+    ) {
+      this._sendTo(
+        gameId,
+        denyMessage(
+          VOICE_DENY.COOLDOWN,
+          VOICE_REQUEST_MIN_INTERVAL_MS - (now - lastRequestAt),
+        ),
+      );
+      return;
+    }
+
+    this._lastRequestAt.set(gameId, now);
+
+    const own = this._speakerTalks.get(gameId);
+
+    // повторный запрос во время своего эфира идемпотентен
+    if (own) {
+      this._sendTo(
+        gameId,
+        grantMessage(
+          own.talkId,
+          Math.max(0, this._config.maxDurationMs - (now - own.startedAt)),
+        ),
+      );
+      return;
+    }
+
+    const channel = speakChannel(participant, this._config);
+
+    if (!this._isReady(participant) || channel === null) {
+      this._sendTo(gameId, denyMessage(VOICE_DENY.FORBIDDEN, 0));
+      return;
+    }
+
+    const cooldownUntil = this._cooldownUntil.get(gameId) ?? 0;
+
+    if (cooldownUntil > now) {
+      this._sendTo(
+        gameId,
+        denyMessage(VOICE_DENY.COOLDOWN, cooldownUntil - now),
+      );
+      return;
+    }
+
+    if (this._talks.has(channel)) {
+      this._sendTo(gameId, denyMessage(VOICE_DENY.BUSY, 0));
+      return;
+    }
+
+    const talk = {
+      talkId: this._allocTalkId(),
+      speakerId: gameId,
+      wireId,
+      speakerSocketId: participant.socketId,
+      channel,
+      startedAt: now,
+      listeners: new Map(),
+    };
+
+    this._talks.set(channel, talk);
+    this._speakerTalks.set(gameId, talk);
+
+    // маршрут и START раньше GRANT: ретранслятор должен знать маршрут до
+    // первого пакета говорящего
+    this._refreshListeners(talk, this._bucketListeners().get(channel));
+    this._sendTo(gameId, grantMessage(talk.talkId, this._config.maxDurationMs));
+  }
+
+  /**
+   * Отпускание эфира; запоздавшее отпускание старого эфира игнорируется.
+   * @param {string} gameId
+   * @param {number} talkId
+   */
+  release(gameId, talkId) {
+    const talk = this._speakerTalks.get(gameId);
+
+    if (talk && talk.talkId === talkId) {
+      this._end(talk, VOICE_END.RELEASED);
+    }
+  }
+
+  /**
+   * Раз в снапшот-тик, после рассылки кадров: отзыв, таймаут, слушатели.
+   */
+  tick() {
+    if (this._talks.size === 0) {
+      return;
+    }
+
+    const now = this._now();
+    const alive = [];
+
+    for (const talk of [...this._talks.values()]) {
+      const speaker = this._participants.get(talk.speakerId);
+
+      if (
+        !this._isReady(speaker) ||
+        speakChannel(speaker, this._config) !== talk.channel ||
+        speaker.socketId !== talk.speakerSocketId
+      ) {
+        this._end(talk, VOICE_END.REVOKED);
+      } else if (
+        now - talk.startedAt >=
+        this._config.maxDurationMs + VOICE_HOST_GRACE_MS
+      ) {
+        this._end(talk, VOICE_END.TIMEOUT);
+      } else {
+        alive.push(talk);
+      }
+    }
+
+    if (alive.length === 0) {
+      return;
+    }
+
+    const buckets = this._bucketListeners();
+
+    for (const talk of alive) {
+      this._refreshListeners(talk, buckets.get(talk.channel));
+    }
+  }
+
+  /**
+   * Участник снят: его эфир кончается без отправок ему, из слушателей он
+   * исчезает без уведомлений.
+   * @param {string} gameId
+   */
+  removeUser(gameId) {
+    const own = this._speakerTalks.get(gameId);
+
+    if (own) {
+      this._end(own, VOICE_END.REVOKED, { speaker: false });
+    }
+
+    for (const talk of this._talks.values()) {
+      if (talk.listeners.delete(gameId)) {
+        this._publishRoute(talk);
+      }
+    }
+
+    this._cooldownUntil.delete(gameId);
+    this._lastRequestAt.delete(gameId);
+  }
+
+  /**
+   * Все эфиры заканчиваются (REVOKED), кулдауны забываются.
+   * @param {Object} [options]
+   * @param {boolean} [options.notify=true] - слать END/STOP.
+   */
+  reset({ notify = true } = {}) {
+    for (const talk of [...this._talks.values()]) {
+      this._end(talk, VOICE_END.REVOKED, {
+        speaker: notify,
+        listeners: notify,
+      });
+    }
+
+    this._cooldownUntil.clear();
+    this._lastRequestAt.clear();
+  }
+
+  debugState() {
+    const now = this._now();
+
+    return {
+      talks: [...this._talks.values()].map(talk => ({
+        talkId: talk.talkId,
+        speakerId: talk.speakerId,
+        channel: talk.channel,
+        listeners: talk.listeners.size,
+        ageMs: now - talk.startedAt,
+      })),
+    };
+  }
+
+  _isReady(participant) {
+    return Boolean(
+      participant?.isNetworked &&
+      participant.isReady &&
+      participant.detachedAt === null,
+    );
+  }
+
+  // отправка по ТЕКУЩЕМУ socketId: неизвестный сокет SocketManager ругается
+  _sendTo(gameId, message) {
+    const participant = this._participants.get(gameId);
+
+    if (participant) {
+      this._socketManager.sendVoice(participant.socketId, message);
+    }
+  }
+
+  // 1..VOICE_MAX_TALK_ID по кругу, занятые активными эфирами пропускаются
+  // (эфиров не больше, чем каналов, свободный найдётся всегда)
+  _allocTalkId() {
+    const busy = new Set();
+
+    for (const talk of this._talks.values()) {
+      busy.add(talk.talkId);
+    }
+
+    for (;;) {
+      const talkId = this._nextTalkId;
+
+      this._nextTalkId = talkId === VOICE_MAX_TALK_ID ? 1 : talkId + 1;
+
+      if (!busy.has(talkId)) {
+        return talkId;
+      }
+    }
+  }
+
+  _end(talk, reason, { speaker = true, listeners = true } = {}) {
+    this._talks.delete(talk.channel);
+    this._speakerTalks.delete(talk.speakerId);
+
+    this._routeSink?.({
+      speakerSocketId: talk.speakerSocketId,
+      route: null,
+    });
+
+    if (listeners) {
+      for (const gameId of talk.listeners.keys()) {
+        if (gameId !== talk.speakerId) {
+          this._sendTo(gameId, stopMessage(talk.wireId, talk.talkId));
+        }
+      }
+    }
+
+    if (speaker) {
+      this._sendTo(talk.speakerId, stopMessage(talk.wireId, talk.talkId));
+      this._sendTo(talk.speakerId, endMessage(talk.talkId, reason));
+    }
+
+    this._cooldownUntil.set(
+      talk.speakerId,
+      this._now() + this._config.cooldownMs,
+    );
+  }
+
+  // канал → Map<gameId, socketId> слушателей; один проход на тик
+  _bucketListeners() {
+    const activeIds = new Set(this._participants.getActiveList());
+    const buckets = new Map();
+
+    for (const participant of this._participants.getNetworkedReady()) {
+      const channel = listenChannel(participant, {
+        scope: this._config.scope,
+        participants: this._participants,
+        activeIds,
+      });
+
+      if (channel === null) {
+        continue;
+      }
+
+      let bucket = buckets.get(channel);
+
+      if (!bucket) {
+        bucket = new Map();
+        buckets.set(channel, bucket);
+      }
+
+      bucket.set(participant.gameId, participant.socketId);
+    }
+
+    return buckets;
+  }
+
+  // дифф слушателей эфира: START добавленным, STOP ушедшим, новый маршрут.
+  // Переподключённому (socketId сменился без отсоединения) STOP на старый
+  // сокет не шлётся — получателя у него нет
+  _refreshListeners(talk, bucket) {
+    const desired = new Map(bucket ?? []);
+
+    desired.set(talk.speakerId, talk.speakerSocketId);
+
+    const added = [];
+    const gone = [];
+
+    for (const [gameId, socketId] of desired) {
+      if (talk.listeners.get(gameId) !== socketId) {
+        added.push([gameId, socketId]);
+      }
+    }
+
+    for (const gameId of talk.listeners.keys()) {
+      if (!desired.has(gameId)) {
+        gone.push(gameId);
+      }
+    }
+
+    if (added.length === 0 && gone.length === 0) {
+      return;
+    }
+
+    talk.listeners = desired;
+    this._publishRoute(talk);
+
+    for (const gameId of gone) {
+      this._sendTo(gameId, stopMessage(talk.wireId, talk.talkId));
+    }
+
+    const speaker = this._participants.get(talk.speakerId);
+    const start = startMessage({
+      speakerId: talk.wireId,
+      talkId: talk.talkId,
+      name: speaker.name,
+      teamId: speaker.teamId,
+      chatColor: speaker.chatColor ?? null,
+    });
+
+    for (const [, socketId] of added) {
+      this._socketManager.sendVoice(socketId, start);
+    }
+  }
+
+  _publishRoute(talk) {
+    const listenerSocketIds = [];
+
+    for (const [gameId, socketId] of talk.listeners) {
+      if (gameId !== talk.speakerId) {
+        listenerSocketIds.push(socketId);
+      }
+    }
+
+    this._routeSink?.({
+      speakerSocketId: talk.speakerSocketId,
+      route: {
+        talkId: talk.talkId,
+        speakerGameId: talk.wireId,
+        listenerSocketIds,
+      },
+    });
+  }
+}

package/src/host/meta/modules/voice/channels.js

@@ -0,0 +1,58 @@
+// канал «вся комната» (scope 'global')
+export const GLOBAL_CHANNEL = 'global';
+
+/**
+ * Канал, в который участник может говорить; null — говорить нельзя.
+ * Говорит только человек, сам управляющий живым актором.
+ * @param {Object} participant
+ * @param {Object} options
+ * @param {string} options.scope - 'team' | 'global'.
+ * @returns {number|string|null}
+ */
+export function speakChannel(participant, { scope }) {
+  if (!participant?.isNetworked || participant.isWatching !== false) {
+    return null;
+  }
+
+  return scope === 'global' ? GLOBAL_CHANNEL : participant.teamId;
+}
+
+/**
+ * Канал, который участник слышит; null — не слышит ничего. Живой игрок —
+ * свою команду; любой наблюдающий (наблюдатель, погибший, ждущий респауна) —
+ * команду того, за чьей камерой следит.
+ * @param {Object} participant
+ * @param {Object} options
+ * @param {string} options.scope - 'team' | 'global'.
+ * @param {Object} options.participants - ParticipantManager.
+ * @param {Set<string>} [options.activeIds] - живые id (Voice строит один раз
+ *   на тик); без него берётся participants.getActiveList().
+ * @returns {number|string|null}
+ */
+export function listenChannel(participant, { scope, participants, activeIds }) {
+  if (!participant?.isNetworked) {
+    return null;
+  }
+
+  if (scope === 'global') {
+    return GLOBAL_CHANNEL;
+  }
+
+  if (participant.isWatching === false) {
+    return participant.teamId;
+  }
+
+  const watchedId = participant.watchedGameId;
+
+  // наблюдаемый обязан быть в активном списке: камера наблюдателя смотрит
+  // только на него (HostGame._onShotTick → getCamera)
+  const isActive = activeIds
+    ? activeIds.has(watchedId)
+    : participants.getActiveList().includes(watchedId);
+
+  if (watchedId === null || !isActive) {
+    return null;
+  }
+
+  return participants.get(watchedId)?.teamId ?? null;
+}

package/src/host/meta/modules/voice/index.js

@@ -0,0 +1 @@
+export { default } from './Voice.js';