vimp-engine 0.38.3 → 0.39.0

package/src/client/main.js

@@ -26,6 +26,9 @@ import StatCtrl from './components/controller/Stat.js';
 import VoteModel from './components/model/Vote.js';
 import VoteView from './components/view/Vote.js';
 import VoteCtrl from './components/controller/Vote.js';
+import VoiceModel from './components/model/Voice.js';
+import VoiceView from './components/view/Voice.js';
+import VoiceCtrl from './components/controller/Voice.js';
 import {
   buildForm,
   mergeRoomDefaults,
@@ -45,6 +48,8 @@ import {
 import { createContextTracker } from './lib/contextTracker.js';
 import { createLocalPlayer } from './lib/localPlayer.js';
 import { createAccolades } from './lib/accolades.js';
+import { createVoiceState } from './lib/voiceState.js';
+import { parseVoiceMessage } from '../lib/voiceMessages.js';
 import { createDiagnostics } from './lib/diagnostics.js';
 import { fetchRetrying, isNetworkFailure } from './lib/retryOnNetworkError.js';
 import { dispatchSocketMessage } from './lib/socketDispatch.js';
@@ -313,6 +318,7 @@ const PS_CHAT_DATA = wsports.server.CHAT_DATA;
 const PS_VOTE_DATA = wsports.server.VOTE_DATA;
 const PS_KEYSET_DATA = wsports.server.KEYSET_DATA;
 const PS_ACCOLADES_DATA = wsports.server.ACCOLADES_DATA;
+const PS_VOICE_DATA = wsports.server.VOICE_DATA;
 const PS_SESSION_DATA = wsports.server.SESSION_DATA;
 const PS_RESUME_RESULT = wsports.server.RESUME_RESULT;
 
@@ -325,6 +331,7 @@ const PC_MAP_READY = wsports.client.MAP_READY;
 const PC_FIRST_SHOT_READY = wsports.client.FIRST_SHOT_READY;
 const PC_KEYS_DATA = wsports.client.KEYS_DATA;
 const PC_CHAT_DATA = wsports.client.CHAT_DATA;
+const PC_VOICE_FLOOR = wsports.client.VOICE_FLOOR;
 const PC_VOTE_DATA = wsports.client.VOTE_DATA;
 const PC_PONG = wsports.client.PONG;
 const PC_LEAVE = wsports.client.LEAVE;
@@ -433,6 +440,15 @@ const localPlayer = createLocalPlayer(() => clientCore);
 // сервис пула зависимостей: «какое место у этой сущности в глобальном
 // топе?». Места считает хост, part рисует за них знак (см. lib/accolades.js)
 const accolades = createAccolades();
+// голосовая связь: кто в эфире (сервис партов `voice`) — хранилище пишет
+// движок по VOICE_DATA, парты только читают (lib/voiceState.js)
+const voice = createVoiceState();
+// подсистема голоса грузится лениво — только у игры с включённой связью
+let voiceClient = null;
+let voiceConfig = null;
+// номер запуска подсистемы: чанк, догрузившийся после закрытия матча,
+// уничтожает свой клиент сам
+let voiceSession = 0;
 let inputSeq = 0; // номер отправленного ввода (KEYS_DATA)
 
 // обратный индекс снапшот-схемы игры (CONFIG_DATA.snapshot):
@@ -451,6 +467,9 @@ socketMethods[PS_CONFIG_DATA] = async data => {
     return;
   }
 
+  voiceConfig = data.voice ?? null;
+  voice.store.setEnabled(voiceConfig?.enabled === true);
+
   gameSets = data.parts.gameSets;
   entitiesOnCanvas = data.parts.entitiesOnCanvas;
 
@@ -541,6 +560,9 @@ socketMethods[PS_CONFIG_DATA] = async data => {
       // места в глобальном топе: знак за место рисует part игры, движок
       // раздаёт только числа (см. lib/accolades.js)
       accolades,
+      // индикаторы эфира связи для партов игры: кто сейчас говорит
+      // (только чтение, см. lib/voiceState.js)
+      voice: voice.service,
       // база ассетов игры — тем же каналом, что и путь к звукам (см. выше):
       // картинки карт живут в пакете игры (dist/img/), движок их не раздаёт.
       // part, объявивший сервис в componentDependencies, строит URL сам —
@@ -909,6 +931,19 @@ socketMethods[PS_ACCOLADES_DATA] = data => {
   modules.stat?.applyAccolades?.();
 };
 
+// голосовая связь: кортеж разбирается один раз (lib/voiceMessages.js) —
+// хост в P2P чужой, непрошедшее проверку не доходит ни до кого
+socketMethods[PS_VOICE_DATA] = data => {
+  const message = parseVoiceMessage(data);
+
+  if (!message) {
+    return;
+  }
+
+  voice.store.apply(message);
+  voiceClient?.handleFloorMessage(message);
+};
+
 // chat data
 socketMethods[PS_CHAT_DATA] = data => {
   modules.chat.add(data);
@@ -1214,6 +1249,20 @@ function runModules(data) {
 
   modules.vote = new VoteCtrl(voteModel, voteView);
 
+  //==========================================//
+  // Voice Module (голосовая связь)
+  //==========================================//
+
+  if (voiceConfig?.enabled) {
+    const voiceModel = new VoiceModel({ texts: voiceConfig.texts });
+    const voiceView = new VoiceView(voiceModel, gameContainer);
+
+    modules.voice = new VoiceCtrl(voiceModel, voiceView);
+    modules.controls.setPushToTalk(voiceConfig.hotkey);
+    controlsModel.publisher.on('ptt', held => voiceClient?.setPttHeld(held));
+    startVoiceClient();
+  }
+
   //==========================================//
   // Подписка на события
   //==========================================//
@@ -1234,6 +1283,8 @@ function runModules(data) {
     'keyUp',
     modules.controls.remove.bind(modules.controls),
   );
+  // потеря фокуса окна отпускает связь: keyup снаружи не придёт
+  inputListener.publisher.on('blur', () => modules.controls?.releasePtt());
   inputListener.publisher.on(
     'mouseAction',
     modules.controls.resetCursorHideTimer.bind(modules.controls),
@@ -1337,6 +1388,58 @@ function sending(name, data, reliable = true) {
   supervisor?.send(JSON.stringify([name, data]), reliable);
 }
 
+// подсистема голоса — отдельный чанк: игре без связи и standalone он не нужен
+function startVoiceClient() {
+  const session = ++voiceSession;
+
+  import('./voice/VoiceClient.js')
+    .then(async ({ default: VoiceClient }) => {
+      const client = new VoiceClient({
+        config: voiceConfig,
+        sendFloor: payload => sending(PC_VOICE_FLOOR, payload),
+        sendAudio: bytes => supervisor?.sendVoice(bytes),
+        soundManager,
+        localPlayer,
+        hud: modules.voice,
+        voiceStore: voice.store,
+        // стиль связи — хуки игры: звуки сигналов и окраска речи; старый
+        // плагин их не имеет — нейтральные тоны, чистый голос
+        voiceSounds: clientPlugin.hooks.voiceSounds,
+        voiceFilter: clientPlugin.hooks.voiceFilter,
+        diagnostics,
+      });
+
+      try {
+        await client.init();
+      } catch (error) {
+        // недособранный клиент освобождает то, что успел создать; сбой
+        // уборки не подменяет первопричину
+        try {
+          client.destroy();
+        } catch {
+          // клиент собран не до конца
+        }
+
+        throw error;
+      }
+
+      // матч закрылся, пока грузился чанк: клиент не нужен
+      if (session !== voiceSession) {
+        client.destroy();
+        return;
+      }
+
+      voiceClient = client;
+    })
+    .catch(error => {
+      diagnostics.capture(error, { source: 'voice' });
+
+      if (session === voiceSession) {
+        modules.voice?.showOwn('error', { textKey: 'unavailable' });
+      }
+    });
+}
+
 // отправка сообщения чата хосту (точка перехвата команд, адресованных
 // мастеру, а не хосту)
 function handleChatSend(message) {
@@ -1397,6 +1500,8 @@ function handleVisibilityChange() {
   // если вкладка неактивна, выключение звука
   if (document.visibilityState === 'hidden') {
     hiddenAt = performance.now();
+    // скрытая вкладка не получит keyup
+    modules.controls?.releasePtt();
     soundManager.mute();
     // иначе включение звука при возвращении (кроме паузы переподключения и
     // смены хоста — его включит возобновление сессии)
@@ -1594,6 +1699,13 @@ function handleDisconnect(closeCode) {
   lastMapData = null;
 
   document.removeEventListener('visibilitychange', handleVisibilityChange);
+  // строго до soundManager.destroy(): Howler.unload() закрывает контекст, на
+  // котором сидят захват и воспроизведение связи
+  voiceSession += 1;
+  voiceClient?.destroy();
+  voiceClient = null;
+  voice.store.clear();
+  modules.voice?.destroy();
   soundManager.destroy();
   modules.controls?.disableKeys();
 
@@ -1687,6 +1799,7 @@ function startSession(transport, reconnect = null) {
     onTerminal: handleDisconnect,
     onStateChange: handleSessionState,
     onResumed: handleSessionResumed,
+    onVoice: bytes => voiceClient?.handleAudio(bytes),
     onResumeRejected: handleResumeRejected,
     onHostLost: reportHostUnreachable,
     onColdRestart: handleColdRestart,
@@ -1730,6 +1843,8 @@ function isSessionPaused() {
 function handleSessionState(state, prev) {
   if (state === SESSION_STATES.migrating) {
     showSessionOverlay('Switching host…');
+    voiceClient?.suspend();
+    voice.store.clear();
     modules.controls?.disableKeys();
     soundManager.mute();
   } else if (state === SESSION_STATES.reconnecting) {
@@ -1738,6 +1853,8 @@ function handleSessionState(state, prev) {
       showSessionOverlay('Reconnecting…');
     }
 
+    voiceClient?.suspend();
+    voice.store.clear();
     modules.controls?.disableKeys();
     soundManager.mute();
   } else if (state === SESSION_STATES.inGame) {

package/src/client/network/HostConnectionManager.js

@@ -1,10 +1,12 @@
 // WebRTC-answerer браузерного хоста (Фаза 2 Этапа 4). Зеркало WebRtcManager:
-// клиент — offerer (создаёт каналы meta/state и оффер), хост здесь — answerer.
+// клиент — offerer (создаёт каналы meta/state/voice и оффер), хост здесь — answerer.
 // Живёт в главном потоке (RTCPeerConnection в Worker'е недоступны); входящие
 // кадры каналов уходят в Worker через HostController, исходящие Worker-кадры
 // раскладываются по каналам meta (reliable) / state (unreliable) по флагу
 // reliable из ядра (body_has_events). Медленным пирам state-кадры дропаются
-// по bufferedAmount (бэкпрешер) — meta не дропается никогда.
+// по bufferedAmount (бэкпрешер) — meta не дропается никогда. Канал voice в
+// готовность не входит и в Worker не ходит: пакеты голоса идут ретранслятору
+// HostController.
 export default class HostConnectionManager {
   /**
    * @param {SignalingClient} signaling - сигнальный WS мастера.
@@ -26,7 +28,7 @@ export default class HostConnectionManager {
     this._threshold = opts.backpressureThreshold ?? 262144; // 256 КБ
     this._onPeersChange = opts.onPeersChange;
 
-    // clientId → { pc, meta, state, openCount, memberId }
+    // clientId → { pc, meta, state, voice, openCount, memberId }
     this._peers = new Map();
 
     signaling.publisher.on('webrtc_offer', 'onOffer', this);
@@ -59,6 +61,7 @@ export default class HostConnectionManager {
       pc,
       meta: null,
       state: null,
+      voice: null,
       openCount: 0,
       memberId,
       resume,
@@ -122,11 +125,21 @@ export default class HostConnectionManager {
   }
 
   _wireChannel(clientId, peer, channel) {
+    if (channel.label === 'voice') {
+      this._wireVoiceChannel(clientId, peer, channel);
+      return;
+    }
+
+    // чужая метка — не наш канал: ни обработчиков, ни счёта готовности
+    if (channel.label !== 'meta' && channel.label !== 'state') {
+      return;
+    }
+
     channel.binaryType = 'arraybuffer';
 
     if (channel.label === 'meta') {
       peer.meta = channel;
-    } else if (channel.label === 'state') {
+    } else {
       peer.state = channel;
     }
 
@@ -159,6 +172,34 @@ export default class HostConnectionManager {
     };
   }
 
+  _wireVoiceChannel(clientId, peer, channel) {
+    channel.binaryType = 'arraybuffer';
+    peer.voice = channel;
+
+    // голос — только ретранслятору главного потока; в Worker он не уходит
+    // никогда
+    channel.onmessage = event =>
+      this._controller.voiceIngress(clientId, event.data);
+
+    channel.onopen = () => {
+      if (this._peers.get(clientId) !== peer) {
+        return;
+      }
+
+      this._controller.attachVoice(clientId, {
+        send: bytes => {
+          if (channel.readyState === 'open') {
+            channel.send(bytes);
+          }
+        },
+        bufferedAmount: () => channel.bufferedAmount,
+      });
+    };
+
+    // потеря одного канала голоса — не повод рвать матч
+    channel.onclose = () => this._controller.detachVoice(clientId);
+  }
+
   // раскладывает исходящий Worker-кадр по каналам meta/state
   _deliver(peer, payload, reliable) {
     // JSON-протокол и событийные кадры — надёжно по meta; позиционные кадры
@@ -189,7 +230,7 @@ export default class HostConnectionManager {
     this._controller.disconnect(clientId); // Worker: removeUser
 
     // снять обработчики каналов — замыкания не должны удерживать peer
-    for (const channel of [peer.meta, peer.state]) {
+    for (const channel of [peer.meta, peer.state, peer.voice]) {
       if (channel) {
         channel.onopen = null;
         channel.onmessage = null;

package/src/client/network/HostController.js

@@ -1,3 +1,5 @@
+import VoiceRelay from '../../lib/VoiceRelay.js';
+
 // Мост главного потока между Worker'ом хоста (авторитетная симуляция) и
 // транспортами клиентов. Worker не имеет доступа к RTCPeerConnection — главный
 // поток роутит пакеты: исходящие кадры Worker'а (to_client) → нужному клиенту,
@@ -9,6 +11,9 @@
 // версию кода без разрыва P2P — старый Worker отдаёт handoff-состояние на
 // границе раунда, новый поднимается с ним, клиенты переподключаются
 // внутренними connect'ами (WebRTC-каналы живут здесь и не трогаются).
+//
+// Здесь же живёт ретранслятор голоса (VoiceRelay): пакеты голоса в Worker не
+// уходят, маршруты ему присылает мета-модуль Voice сообщением voice_route.
 
 // предохранитель от зависшего init нового Worker'а: не дождались ready —
 // своп отменяется, комната продолжает жить на старом Worker'е
@@ -102,6 +107,8 @@ export default class HostController {
 
     this._swap = null; // состояние эстафеты (Этап 5.2)
 
+    this._voiceRelay = new VoiceRelay();
+
     // ожидание границы раунда плановой передачей (host-migration этап 8d)
     this._roundBoundaryCallback = null;
 
@@ -202,8 +209,36 @@ export default class HostController {
     this._worker.postMessage(msg);
   }
 
+  /**
+   * Выход голоса к соединению (WebRTC-канал гостя или loopback хоста-игрока).
+   * @param {string} socketId
+   * @param {{ send: Function, bufferedAmount?: Function }} sink
+   */
+  attachVoice(socketId, sink) {
+    this._voiceRelay.attach(socketId, sink);
+  }
+
+  /**
+   * Отцепляет выход голоса (канал voice закрылся при живом соединении).
+   * @param {string} socketId
+   */
+  detachVoice(socketId) {
+    this._voiceRelay.detach(socketId);
+  }
+
+  /**
+   * Пакет голоса от соединения: Worker его не видит.
+   * @param {string} socketId
+   * @param {ArrayBuffer|Uint8Array} data
+   */
+  voiceIngress(socketId, data) {
+    this._voiceRelay.ingress(socketId, data);
+  }
+
   // отключает клиента
   disconnect(socketId) {
+    // ретранслятор живёт в главном потоке: ждать паузу эстафеты ему нечего
+    this._voiceRelay.detach(socketId);
     this._deliveries.delete(socketId);
 
     const msg = { type: 'disconnect', socketId };
@@ -580,6 +615,7 @@ export default class HostController {
     this._shutdownResolve?.();
 
     this._rejectDebugRequests('host destroyed');
+    this._voiceRelay.clear();
 
     if (this._swap) {
       const { reject } = this._swap;
@@ -705,6 +741,9 @@ export default class HostController {
       this._postCheckpointState(next);
     }
 
+    // маршруты старого Worker'а мертвы (новый начинает без эфиров); выходы
+    // остаются — каналы WebRTC эстафету переживают
+    this._voiceRelay.clear();
     this._worker.terminate();
     this._worker = next;
     this._worker.onmessage = e => this._onWorkerMessage(e.data);
@@ -761,6 +800,10 @@ export default class HostController {
         this._reportWorkerMessage(msg, msg.kind);
         break;
 
+      case 'voice_route':
+        this._voiceRelay.applyRoute(msg);
+        break;
+
       case 'map_changed':
         this._onMapChange?.(msg.mapName);
         break;

package/src/client/network/LoopbackTransport.js

@@ -32,6 +32,13 @@ export default class LoopbackTransport {
       resume: this._resume,
     });
 
+    // голос хоста-игрока не идёт через Worker: ретранслятор живёт здесь же, в
+    // главном потоке, и отдаёт пакеты прямым вызовом. ?. — у InlineHostBridge
+    // (standalone) голоса нет (D4)
+    this._controller.attachVoice?.(this._socketId, {
+      send: bytes => this.publisher.emit('voice', bytes),
+    });
+
     // подписчики появляются после connect() (супервизор берёт уже
     // подключённый транспорт) — 'open' уходит следующей микрозадачей
     if (this._resume) {
@@ -50,6 +57,13 @@ export default class LoopbackTransport {
     }
   }
 
+  // голосовой пакет хоста-игрока — ретранслятору, минуя Worker
+  sendVoice(bytes) {
+    if (!this._closed) {
+      this._controller.voiceIngress?.(this._socketId, bytes);
+    }
+  }
+
   close() {
     this._emitClose();
   }

package/src/client/network/SessionSupervisor.js

@@ -54,6 +54,8 @@ export default class SessionSupervisor {
    *   транспорта (строка или ArrayBuffer).
    * @param {Function} opts.onTerminal - (closeCode) сессия закрыта
    *   окончательно: путь прежнего handleDisconnect.
+   * @param {Function} [opts.onVoice] - (data) голосовой пакет текущего
+   *   транспорта в состоянии inGame (бинарный, без разбора).
    * @param {Function} [opts.onStateChange] - (state, prev).
    * @param {Function} [opts.onResumed] - место возвращено (RESUME_RESULT ok).
    * @param {Function} [opts.onResumeRejected] - (reason) хост отказал.
@@ -76,6 +78,7 @@ export default class SessionSupervisor {
   constructor({
     onMessage,
     onTerminal,
+    onVoice = null,
     onStateChange = () => {},
     onResumed = () => {},
     onResumeRejected = () => {},
@@ -88,6 +91,7 @@ export default class SessionSupervisor {
   }) {
     this._onMessage = onMessage;
     this._onTerminal = onTerminal;
+    this._onVoice = onVoice;
     this._onStateChange = onStateChange;
     this._onResumed = onResumed;
     this._onResumeRejected = onResumeRejected;
@@ -166,6 +170,17 @@ export default class SessionSupervisor {
     this._transport?.send(data, reliable);
   }
 
+  /**
+   * Голосовой пакет текущему транспорту (только в inGame; транспорт без
+   * голоса — выброс).
+   * @param {Uint8Array} bytes
+   */
+  sendVoice(bytes) {
+    if (this._state === S.inGame) {
+      this._transport?.sendVoice?.(bytes);
+    }
+  }
+
   /**
    * Пользователь уходит сам (или сессию закрывает политика): закрытие
    * транспорта терминально, переподключения не будет.
@@ -477,6 +492,7 @@ export default class SessionSupervisor {
 
     const handlers = {
       message: data => this._handleMessage(transport, data),
+      voice: data => this._handleVoice(transport, data),
       close: closeCode => this._handleClose(transport, closeCode),
       open: () => this._handleOpen(transport),
     };
@@ -523,6 +539,14 @@ export default class SessionSupervisor {
     this._onMessage(data);
   }
 
+  // голос не обновляет метку живости: поток голоса не доказывает живость
+  // протокола хоста
+  _handleVoice(transport, data) {
+    if (transport === this._transport && this._state === S.inGame) {
+      this._onVoice?.(data);
+    }
+  }
+
   _handleOpen(transport) {
     if (transport !== this._transport) {
       return;

package/src/client/network/WebRtcManager.js

@@ -1,12 +1,15 @@
+import { VOICE_BACKPRESSURE_BYTES } from '../../config/voiceProtocol.js';
 import Publisher from '../../lib/Publisher.js';
 
 // Транспорт P2P-соединения клиента с браузерным хостом. Заменяет игровой
-// WebSocket: два RTCDataChannel вместо одного сокета.
+// WebSocket: три RTCDataChannel вместо одного сокета.
 //
 // - meta  (reliable-ordered)      — весь JSON-протокол [portId, payload] и
 //                                    бинарные кадры с одноразовыми событиями;
 // - state (unreliable-unordered)  — чисто позиционные бинарные кадры, их
-//                                    потерю компенсирует следующий кадр.
+//                                    потерю компенсирует следующий кадр;
+// - voice (unreliable-unordered)  — только голосовые пакеты,
+//                                    в готовность соединения не входит.
 //
 // Классификация кадров meta/state — на стороне хоста при упаковке. Клиент лишь
 // принимает данные из обоих каналов и отдаёт их одним потоком (событие
@@ -103,6 +106,7 @@ export default class WebRtcManager {
     this._pc = null;
     this._meta = null;
     this._state = null;
+    this._voice = null;
     this._roomId = null;
     // id вкладки — хост хранит его рядом с clientId пира
     this._memberId = memberId ?? null;
@@ -164,8 +168,18 @@ export default class WebRtcManager {
     });
     this._state.binaryType = 'arraybuffer';
 
+    // voice — голос: ненадёжный неупорядоченный, как state,
+    // но в готовность соединения не входит — связь не обязательна для матча, а
+    // потеря пакета голоса лечится следующим
+    this._voice = pc.createDataChannel('voice', {
+      ordered: false,
+      maxRetransmits: 0,
+    });
+    this._voice.binaryType = 'arraybuffer';
+
     this._wireChannel(this._meta);
     this._wireChannel(this._state);
+    this._wireVoiceChannel(this._voice);
 
     // канал standby открывает хост — только преемнику (этап 6)
     pc.ondatachannel = event => {
@@ -319,6 +333,28 @@ export default class WebRtcManager {
     }
   }
 
+  // голосовой пакет хосту; закрытый или переполненный канал — выброс (живой
+  // голос важнее старого)
+  sendVoice(bytes) {
+    const channel = this._voice;
+
+    if (
+      !channel ||
+      channel.readyState !== 'open' ||
+      channel.bufferedAmount > VOICE_BACKPRESSURE_BYTES
+    ) {
+      return;
+    }
+
+    // канал мог закрыться между проверкой и отправкой — исключение не должно
+    // уйти в колбэк энкодера
+    try {
+      channel.send(bytes);
+    } catch {
+      // пакет потерян, как и при закрытом канале
+    }
+  }
+
   close() {
     this._emitClose();
   }
@@ -420,7 +456,7 @@ export default class WebRtcManager {
 
   // поздние события каналов закрытого менеджера не должны ничего эмитить
   _dropChannelHandlers() {
-    for (const channel of [this._meta, this._state]) {
+    for (const channel of [this._meta, this._state, this._voice]) {
       if (channel) {
         channel.onopen = null;
         channel.onmessage = null;
@@ -451,6 +487,12 @@ export default class WebRtcManager {
     channel.onclose = () => this._emitClose();
   }
 
+  // onopen/onclose не ставим: голос не трогает _openChannels и не закрывает
+  // менеджер
+  _wireVoiceChannel(channel) {
+    channel.onmessage = event => this.publisher.emit('voice', event.data);
+  }
+
   // кода закрытия у data channel нет: 'close' эмитится без аргумента, как
   // и раньше (код приходит только от WebSocket-транспорта dedicated)
   _emitClose() {