vimp-engine 0.1.0

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

@@ -0,0 +1,179 @@
+// Singleton Vote
+let vote;
+
+class Vote {
+  constructor() {
+    if (vote) {
+      return vote;
+    }
+
+    vote = this;
+
+    this._list = []; // данные для всех игроков
+    this._userList = {}; // данные для игрока
+
+    this._activeVoteName = null; // имя активного голосования
+    this._activeVoteCategory = null; // категория активного голосования
+    this._activeVoteData = null; // данные активного голосования
+    this._voteQueue = []; // очередь для голосований
+  }
+
+  // сбрасывает данные
+  reset() {
+    this._list = [];
+
+    for (const gameId in this._userList) {
+      if (Object.hasOwn(this._userList, gameId)) {
+        this._userList[gameId] = [];
+      }
+    }
+
+    this._activeVoteName = null;
+    this._activeVoteCategory = null;
+    this._activeVoteData = null;
+    this._voteQueue = [];
+  }
+
+  // добавляет пользователя
+  addUser(gameId) {
+    this._userList[gameId] = [];
+  }
+
+  // удаляет пользователя
+  removeUser(gameId) {
+    delete this._userList[gameId];
+  }
+
+  // добавляет данные голосования
+  _push(arr) {
+    this._list.push(arr);
+  }
+
+  // добавляет данные голосования для пользователя
+  pushByUser(gameId, arr) {
+    this._userList[gameId].push(arr);
+  }
+
+  // возвращает данные
+  shift() {
+    return this._list.shift();
+  }
+
+  // возвращает данные для пользователя
+  shiftByUser(gameId) {
+    return this._userList[gameId].shift();
+  }
+
+  // запуск голосования и рассылки данных
+  _startVote({ name, category, payload, userList, onStartCallback }) {
+    this._activeVoteName = name;
+    this._activeVoteCategory = category;
+    this._activeVoteData = {};
+
+    if (userList) {
+      for (let i = 0, len = userList.length; i < len; i += 1) {
+        this.pushByUser(userList[i], payload);
+      }
+    } else {
+      this._push(payload);
+    }
+
+    if (onStartCallback) {
+      onStartCallback();
+    }
+  }
+
+  // проверяет использование категории голосования
+  hasVoteCategory(categoryName) {
+    if (this._activeVoteCategory === categoryName) {
+      return true;
+    }
+
+    return (
+      this._voteQueue.find(voteData => voteData.category === categoryName) !==
+      undefined
+    );
+  }
+
+  // создает голосование или ставит его в очередь
+  createVote(data) {
+    // если есть активное голосование, добавляем новое в очередь
+    if (this._activeVoteName) {
+      this._voteQueue.push(data);
+      return;
+    }
+
+    // если активного голосования нет, запускаем это
+    this._startVote(data);
+  }
+
+  // добавляет голос в голосование
+  addInVote(name, value) {
+    // если голосование не активное
+    if (this._activeVoteName !== name) {
+      return;
+    }
+
+    if (this._activeVoteData[value]) {
+      this._activeVoteData[value] += 1;
+    } else {
+      this._activeVoteData[value] = 1;
+    }
+  }
+
+  // возвращает результат голосования, обрабатывает ничью и запускает следующее
+  getResult(name) {
+    // если голосование не активное
+    if (this._activeVoteName !== name) {
+      return;
+    }
+
+    const results = this._activeVoteData;
+    let maxVotes = 0;
+    let winners = []; // массив для хранения победителей
+
+    // удаление завершенного голосования перед подсчетом
+    this._activeVoteName = null;
+    this._activeVoteCategory = null;
+    this._activeVoteData = null;
+
+    // если есть следующее голосование из очереди
+    if (this._voteQueue.length > 0) {
+      const nextVote = this._voteQueue.shift();
+      this._startVote(nextVote);
+    }
+
+    // если никто не проголосовал
+    if (!results || Object.keys(results).length === 0) {
+      return;
+    }
+
+    // поиск победителей
+    for (const option in results) {
+      if (Object.hasOwn(results, option)) {
+        const currentVotes = results[option];
+
+        // если текущий вариант набрал больше голосов,
+        // он становится единственным лидером
+        if (currentVotes > maxVotes) {
+          maxVotes = currentVotes;
+          winners = [option];
+          // если голосов столько же, добавляем в список победителей (ничья)
+        } else if (currentVotes === maxVotes) {
+          winners.push(option);
+        }
+      }
+    }
+
+    // если победитель один
+    if (winners.length === 1) {
+      return winners[0];
+    }
+
+    // случайный выбор, если победителей несколько
+    const randomIndex = Math.floor(Math.random() * winners.length);
+    return winners[randomIndex];
+  }
+}
+
+export default Vote;

package/src/host/meta/modules/chat/Chat.js

@@ -0,0 +1,66 @@
+import { buildSystemMessage } from './systemMessages.js';
+
+// Singleton Chat
+
+let chat;
+
+class Chat {
+  constructor() {
+    if (chat) {
+      return chat;
+    }
+
+    chat = this;
+
+    this._list = [];
+    this._userList = {};
+  }
+
+  // добавляет пользователя
+  addUser(gameId) {
+    this._userList[gameId] = [];
+  }
+
+  // удаляет пользователя
+  removeUser(gameId) {
+    delete this._userList[gameId];
+  }
+
+  // добавляет сообщение
+  push(message, name, teamId) {
+    this._list.push([message, name, teamId]);
+  }
+
+  // добавляет системное сообщение для всех
+  // message может быть:
+  // - шаблонным сообщением '<группа шаблонов>:<номер шаблона>:<параметры>'
+  // - сообщением в виде массива [<текст сообщения>]
+  pushSystem(message, params) {
+    if (typeof message === 'string') {
+      this._list.push(buildSystemMessage(message, params));
+    } else {
+      this._list.push(message);
+    }
+  }
+
+  // добавляет системное сообщение для пользователя
+  pushSystemByUser(gameId, message, params) {
+    if (typeof message === 'string') {
+      this._userList[gameId].push(buildSystemMessage(message, params));
+    } else {
+      this._userList[gameId].push(message);
+    }
+  }
+
+  // возвращает сообщение
+  shift() {
+    return this._list.shift();
+  }
+
+  // возвращает сообщение для пользователя
+  shiftByUser(gameId) {
+    return this._userList[gameId].shift();
+  }
+}
+
+export default Chat;

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

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

package/src/host/meta/modules/chat/systemMessages.js

@@ -0,0 +1,51 @@
+// Реестр кодов системных сообщений чата. Движковые группы: s (статусы),
+// v (голосования), m (карты), c (команды), n (имена). Игровые коды
+// (у танков — группа b:*) добавляются через registerCodes и не должны
+// пересекаться с движковыми группами. Тексты шаблонов — на клиенте.
+const MESSAGE_CODES = {
+  TEAMS_TEAM_FULL: 's:0', // Team {0} is full. Your current team: {1}
+  TEAMS_YOUR_TEAM: 's:1', // Your team: {0}
+  TEAMS_NEW_TEAM: 's:2', // Your new team: {0}
+  TEAMS_NOW_SPECTATOR: 's:3', // Your new status: spectator
+  REPORT_KILL: 's:4', // ⚔️  {0} killed {1}!
+  USER_JOINED: 's:5', // ⚡ {0} joined the game
+  USER_LEFT: 's:6', // 👋  {0} left the game
+
+  VOTE_CREATED: 'v:0', // A vote has been created
+  VOTE_STARTED: 'v:1', // Voting has started
+  VOTE_ACCEPTED: 'v:2', // Your vote has been accepted
+  VOTE_UNAVAILABLE: 'v:3', // Voting is temporarily unavailable
+  VOTE_PASSED: 'v:4', // Vote passed
+  VOTE_FAILED: 'v:5', // Vote failed
+
+  MAP_CURRENT: 'm:0', // Current map: {0}
+  MAP_NEXT: 'm:1', // Next map: {0}
+
+  COMMANDS_NOT_FOUND: 'c:0', // Command not found
+  RANK: 'c:1', // Your rank: {0}
+
+  NAME_INVALID: 'n:0', // Invalid name
+  NAME_CHANGED: 'n:1', // {0} changed name to {1}
+};
+
+/**
+ * Регистрирует игровые коды системных сообщений (merge в реестр движка).
+ * Идемпотентна: повторная регистрация тех же кодов безопасна.
+ * @param {Object} codes - { KEY: '<группа>:<номер>' }
+ */
+export function registerCodes(codes) {
+  Object.assign(MESSAGE_CODES, codes);
+}
+
+/**
+ * Собирает финальную строку системного сообщения из ключа и параметров.
+ * @param {string} messageKey - Ключ из объекта MESSAGE_CODES
+ * @param {Array<string>} [params=[]] - Массив с параметрами для сообщения.
+ * @returns {string|null} Готовая строка для отправки клиенту
+ * (например, 'n:1:Player1,Player2')
+ */
+export function buildSystemMessage(key, params = []) {
+  return params.length
+    ? `${MESSAGE_CODES[key]}:${params.join(',')}`
+    : MESSAGE_CODES[key];
+}

package/src/host/meta/player/HumanParticipant.js

@@ -0,0 +1,36 @@
+import Participant from './Participant.js';
+
+// Участник-человек: поля и поведение, специфичные для реального игрока
+class HumanParticipant extends Participant {
+  constructor({
+    gameId,
+    name,
+    model,
+    team,
+    teamId,
+    socketId,
+    watchedGameId,
+    token = null,
+  }) {
+    super({ gameId, name, model, team, teamId });
+
+    this.socketId = socketId;
+    // identity-токен участника (Этап B4): переиспользуется для
+    // авторизованной синхронизации rank/state с мастером
+    this.token = token;
+    this.isReady = false;
+    this.currentMap = null;
+    this.isWatching = true;
+    this.watchedGameId = watchedGameId ?? null;
+    this.forceCameraReset = true;
+    this.pendingShake = null;
+    this.lastActionTime = Date.now();
+    this.lastInputSeq = 0; // номер последнего обработанного ввода (предикшен)
+  }
+
+  get isNetworked() {
+    return true;
+  }
+}
+
+export default HumanParticipant;

package/src/host/meta/player/Participant.js

@@ -0,0 +1,22 @@
+// Базовый класс участника — источник истины полей, общих для людей и ботов
+class Participant {
+  constructor({ gameId, name, model, team, teamId }) {
+    this.gameId = gameId;
+    this.name = name;
+    this.model = model;
+    this.team = team;
+    this.teamId = teamId;
+    this.status = 'spectator'; // 'spectator' | 'active' | 'dead'
+  }
+
+  // участник, управляемый кодом (ИИ), а не сетевым игроком
+  get isScripted() {
+    return false;
+  }
+
+  get isNetworked() {
+    return false;
+  }
+}
+
+export default Participant;

package/src/host/meta/player/ParticipantManager.js

@@ -0,0 +1,247 @@
+import HumanParticipant from './HumanParticipant.js';
+import ScriptedParticipant from './ScriptedParticipant.js';
+
+// Единый источник истины об участниках игры (люди + scripted-участники).
+// Владеет реестром, размерами команд, списком активных игроков,
+// генерацией id (единое числовое пространство) и проверкой имён.
+class ParticipantManager {
+  // scripted — параметры scripted-участников из конфига игры:
+  // { namePrefix, defaultModel }
+  constructor(teams, spectatorTeam, maxPlayers, scripted = {}) {
+    this._teams = teams; // { team1: 1, team2: 2, spectators: 3 }
+    this._spectatorTeam = spectatorTeam;
+    this._spectatorId = teams[spectatorTeam];
+    this._maxPlayers = maxPlayers;
+    this._scripted = scripted;
+
+    this._participants = new Map(); // gameId -> Participant
+    this._teamSizes = {}; // team -> Set<gameId>
+    this._activePlayersList = []; // gameId[]
+
+    this.resetTeamSizes();
+  }
+
+  // наименьший свободный числовой id (единое пространство людей и scripted)
+  _nextGameId() {
+    let counter = 0;
+
+    while (this._participants.has(counter.toString(10))) {
+      counter += 1;
+    }
+
+    return counter.toString(10);
+  }
+
+  // создаёт участника-человека (спектатор), возвращает gameId
+  createHuman(params, socketId) {
+    const gameId = this._nextGameId();
+    const name = this.checkName(params.name);
+
+    const participant = new HumanParticipant({
+      gameId,
+      name,
+      model: params.model,
+      team: this._spectatorTeam,
+      teamId: this._spectatorId,
+      socketId,
+      watchedGameId: this._activePlayersList[0] || null,
+      token: params.token,
+    });
+
+    this._participants.set(gameId, participant);
+    this._teamSizes[this._spectatorTeam].add(gameId);
+
+    return gameId;
+  }
+
+  // создаёт scripted-участника в команде, возвращает gameId
+  createScripted({ team, model }) {
+    const gameId = this._nextGameId();
+    const name = this.checkName(`${this._scripted.namePrefix}${gameId}`);
+    const teamId = this._teams[team];
+
+    const participant = new ScriptedParticipant({
+      gameId,
+      name,
+      model: model ?? this._scripted.defaultModel,
+      team,
+      teamId,
+    });
+
+    this._participants.set(gameId, participant);
+    this._teamSizes[team].add(gameId);
+
+    return gameId;
+  }
+
+  // восстанавливает человека с исходным gameId (эстафета Worker'ов, Этап 5.2);
+  // занятый id или неизвестная команда — null (запись пропускается)
+  restoreHuman({ gameId, socketId, name, model, team, teamId }) {
+    if (this._participants.has(gameId) || !this._teamSizes[team]) {
+      return null;
+    }
+
+    const participant = new HumanParticipant({
+      gameId,
+      name,
+      model,
+      team,
+      teamId,
+      socketId,
+      watchedGameId: this._activePlayersList[0] || null,
+    });
+
+    this._participants.set(gameId, participant);
+    this._teamSizes[team].add(gameId);
+
+    return participant;
+  }
+
+  // восстанавливает scripted-участника с исходным gameId
+  // (эстафета Worker'ов, Этап 5.2)
+  restoreScripted({ gameId, name, model, team, teamId }) {
+    if (this._participants.has(gameId) || !this._teamSizes[team]) {
+      return null;
+    }
+
+    const participant = new ScriptedParticipant({
+      gameId,
+      name,
+      model,
+      team,
+      teamId,
+    });
+
+    this._participants.set(gameId, participant);
+    this._teamSizes[team].add(gameId);
+
+    return participant;
+  }
+
+  // полностью удаляет участника из реестра (команда + список активных)
+  remove(gameId) {
+    const participant = this._participants.get(gameId);
+
+    if (!participant) {
+      return;
+    }
+
+    this.removeActive(gameId);
+    this._teamSizes[participant.team]?.delete(gameId);
+    this._participants.delete(gameId);
+  }
+
+  get(gameId) {
+    return this._participants.get(gameId);
+  }
+
+  getAll() {
+    return [...this._participants.values()];
+  }
+
+  getHumans() {
+    return this.getAll().filter(p => p.isNetworked);
+  }
+
+  getScripted() {
+    return this.getAll().filter(p => p.isScripted);
+  }
+
+  // люди, готовые к игре (получатели сетевого кадра)
+  getNetworkedReady() {
+    return this.getHumans().filter(p => p.isReady);
+  }
+
+  // проверяет уникальность имени по всему реестру (люди + scripted)
+  checkName(name, number = 1) {
+    for (const participant of this._participants.values()) {
+      if (participant.name === name) {
+        if (number > 1) {
+          name = name.slice(0, name.lastIndexOf('#')) + '#' + number;
+        } else {
+          name = name + '#' + number;
+        }
+
+        return this.checkName(name, number + 1);
+      }
+    }
+
+    return name;
+  }
+
+  // команды
+  getPlayableTeams() {
+    return Object.keys(this._teams).filter(t => t !== this._spectatorTeam);
+  }
+
+  getTeamSize(team) {
+    return this._teamSizes[team].size;
+  }
+
+  addToTeam(gameId, team) {
+    this._teamSizes[team].add(gameId);
+  }
+
+  removeFromTeam(gameId, team) {
+    this._teamSizes[team].delete(gameId);
+  }
+
+  resetTeamSizes() {
+    this._teamSizes = Object.keys(this._teams).reduce((acc, key) => {
+      acc[key] = new Set();
+      return acc;
+    }, {});
+  }
+
+  // активные игроки (на полотне, для наблюдения)
+  addActive(gameId) {
+    if (!this._activePlayersList.includes(gameId)) {
+      this._activePlayersList.push(gameId);
+    }
+  }
+
+  removeActive(gameId) {
+    this._activePlayersList = this._activePlayersList.filter(
+      id => id !== gameId,
+    );
+
+    // перецепление наблюдателей на другого активного игрока
+    for (const participant of this._participants.values()) {
+      if (participant.watchedGameId === gameId) {
+        participant.watchedGameId = this._activePlayersList[0] || null;
+      }
+    }
+  }
+
+  clearActive() {
+    this._activePlayersList = [];
+  }
+
+  getActiveList() {
+    return this._activePlayersList;
+  }
+
+  // заменяет наблюдаемого игрока (victimId) на killerId
+  replaceWatched(victimId, killerId) {
+    if (!this._activePlayersList.includes(killerId)) {
+      return;
+    }
+
+    for (const participant of this._participants.values()) {
+      if (participant.watchedGameId === victimId) {
+        participant.watchedGameId = killerId;
+      }
+    }
+  }
+
+  // суммарно люди + scripted (для лимита maxPlayers)
+  get totalCount() {
+    return this._participants.size;
+  }
+
+  get isFull() {
+    return this._maxPlayers ? this.totalCount >= this._maxPlayers : false;
+  }
+}
+
+export default ParticipantManager;

package/src/host/meta/player/ScriptedParticipant.js

@@ -0,0 +1,19 @@
+import Participant from './Participant.js';
+
+// Scripted-участник: управляется игровым модулем, всегда active-или-удалён,
+// наблюдателем не бывает
+class ScriptedParticipant extends Participant {
+  constructor({ gameId, name, model, team, teamId }) {
+    super({ gameId, name, model, team, teamId });
+
+    // в статистику добавляется как 'dead' до старта раунда
+    this.status = 'dead';
+    this.controller = null;
+  }
+
+  get isScripted() {
+    return true;
+  }
+}
+
+export default ScriptedParticipant;