vimp-engine 0.38.3 → 0.40.0

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';

package/src/lib/VoiceRelay.js

@@ -0,0 +1,200 @@
+import wsports from '../config/wsports.js';
+import {
+  VOICE_BACKPRESSURE_BYTES,
+  VOICE_RELAY_BYTE_RATE,
+  VOICE_RELAY_RATE,
+} from '../config/voiceProtocol.js';
+import { readVoiceHeader, stampForListeners, toBytes } from './voicePacket.js';
+
+// Ретранслятор голоса транспортного уровня (главный поток вкладки хоста).
+// Раздаёт пакеты говорящего слушателям по маршруту, который присылает мета-
+// модуль Voice. Аудио не входит в Worker, порт-машину и ядро. Содержимое
+// пакетов не логируется.
+
+// пополнение ведра: не выше ёмкости burst
+const refill = (value, burst, perSecond, elapsed) =>
+  Math.min(burst, value + elapsed * perSecond);
+
+export default class VoiceRelay {
+  /**
+   * @param {Object} [opts]
+   * @param {Function} [opts.now] - мс; по умолчанию performance.now().
+   * @param {{ packetsPerSecond: number, burst: number }} [opts.rate]
+   * @param {{ bytesPerSecond: number, burst: number }} [opts.byteRate]
+   * @param {number} [opts.backpressureBytes] - порог bufferedAmount выхода.
+   */
+  constructor({
+    now = () => globalThis.performance.now(),
+    rate = VOICE_RELAY_RATE,
+    byteRate = VOICE_RELAY_BYTE_RATE,
+    backpressureBytes = VOICE_BACKPRESSURE_BYTES,
+  } = {}) {
+    this._now = now;
+    this._rate = rate;
+    this._byteRate = byteRate;
+    this._backpressureBytes = backpressureBytes;
+
+    // socketId → { send(bytes), bufferedAmount?() }
+    this._sinks = new Map();
+    // speakerSocketId → { talkId, speakerGameId, listenerSocketIds }
+    this._routes = new Map();
+    // speakerSocketId → { tokens, bytes, last }
+    this._buckets = new Map();
+  }
+
+  /**
+   * Выход к соединению (канал WebRTC гостя или loopback хоста-игрока).
+   * @param {string} socketId
+   * @param {{ send: Function, bufferedAmount?: Function }} sink
+   */
+  attach(socketId, sink) {
+    this._sinks.set(socketId, sink);
+  }
+
+  /**
+   * Соединение ушло: снимает выход, маршрут, где оно говорящий, и убирает его
+   * из списков слушателей.
+   * @param {string} socketId
+   */
+  detach(socketId) {
+    this._sinks.delete(socketId);
+    this._routes.delete(socketId);
+    this._buckets.delete(socketId);
+
+    for (const [speakerSocketId, route] of this._routes) {
+      if (route.listenerSocketIds.includes(socketId)) {
+        this._routes.set(speakerSocketId, {
+          ...route,
+          listenerSocketIds: route.listenerSocketIds.filter(
+            id => id !== socketId,
+          ),
+        });
+      }
+    }
+  }
+
+  /**
+   * Маршрут от модуля Voice; route === null снимает его.
+   * @param {Object} msg
+   * @param {string} msg.speakerSocketId
+   * @param {{ talkId: number, speakerGameId: number,
+   *   listenerSocketIds: string[] }|null} msg.route
+   */
+  applyRoute({ speakerSocketId, route }) {
+    if (!route) {
+      this._routes.delete(speakerSocketId);
+      this._buckets.delete(speakerSocketId);
+      return;
+    }
+
+    // ведро полное только у нового эфира
+    if (this._routes.get(speakerSocketId)?.talkId !== route.talkId) {
+      this._buckets.set(speakerSocketId, {
+        tokens: this._rate.burst,
+        bytes: this._byteRate.burst,
+        last: this._now(),
+      });
+    }
+
+    this._routes.set(speakerSocketId, {
+      talkId: route.talkId,
+      speakerGameId: route.speakerGameId,
+      listenerSocketIds: [...route.listenerSocketIds],
+    });
+  }
+
+  /**
+   * Пакет от соединения socketId. Любой провал проверок — молчаливый выброс.
+   * @param {string} socketId
+   * @param {ArrayBuffer|Uint8Array} data
+   */
+  ingress(socketId, data) {
+    const route = this._routes.get(socketId);
+
+    if (!route) {
+      return;
+    }
+
+    const bytes = toBytes(data);
+    const header = readVoiceHeader(bytes);
+
+    if (
+      !header ||
+      header.port !== wsports.client.VOICE_AUDIO ||
+      header.talkId !== route.talkId ||
+      !this._admit(socketId, bytes.length)
+    ) {
+      return;
+    }
+
+    // id говорящего хост знает сам — клиентскому байту не верим
+    stampForListeners(bytes, route.speakerGameId);
+
+    for (const id of route.listenerSocketIds) {
+      const sink = this._sinks.get(id);
+
+      if (!sink) {
+        continue;
+      }
+
+      // сбой одного выхода не лишает пакета остальных слушателей
+      try {
+        // живой голос важнее старого: переполненному выходу пакет не шлём
+        if (sink.bufferedAmount?.() > this._backpressureBytes) {
+          continue;
+        }
+
+        sink.send(bytes);
+      } catch {
+        // канал закрывается: пакет пропадает, как при потере
+      }
+    }
+  }
+
+  /**
+   * Снимает все маршруты и вёдра (эстафета Worker'ов, закрытие комнаты).
+   * Выходы остаются: транспорты переживают смену Worker'а.
+   */
+  clear() {
+    this._routes.clear();
+    this._buckets.clear();
+  }
+
+  // вёдра говорящего: пакеты (packetsPerSecond, ёмкость burst) и байты
+  // (bytesPerSecond, ёмкость burst). Пакет проходит, только если хватает
+  // обоих; отказ не тратит ни одного
+  _admit(socketId, size) {
+    const bucket = this._buckets.get(socketId);
+    const now = this._now();
+
+    if (!bucket) {
+      return false;
+    }
+
+    const elapsed = (now - bucket.last) / 1000;
+
+    bucket.tokens = refill(
+      bucket.tokens,
+      this._rate.burst,
+      this._rate.packetsPerSecond,
+      elapsed,
+    );
+    bucket.bytes = refill(
+      bucket.bytes,
+      this._byteRate.burst,
+      this._byteRate.bytesPerSecond,
+      elapsed,
+    );
+    bucket.last = now;
+
+    // отрицание «>=», а не «<»: NaN в ведре закрывает, а не открывает
+    if (!(bucket.tokens >= 1 && bucket.bytes >= size)) {
+      return false;
+    }
+
+    bucket.tokens -= 1;
+    bucket.bytes -= size;
+
+    return true;
+  }
+}

package/src/lib/buildClientConfig.js

@@ -1,3 +1,5 @@
+import { normalizeVoiceConfig } from './voiceConfig.js';
+
 // Сборка клиентского CONFIG_DATA (порт 0): merge движковых дефолтов
 // (src/config/clientDefaults.js) с игровым client-конфигом
 // (@vimp-games/tanks/config/client.js) + время голосования и данные client-side
@@ -54,5 +56,10 @@ export const buildClientConfig = (game, defaults, gameClient) => {
   // читает hot-буфер — бандл клиента не обязан совпадать с бандлом хоста
   config.snapshot = game.snapshot;
 
+  // голосовая связь: клиенту нужен весь блок — хоткей, тайминги для HUD и
+  // локальных таймеров, битрейт энкодера и подписи. enabled здесь уже
+  // фактический (createHostRuntime гасит его без ретранслятора)
+  config.voice = game.voice ?? normalizeVoiceConfig(undefined);
+
   return config;
 };