mm_os 4.3.6 → 5.0.0

package/core/channel/matcher.js

@@ -1,585 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-const {
-  idGen
-} = require('../../ulits/id_gen.js');
-
-/**
- * 匹配器
- * 管理匹配池并实现基于等级和等待时间的匹配算法
- */
-class Matcher extends Drive {
-  static config = {
-    name: 'matcher',
-    title: '匹配器',
-    wait_time: 120000,
-    lv_range_init: 5,
-    lv_range_max: 20,
-    lv_expand_int: 10000,
-    match_interval: 1000,
-    team_sizes: {
-      '1v1': 1,
-      '3v3': 3,
-      '5v5': 5
-    }
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   */
-  constructor(config) {
-    super({
-      ...Matcher.config,
-      ...config
-    });
-
-    this._channel = null;
-    this._match_timer = null;
-
-    this._pools = new Map();
-    this._player_pool = new Map();
-  }
-}
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Matcher.prototype.getTplDir = function() {
-  return __dirname;
-};
-
-/**
- * 初始化匹配器
- * @param {object} channel 游戏频道
- */
-Matcher.prototype._initCore = async function (channel) {
-  this._channel = channel;
-};
-
-/**
- * 启动匹配定时器
- */
-Matcher.prototype._start = function () {
-  this._match_timer = setInterval(() => {
-    this._doMatch();
-  }, this.config.match_interval);
-};
-
-/**
- * 停止匹配定时器
- */
-Matcher.prototype._stop = function () {
-  if (this._match_timer) {
-    clearInterval(this._match_timer);
-    this._match_timer = null;
-    this.log('debug', '匹配定时器已停止');
-  }
-};
-
-/**
- * 执行匹配
- */
-Matcher.prototype._doMatch = function () {
-  this.updateLevelRanges();
-  this.cleanTimeout();
-
-  var modes = ['rank', 'casual'];
-  var formats = ['1v1', '3v3', '5v5'];
-  var team_sizes = [1, 2, 3, 5];
-
-  for (var m = 0; m < modes.length; m++) {
-    for (var f = 0; f < formats.length; f++) {
-      for (var t = 0; t < team_sizes.length; t++) {
-        this._matchPool(modes[m], formats[f], team_sizes[t]);
-      }
-    }
-  }
-};
-
-/**
- * 匹配指定池
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {number} team_size 队伍人数
- */
-Matcher.prototype._matchPool = function (mode, format, team_size) {
-  var pool = this.getPool(mode, format, team_size);
-  if (pool.length < 2) {
-    return;
-  }
-
-  var required_count = this._getRequiredCount(format);
-  var matched_groups = this._findMatchGroups(pool, required_count);
-
-  for (var i = 0; i < matched_groups.length; i++) {
-    var group = matched_groups[i];
-    this._create(group, mode, format);
-  }
-};
-
-/**
- * 获取需要的玩家数量
- * @param {string} format 比赛格式
- * @returns {number} 玩家数量
- */
-Matcher.prototype._getRequiredCount = function (format) {
-  var counts = {
-    '1v1': 2,
-    '3v3': 6,
-    '5v5': 10
-  };
-  return counts[format] || 10;
-};
-
-/**
- * 查找匹配组
- * @param {Array} pool 匹配池
- * @param {number} required_count 需要的玩家数量
- * @returns {Array} 匹配组列表
- */
-Matcher.prototype._findMatchGroups = function (pool, required_count) {
-  var groups = [];
-  var used = new Set();
-  var sorted_pool = this._sortByWaitTime(pool);
-
-  for (var i = 0; i < sorted_pool.length; i++) {
-    var entry = sorted_pool[i];
-    if (used.has(entry.player_id)) {
-      continue;
-    }
-
-    var group = this._buildGroup(entry, sorted_pool, used, required_count);
-    if (group && group.length === required_count) {
-      groups.push(group);
-    }
-  }
-
-  return groups;
-};
-
-/**
- * 按等待时间排序（等待久的优先）
- * @param {Array} pool 匹配池
- * @returns {Array} 排序后的匹配池
- */
-Matcher.prototype._sortByWaitTime = function (pool) {
-  return pool.slice().sort((a, b) => {
-    return a.join_time - b.join_time;
-  });
-};
-
-/**
- * 构建匹配组
- * @param {object} first_entry 第一个玩家
- * @param {Array} pool 匹配池
- * @param {Set} used 已使用的玩家
- * @param {number} required_count 需要的玩家数量
- * @returns {Array|null} 匹配组
- */
-Matcher.prototype._buildGroup = function (first_entry, pool, used, required_count) {
-  var group = [first_entry];
-  used.add(first_entry.player_id);
-
-  var member_count = first_entry.team_members.length;
-
-  for (var i = 0; i < pool.length && member_count < required_count; i++) {
-    var entry = pool[i];
-    if (used.has(entry.player_id)) {
-      continue;
-    }
-
-    if (this._can(first_entry, entry)) {
-      if (member_count + entry.team_members.length <= required_count) {
-        group.push(entry);
-        used.add(entry.player_id);
-        member_count += entry.team_members.length;
-      }
-    }
-  }
-
-  if (member_count === required_count) {
-    return group;
-  }
-
-  for (var j = 0; j < group.length; j++) {
-    used.delete(group[j].player_id);
-  }
-  return null;
-};
-
-/**
- * 判断两个玩家是否可以匹配
- * @param {object} entry_a 玩家A
- * @param {object} entry_b 玩家B
- * @returns {boolean} 是否可以匹配
- */
-Matcher.prototype._can = function (entry_a, entry_b) {
-  var level_diff = Math.abs(entry_a.level - entry_b.level);
-  var min_range = Math.min(entry_a.lv_range, entry_b.lv_range);
-
-  return level_diff <= min_range;
-};
-
-/**
- * 创建匹配
- * @param {Array} group 匹配组
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @returns {object} 匹配结果
- */
-Matcher.prototype._create = function (group, mode, format) {
-  var match_id = idGen.genId('match');
-  var all_players = [];
-
-  for (var i = 0; i < group.length; i++) {
-    var entry = group[i];
-    all_players = all_players.concat(entry.team_members);
-    this.leave(entry.player_id);
-  }
-
-  var teams = this._splitTeams(all_players, format);
-
-  var match_ret = {
-    match_id: match_id,
-    mode: mode,
-    format: format,
-    teams: teams,
-    players: all_players,
-    timestamp: Date.now()
-  };
-
-  this.emitEvent('match_success', match_ret);
-
-  this.log('info', `匹配成功: ${match_id}, 模式: ${mode}, 格式: ${format}, 玩家数: ${all_players.length}`);
-
-  return match_ret;
-};
-
-/**
- * 分割队伍
- * @param {Array} players 玩家列表
- * @param {string} format 比赛格式
- * @returns {object} 队伍配置
- */
-Matcher.prototype._splitTeams = function (players, format) {
-  var counts = {
-    '1v1': 1,
-    '3v3': 3,
-    '5v5': 5
-  };
-
-  var team_size = counts[format] || 5;
-
-  return {
-    team_a: players.slice(0, team_size),
-    team_b: players.slice(team_size),
-    format: format
-  };
-};
-
-/**
- * 玩家加入匹配池
- * @param {string} player_id 玩家ID
- * @param {object} options 匹配选项
- * @returns {boolean} 是否成功加入
- */
-Matcher.prototype.join = function (player_id, options = {}) {
-  if (typeof player_id !== 'string') {
-    throw new TypeError('玩家ID必须是字符串');
-  }
-
-  var mode = options.mode || 'rank';
-  var format = options.format || '5v5';
-  var team_size = options.team_size || 1;
-  var team_members = options.team_members || [player_id];
-
-  if (this._player_pool.has(player_id)) {
-    throw new Error(`玩家 ${player_id} 已在匹配池中`);
-  }
-
-  var player = this._channel.getPlayer(player_id);
-  if (!player) {
-    throw new Error(`玩家 ${player_id} 不存在`);
-  }
-
-  var pool_key = this._getPoolKey(mode, format, team_size);
-  var pool = this._getOrCreatePool(pool_key);
-
-  var entry = this._createEntry(player_id, player, team_members, team_size, mode, format);
-
-  pool.push(entry);
-  this._player_pool.set(player_id, pool_key);
-
-  this._emitJoinEvent(player_id, mode, format, team_size, entry.join_time);
-
-  this.log('debug', `玩家 ${player_id} 加入匹配池 ${pool_key}`);
-  return true;
-};
-
-/**
- * 玩家离开匹配池
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否成功离开
- */
-Matcher.prototype.leave = function (player_id) {
-  if (typeof player_id !== 'string') {
-    throw new TypeError('玩家ID必须是字符串');
-  }
-
-  var pool_key = this._player_pool.get(player_id);
-  if (!pool_key) {
-    return false;
-  }
-
-  var pool = this._pools.get(pool_key);
-  if (!pool) {
-    this._player_pool.delete(player_id);
-    return false;
-  }
-
-  for (var i = pool.length - 1; i >= 0; i--) {
-    if (pool[i].player_id === player_id) {
-      pool.splice(i, 1);
-      break;
-    }
-  }
-
-  this._player_pool.delete(player_id);
-
-  this.emitEvent('player_leave_pool', {
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-
-  this.log('debug', `玩家 ${player_id} 离开匹配池`);
-  return true;
-};
-
-/**
- * 检查玩家是否在匹配池中
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否在匹配池中
- */
-Matcher.prototype.has = function (player_id) {
-  return this._player_pool.has(player_id);
-};
-
-/**
- * 获取匹配池键
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {number} team_size 队伍人数
- * @returns {string} 匹配池键
- */
-Matcher.prototype._getPoolKey = function (mode, format, team_size) {
-  return `${mode}_${format}_${team_size}`;
-};
-
-/**
- * 获取或创建匹配池
- * @param {string} pool_key 池键名
- * @returns {Array} 匹配池
- */
-Matcher.prototype._getOrCreatePool = function (pool_key) {
-  if (!this._pools.has(pool_key)) {
-    this._pools.set(pool_key, []);
-  }
-  return this._pools.get(pool_key);
-};
-
-/**
- * 创建匹配条目
- * @param {string} player_id 玩家ID
- * @param {object} player 玩家对象
- * @param {Array} members 队伍成员
- * @param {number} team_size 队伍人数
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @returns {object} 匹配条目
- */
-Matcher.prototype._createEntry = function (player_id, player, members, team_size, mode, format) {
-  return {
-    player_id: player_id,
-    team_members: members,
-    team_size: team_size,
-    level: player.level || 0,
-    join_time: Date.now(),
-    lv_range: this.config.lv_range_init,
-    mode: mode,
-    format: format
-  };
-};
-
-/**
- * 发送加入事件
- * @param {string} player_id 玩家ID
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {number} team_size 队伍人数
- * @param {number} timestamp 时间戳
- */
-Matcher.prototype._emitJoinEvent = function (player_id, mode, format, team_size, timestamp) {
-  this.emitEvent('player_join_pool', {
-    player_id: player_id,
-    mode: mode,
-    format: format,
-    team_size: team_size,
-    timestamp: timestamp
-  });
-};
-
-/**
- * 获取指定匹配池
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {number} team_size 队伍人数
- * @returns {Array} 匹配池
- */
-Matcher.prototype.getPool = function (mode, format, team_size) {
-  var pool_key = this._getPoolKey(mode, format, team_size);
-  return this._pools.get(pool_key) || [];
-};
-
-/**
- * 获取匹配池大小
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {number} team_size 队伍人数
- * @returns {number} 匹配池大小
- */
-Matcher.prototype.getPoolSize = function (mode, format, team_size) {
-  return this.getPool(mode, format, team_size).length;
-};
-
-/**
- * 获取总等待人数
- * @returns {number} 总等待人数
- */
-Matcher.prototype.getTotalWaiting = function () {
-  return this._player_pool.size;
-};
-
-/**
- * 更新玩家等级范围
- * 根据等待时间扩大匹配范围
- */
-Matcher.prototype.updateLevelRanges = function () {
-  var now = Date.now();
-  var expand_int = this.config.lv_expand_int;
-  var max_range = this.config.lv_range_max;
-  var self = this;
-
-  this._pools.forEach((pool) => {
-    for (var i = 0; i < pool.length; i++) {
-      var entry = pool[i];
-      var wait_time = now - entry.join_time;
-      var expand_count = Math.floor(wait_time / expand_int);
-      var new_range = self.config.lv_range_init + expand_count;
-
-      if (new_range > max_range) {
-        entry.lv_range = max_range;
-      } else {
-        entry.lv_range = new_range;
-      }
-    }
-  });
-};
-
-/**
- * 清理超时玩家
- */
-Matcher.prototype.cleanTimeout = function () {
-  var now = Date.now();
-  var max_wait = this.config.wait_time;
-
-  this._pools.forEach((pool, pool_key) => {
-    for (var i = pool.length - 1; i >= 0; i--) {
-      var entry = pool[i];
-      if (now - entry.join_time > max_wait) {
-        pool.splice(i, 1);
-        this._player_pool.delete(entry.player_id);
-
-        this.emitEvent('match_timeout', {
-          player_id: entry.player_id,
-          wait_time: max_wait,
-          timestamp: now
-        });
-
-        this.log('debug', `玩家 ${entry.player_id} 匹配超时`);
-      }
-    }
-  });
-};
-
-/**
- * 清空匹配池
- */
-Matcher.prototype.clear = function () {
-  this._pools.clear();
-  this._player_pool.clear();
-  this.log('info', '匹配池已清空');
-};
-
-/**
- * 获取匹配状态
- * @param {string} player_id 玩家ID
- * @returns {object|null} 匹配状态
- */
-Matcher.prototype.getMatchStatus = function (player_id) {
-  if (!this.has(player_id)) {
-    return null;
-  }
-
-  var entry = this._findPlayerEntry(player_id);
-  if (!entry) {
-    return null;
-  }
-
-  var now = Date.now();
-  var wait_time = now - entry.join_time;
-
-  return {
-    player_id: player_id,
-    mode: entry.mode,
-    format: entry.format,
-    team_size: entry.team_size,
-    level: entry.level,
-    lv_range: entry.lv_range,
-    wait_time: wait_time,
-    pool_size: this.getPoolSize(entry.mode, entry.format, entry.team_size)
-  };
-};
-
-/**
- * 查找玩家匹配条目
- * @param {string} player_id 玩家ID
- * @returns {object|null} 匹配条目
- */
-Matcher.prototype._findPlayerEntry = function (player_id) {
-  var found = null;
-
-  this._pools.forEach((pool) => {
-    for (var i = 0; i < pool.length; i++) {
-      if (pool[i].player_id === player_id) {
-        found = pool[i];
-        return;
-      }
-    }
-  });
-
-  return found;
-};
-
-/**
- * 停止匹配器
- */
-Matcher.prototype.stop = function () {
-  this._stop();
-  this.clear();
-  this.log('info', '匹配器已停止');
-};
-
-exports.Matcher = Matcher;

package/core/com/config.tpl.json

@@ -1,16 +0,0 @@
-{
-  // 名称
-  "name": "${name}",
-  // 标题
-  "title": "公共模块",
-  // 描述
-  "description": "定义公共模块",
-  // 主文件
-  "main": "index.js",
-  // 状态 0：禁用 1：启用
-  "state": 1,
-  // 排序，越小越靠前
-  "sort": 100,
-  // 依赖的npm module
-  "dependencies": []
-}

package/core/com/index.js

@@ -1,77 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-
-/**
- * 公共基类
- * 负责管理公共的生命周期、资源加载和依赖管理
- */
-class Com extends Drive {
-  static config = {
-    // 组件名称
-    name: 'default',
-    // 组件版本
-    version: '1.0.0',
-    // 组件标题
-    title: '公共',
-    // 组件描述
-    description: '公共基类',
-    // 作者
-    author: 'qww',
-    // 组件目录
-    dir: './com',
-    // 依赖的npm模块
-    dependencies: []
-  };
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父对象
-   */
-  constructor(config, parent) {
-    super({...Com.config, ...config || {}}, parent);
-  }
-}
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Com.prototype.getTplDir = function() {
-  return __dirname;
-};
-
-/**
- * 初始化核心
- * @param {object} server 服务器
- * @param {object} eventer 事件总线
- * @param {object} logger 日志管理器
- * @private
- */
-Com.prototype._initCore = async function(server, eventer, logger) {
-  // 初始化依赖项
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  if (server) {
-    this.getServer = function () {
-      return server;
-    };
-  }
-  // 初始化管理
-  await this._initManager();
-  // 加载资源
-  await this._loadSources();
-};
-
-Com.prototype._startCore = async function () {
-  // 初始化资源
-  await this._initSources();
-};
-
-exports.Com = Com;

package/core/com/script.tpl.js

@@ -1,5 +0,0 @@
-/**
- * 公共模块
- */
-module.exports = {
-};

package/core/component/component.js

@@ -1,42 +0,0 @@
-/**
- * 组件基类
- */
-class Component {
-  constructor() {
-    this._is_dirty = false;
-    // 使用 Proxy 代理对象，拦截属性设置操作
-    return new Proxy(this, {
-      set: function (target, prop, value) {
-        if (prop === '_is_dirty') {
-          target._is_dirty = value;
-          return true;
-        }
-        if (target[prop] !== value) {
-          target._is_dirty = true;
-        }
-        target[prop] = value;
-        return true;
-      },
-      get: function (target, prop) {
-        return target[prop];
-      }
-    });
-  }
-
-  isDirty(is_dirty) {
-    if (is_dirty !== undefined) {
-      this._is_dirty = is_dirty;
-    }
-    return this._is_dirty;
-  }
-}
-
-/**
- * 转换为JSON字符串
- * @returns {string} JSON字符串
- */
-Component.prototype.toJson = function () {
-  return JSON.stringify(this);
-};
-
-module.exports = Component;