mm_os 4.3.6 → 5.0.0

package/core/channel/index.js

@@ -1,899 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-const {
-  RoomAdmin
-} = require('../room/index.js');
-const {
-  Matcher
-} = require('./matcher.js');
-
-/**
- * 游戏频道 - 平行世界管理器
- * 负责管理频道的创建、销毁、玩家隔离和频道间通信
- */
-class Channel extends Drive {
-  static config = {
-    'name': 'default',
-    'title': '默认频道',
-    'min_level': 0,
-    'max_level': 1000,
-    'max_players': 5000,
-    'type': 'normal',
-    'load_threshold': 0.8,
-    'main': '',
-    'match': {
-      'wait_time': 120000,
-      'lv_range_init': 5,
-      'lv_range_max': 20,
-      'lv_expand_int': 10000,
-      'interval': 1000
-    }
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   */
-  constructor(config) {
-    super({ ...Channel.config, ...config });
-    
-    // 游戏世界集合
-    this.worlds = new Map();
-  }
-}
-
-/**
- * 预置
- */
-Channel.prototype._preset = function () {
-  this.channel_id = 0;
-  this.status = 1;
-  this.stats = {
-    player: 0,
-    room: 0,
-    world: 0,
-    message: 0,
-    last_update: Date.now()
-  };
-
-  this._monitorTimer = null;
-
-  this.roomAdmin = null;
-  this.matcher = null;
-
-  // 主世界ID
-  this._main_world_id = '';
-};
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Channel.prototype.getTplDir = function () {
-  return __dirname;
-};
-
-/**
- * 初始化核心
- * @param {object} zone 分区对象
- * @param {object} eventer 事件管理器
- * @param {object} logger 日志管理器
- */
-Channel.prototype._initCore = async function (zone, eventer, logger) {
-  if (!zone) {
-    throw new TypeError('分区对象不能为空');
-  }
-  else {
-    this.getZone = function () {
-      return zone;
-    };
-  }
-
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-
-  await this._initManager();
-  await this._loadSources();
-};
-
-/**
- * 加载世界
- * @returns {Promise<void>}
- */
-Channel.prototype._loadWorlds = async function () {
-  // 通过事件方式加载已创建的世界数据，避免直接操作数据库
-  var worlds = await this.emitWait('world_load', {
-    zone_name: this.getZone().config.name,
-    channel_id: this.channel_id
-  });
-  if (worlds && worlds.length > 0) {
-    // 遍历世界列表，创建世界对象
-    for (var i = 0; i < worlds.length; i++) {
-      var info = worlds[i];
-      await this.createWorld(info, info.world_id);
-    }
-    this.log('info', `加载世界成功，共 ${worlds.length} 个`);
-  }
-
-  // 加载所有游戏世界
-  var promises = [];
-  for (var o of this.worlds.values()) {
-    promises.push(o.do('load'));
-  }
-  await Promise.all(promises);
-};
-
-/**
- * 初始化房间管理器
- */
-Channel.prototype._initRoomAdmin = async function () {
-  this.roomAdmin = new RoomAdmin();
-  await this.roomAdmin.do('init', this);
-};
-
-/**
- * 初始化匹配器
- */
-Channel.prototype._initMatcher = async function () {
-  this.matcher = new Matcher(this.config.match, this);
-  await this.matcher.do('init', this);
-};
-
-/**
- * 初始化管理器
- */
-Channel.prototype._initManager = async function () {
-  // var dir = this.getDir().dirname().dirname();
-  // var game = new Manager({
-  //   name: 'game',
-  //   title: '游戏',
-  //   filename: 'game.json',
-  //   tpl_dir: `../game/`.fullname(__dirname),
-  //   base_dir: '',
-  //   // base_dir: `../../common/${name}/`.fullname(__dirname),
-  //   dir: `./game`.fullname(dir)
-  // }, this, this.game, Game);
-  // await game.do('init');
-  // this.manager.game = game;
-};
-
-/**
- * 获取游戏管理器目录
- * @returns {string} 游戏管理器目录
- */
-Channel.prototype.getDir = function () {
-  return this.getZone().getDir();
-};
-
-/**
- * 加载资源
- */
-Channel.prototype._loadSources = async function () {
-  await this.manager.game.runAll('load');
-};
-
-/**
- * 设置主世界ID
- * @param {string} world_id 主世界ID
- */
-Channel.prototype.setMainWorld = function (world_id) {
-  this._main_world_id = world_id;
-};
-
-/**
- * 初始化资源
- */
-Channel.prototype._initSources = async function () {
-  await this.manager.game.runAll('init', this, this.getEventer(), this.getLogger());
-};
-
-/**
- * 加载游戏房间
- * @returns {Promise<void>}
- */
-Channel.prototype._loadRooms = async function () {
-  // 通过事件方式加载已创建的房间数据，避免直接操作数据库
-  var rooms = await this.emitWait('room_load', {
-    zone_name: this.getZone().config.name,
-    channel_id: this.channel_id
-  });
-  if (rooms && rooms.length > 0) {
-    // 遍历房间列表，创建房间对象
-    for (var i = 0; i < rooms.length; i++) {
-      var info = rooms[i];
-      var room = await this.roomAdmin.create(info, info.owner);
-      // 恢复房间原有ID
-      if (info.room_id) {
-        this.roomAdmin._rooms.delete(room.room_id);
-        room.room_id = info.room_id;
-        this.roomAdmin._rooms.set(room.room_id, room);
-      }
-      // 恢复房间状态
-      if (info.state) {
-        room.state = info.state;
-      }
-    }
-    this.log('info', `加载房间成功，共 ${rooms.length} 个`);
-  }
-
-  // 加载所有游戏房间
-  var promises = [];
-  for (var o of this.rooms.values()) {
-    promises.push(o.do('load'));
-  }
-  await Promise.all(promises);
-};
-
-/**
- * 启动核心
- */
-Channel.prototype._startCore = async function () {
-  await this._initSources();
-
-  await this._loadWorlds();
-
-  await this._initRoomAdmin();
-
-  await this._loadRooms();
-
-  await this._initMatcher();
-
-  await this.manager.game.runAll('start');
-  await this.matcher.do('start');
-  this._startMonitor();
-  await this._startWorlds();
-};
-
-/**
- * 启动游戏世界
- */
-Channel.prototype._startWorlds = async function () {
-  var promises = [];
-  for (let o of this.worlds.values()) {
-    promises.push(o.do('start'));
-  }
-  await Promise.all(promises);
-};
-
-/**
- * 初始化默认房间
- */
-Channel.prototype._initRooms = async function () {
-  var promises = [];
-  for (let o of this.rooms.values()) {
-    promises.push(o.do('init', this, this.getEventer(), this.getLogger()));
-  }
-  await Promise.all(promises);
-};
-
-/**
- * 启动频道监控
- */
-Channel.prototype._startMonitor = function () {
-  this._monitorTimer = setInterval(() => {
-    this._updateStatus();
-  }, 30000);
-};
-
-/**
- * 更新频道状态
- */
-Channel.prototype._updateStatus = function () {
-  var player = this.player_ids.size;
-  var max_players = this.config.max_players;
-  var load_ratio = player / max_players;
-
-  if (load_ratio >= 1) {
-    this.status = 3;
-  } else if (load_ratio >= this.config.load_threshold) {
-    this.status = 2;
-  } else {
-    this.status = 1;
-  }
-
-  this.stats.player = player;
-  this.stats.room = this.rooms.size;
-  this.stats.world = this.worlds.size;
-  this.stats.last_update = Date.now();
-};
-
-/**
- * 玩家进入频道
- * @param {string} player_id 玩家ID
- * @returns {object} 世界对象
- */
-Channel.prototype.enter = function (player_id) {
-  if (!player_id) {
-    throw new TypeError('玩家ID不能为空');
-  }
-
-  if (this.player_ids.has(player_id)) {
-    throw new Error('玩家已在当前频道中');
-  }
-
-  var player = this.getZone().getPlayer(player_id);
-  if (!player) {
-    throw new Error(`玩家 ${player_id} 不存在`);
-  }
-
-  var {
-    min_level,
-    max_level,
-    status,
-    max_players
-  } = this.config;
-
-  this._validateStatus(status);
-  this._validateQualify(player, min_level, max_level, max_players);
-
-  try {
-    this.player_ids.set(player_id, true);
-
-    this.emitEvent('player_enter_channel', {
-      channel_id: this.config.name,
-      player_id: player_id,
-      player_level: player.level,
-      timestamp: Date.now()
-    });
-
-    let world = this.enterMainWorld(player_id);
-    return world;
-  } catch (error) {
-    this.player_ids.delete(player_id);
-    throw error;
-  }
-};
-
-/**
- * 验证频道状态
- * @param {number} status 频道状态
- */
-Channel.prototype._validateStatus = function (status) {
-  if (status === 0) {
-    throw new Error('频道已关闭，无法进入');
-  }
-  if (status === 2) {
-    throw new Error('频道维护中，暂时无法进入');
-  }
-  if (status === 3) {
-    throw new Error('频道爆满，请稍后再试');
-  }
-};
-
-/**
- * 检查玩家是否在频道中
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否在频道中
- */
-Channel.prototype._hasPlayer = function (player_id) {
-  return this.player_ids.has(player_id);
-};
-
-/**
- * 验证玩家资格
- * @param {object} player 玩家对象
- * @param {number} min_level 最低等级
- * @param {number} max_level 最高等级
- * @param {number} max_players 最大玩家数
- */
-Channel.prototype._validateQualify = function (player, min_level, max_level, max_players) {
-  if (player.level < min_level || player.level > max_level) {
-    var msg = `境界不符，无法进入此频道（要求等级：${min_level}-${max_level}）`;
-    throw new Error(msg);
-  }
-
-  if (this.player_ids.size >= max_players) {
-    throw new Error('频道人数已达上限，无法进入');
-  }
-
-  if (this._hasPlayer(player.player_id)) {
-    throw new Error('玩家已在当前频道中');
-  }
-};
-
-/**
- * 获取默认房间
- * @param {string} player_id 玩家ID
- * @returns {object} 房间对象
- */
-Channel.prototype.getDefaultRoom = async function (player_id) {
-  var player = this.getPlayer(player_id);
-
-  var room_name = player.returning ? 'main_room' : 'cultivation_area';
-  var room = this.rooms.get(room_name);
-
-  if (!room) {
-    throw new Error(`默认房间 ${room_name} 不存在`);
-  }
-
-  return room;
-};
-
-/**
- * 玩家退出频道
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否成功退出
- */
-Channel.prototype.leave = async function (player_id) {
-  if (!player_id) {
-    throw new TypeError('玩家ID不能为空');
-  }
-
-  if (!this.player_ids.has(player_id)) {
-    throw new Error('玩家不在当前频道中');
-  }
-
-  this.player_ids.delete(player_id);
-
-  this.emitEvent('player_leave_channel', {
-    channel_id: this.config.name,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-  return true;
-};
-
-/**
- * 强制踢出玩家
- * @param {string} player_id 玩家ID
- * @param {string} reason 踢出原因
- * @returns {boolean} 是否成功踢出
- */
-Channel.prototype.kickPlayer = async function (player_id, reason = '系统维护') {
-  if (!player_id) {
-    throw new TypeError('玩家ID不能为空');
-  }
-
-  if (!this.player_ids.has(player_id)) {
-    throw new Error('玩家不在当前频道中');
-  }
-
-  this.player_ids.delete(player_id);
-
-  this.emitEvent('player_kicked_channel', {
-    channel_id: this.config.name,
-    player_id: player_id,
-    reason: reason,
-    timestamp: Date.now()
-  });
-  return true;
-};
-
-/**
- * 获取玩家对象
- * @param {string} player_id 玩家ID
- * @returns {object} 玩家对象
- */
-Channel.prototype.getPlayer = function (player_id) {
-  if (!player_id) {
-    throw new TypeError('玩家ID不能为空');
-  }
-
-  return this.getZone().getPlayer(player_id);
-};
-
-/**
- * 获取所有玩家对象
- * @returns {Array} 玩家对象列表
- */
-Channel.prototype.getAllPlayers = function () {
-  var players = [];
-  for (var player_id of this.player_ids.keys()) {
-    var player = this.getPlayer(player_id);
-    players.push(player);
-  }
-  return players;
-};
-
-/**
- * 创建房间
- * @param {string} name 房间名称
- * @param {string} player_id 玩家ID
- * @returns {object} 创建的房间对象
- */
-Channel.prototype.createRoom = async function (name, player_id) {
-  if (!name) {
-    throw new TypeError('房间名称不能为空');
-  }
-
-  if (!player_id) {
-    throw new TypeError('玩家ID不能为空');
-  }
-
-  var player = this.getPlayer(player_id);
-  if (!player) {
-    throw new Error(`玩家 ${player_id} 不存在`);
-  }
-
-  let config = {
-    name,
-    'min_level': player.level,
-    'max_level': player.level + 100
-  };
-
-  var room = await this.roomAdmin.create(config, player_id);
-  return room;
-};
-
-/**
- * 销毁房间
- * @param {string} room_id 房间ID
- * @returns {boolean} 是否成功销毁
- */
-Channel.prototype.destroyRoom = async function (room_id) {
-  if (!room_id) {
-    throw new TypeError('房间ID不能为空');
-  }
-
-  this.roomAdmin.del(room_id);
-  return true;
-};
-
-/**
- * 玩家进入房间
- * @param {string} room_id 房间ID
- * @param {string} player_id 玩家ID
- */
-Channel.prototype.enterRoom = function (room_id, player_id) {
-  this.roomAdmin.enter(room_id, player_id);
-};
-
-/**
- * 玩家退出房间
- * @param {string} room_id 房间ID
- * @param {string} player_id 玩家ID
- */
-Channel.prototype.leaveRoom = function (room_id, player_id) {
-  this.roomAdmin.leave(room_id, player_id);
-};
-
-/**
- * 获取房间列表
- * @returns {Array} 房间列表
- */
-Channel.prototype.getRoomList = function () {
-  return this.roomAdmin.getList();
-};
-
-/**
- * 玩家开始实时匹配
- * @param {string} player_id 玩家ID
- * @param {object} options 匹配选项
- * @returns {object} 匹配状态
- */
-Channel.prototype.startQuickMatch = 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_members = options.team_members || [player_id];
-  var team_size = team_members.length;
-
-  if (team_size > this._getMaxTeamSize(format)) {
-    throw new Error(`队伍人数超过限制: ${team_size}`);
-  }
-
-  for (var i = 0; i < team_members.length; i++) {
-    if (this.matcher.has(team_members[i])) {
-      throw new Error(`玩家 ${team_members[i]} 已在匹配池中`);
-    }
-  }
-
-  this.matcher.join(player_id, {
-    mode: mode,
-    format: format,
-    team_size: team_size,
-    team_members: team_members
-  });
-
-  return this.matcher.getMatchStatus(player_id);
-};
-
-/**
- * 玩家取消实时匹配
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否成功取消
- */
-Channel.prototype.cancelQuickMatch = function (player_id) {
-  if (typeof player_id !== 'string') {
-    throw new TypeError('玩家ID必须是字符串');
-  }
-
-  return this.matcher.leave(player_id);
-};
-
-/**
- * 获取实时匹配状态
- * @param {string} player_id 玩家ID
- * @returns {object|null} 匹配状态
- */
-Channel.prototype.getQuickMatchStatus = function (player_id) {
-  return this.matcher.getMatchStatus(player_id);
-};
-
-/**
- * 获取匹配统计信息
- * @returns {object} 统计信息
- */
-Channel.prototype.getMatchStats = function () {
-  return {
-    waiting_count: this.matcher.getTotalWaiting(),
-    room_count: this.roomAdmin.getCount()
-  };
-};
-
-/**
- * 获取最大队伍人数
- * @param {string} format 比赛格式
- * @returns {number} 最大队伍人数
- */
-Channel.prototype._getMaxTeamSize = function (format) {
-  var sizes = {
-    '1v1': 1,
-    '3v3': 3,
-    '5v5': 5
-  };
-  return sizes[format] || 5;
-};
-
-/**
- * 广播频道消息
- * @param {object} data 广播数据
- * @param {string} data_type 数据类型
- * @returns {boolean} 是否广播成功
- */
-Channel.prototype.broadcast = async function (data, data_type) {
-  if (!data) {
-    throw new TypeError('数据不能为空');
-  }
-
-  if (!data_type || typeof data_type !== 'string') {
-    throw new TypeError('数据类型必须是有效字符串');
-  }
-
-  // 触发广播事件，由业务层处理具体的广播逻辑
-  this.emitEvent('channel_broadcast', {
-    channel_id: this.config.name,
-    data: data,
-    data_type: data_type,
-    timestamp: Date.now()
-  });
-
-  return true;
-};
-
-/**
- * 发送频道消息
- * @param {string} player_id 发送者ID
- * @param {string} content 消息内容
- * @returns {boolean} 是否发送成功
- */
-Channel.prototype.sendMessage = async function (player_id, content) {
-  if (!player_id) {
-    throw new TypeError('发送者ID不能为空');
-  }
-
-  if (!content || typeof content !== 'string') {
-    throw new TypeError('消息内容必须是有效字符串');
-  }
-
-  if (!this.player_ids.has(player_id)) {
-    throw new Error('发送者不在当前频道中');
-  }
-
-  var player = this.getPlayer(player_id);
-
-  var msg = {
-    sender_id: player_id,
-    sender_name: player.name || player_id,
-    content: content,
-    msg_type: 'text',
-    msg_group: 'channel',
-    timestamp: Date.now(),
-    channel_id: this.config.name
-  };
-
-  // 触发消息发送事件，由业务层处理具体的发送逻辑
-  this.emitEvent('channel_message_send', msg);
-
-  return true;
-};
-
-/**
- * 公共数据传输方法
- * @param {string} sender_id 发送者ID
- * @param {object} data 传输数据
- * @param {string} data_type 数据类型
- * @returns {object} 传输结果
- */
-Channel.prototype.send = async function (sender_id, data, data_type) {
-  // 触发数据发送事件，由业务层处理具体的发送逻辑
-  this.emitEvent('channel_data_send', {
-    channel_id: this.config.name,
-    sender_id: sender_id,
-    data: data,
-    data_type: data_type,
-    timestamp: Date.now()
-  });
-
-  // 返回默认结果
-  return {
-    players: this.player_ids.size,
-    success: 0,
-    fail: 0,
-    failed_players: []
-  };
-};
-
-/**
- * 获取频道统计信息
- * @returns {object} 统计信息
- */
-Channel.prototype.getStats = function () {
-  return {
-    ...this.stats,
-    channel_name: this.config.name,
-    channel_status: this.status,
-    channel_type: this.config.type,
-    current_time: Date.now()
-  };
-};
-
-/**
- * 切换频道状态
- * @param {number} new_status 新状态
- * @returns {boolean} 是否切换成功
- */
-Channel.prototype.switchStatus = function (new_status) {
-  if (typeof new_status !== 'number' || new_status < 0 || new_status > 3) {
-    throw new TypeError('频道状态必须是0-3之间的数字');
-  }
-
-  var old_status = this.status;
-  this.status = new_status;
-
-  this.emitEvent('channel_status_changed', {
-    channel_id: this.config.name,
-    old_status: old_status,
-    new_status: new_status,
-    timestamp: Date.now()
-  });
-
-  this.log('info', `频道 ${this.channel_id} 状态切换: ${old_status} -> ${new_status}`);
-  return true;
-};
-
-/**
- * 销毁频道
- * @returns {boolean} 是否销毁成功
- */
-Channel.prototype.destroy = async function () {
-  if (this._monitorTimer) {
-    clearInterval(this._monitorTimer);
-  }
-
-  for (var player_id of this.player_ids.keys()) {
-    await this.kickPlayer(player_id, '频道关闭');
-  }
-
-  // 保存所有房间数据
-  await this._saveRooms();
-
-  for (var world_name of this.worlds.keys()) {
-    await this.destroyWorld(world_name);
-  }
-
-  for (var room_name of this.rooms.keys()) {
-    await this.destroyRoom(room_name);
-  }
-
-  if (this.matcher) {
-    this.matcher.stop();
-  }
-
-  if (this.roomAdmin) {
-    this.roomAdmin.destroy();
-  }
-
-  this.emitEvent('channel_destroyed', {
-    channel_id: this.channel_id,
-    timestamp: Date.now()
-  });
-  return true;
-};
-
-/**
- * 保存所有房间数据
- * @returns {Promise<void>}
- */
-Channel.prototype._saveRooms = async function () {
-  try {
-    var promises = [];
-    for (var room of this.roomAdmin._rooms.values()) {
-      promises.push(room.do('save'));
-    }
-    await Promise.all(promises);
-    this.log('info', `保存所有房间数据成功，共 ${this.roomAdmin._rooms.size} 个`);
-  } catch (error) {
-    this.log('error', `保存房间数据失败: `, error);
-  }
-};
-
-/**
- * 获取频道玩家数量
- * @returns {number} 玩家数量
- */
-Channel.prototype.getPlayerNum = function () {
-  return this.player_ids.size;
-};
-
-/**
- * 进入主世界
- * @param {string} player_id 玩家ID
- */
-Channel.prototype.enterMainWorld = function (player_id) {
-  this.enterWorld(player_id, this._main_world_id);
-};
-
-/**
- * 进入世界
- * @param {string} player_id 玩家ID
- * @param {string} world_id 世界ID
- * @returns {object} 世界对象
- */
-Channel.prototype.enterWorld = function (player_id, world_id) {
-  let world = this.getWorldById(world_id);
-  if (!world) {
-    throw new Error(`世界 ${world_id} 不存在`);
-  }
-  world.enter(player_id);
-  return world;
-};
-
-/**
- * 根据世界ID获取世界对象
- * @param {string} world_id 世界ID
- * @returns {object|null} 世界对象
- */
-Channel.prototype.getWorldById = function (world_id) {
-  return this.worlds.get(world_id);
-};
-
-/**
- * 根据世界名称获取世界对象
- * @param {string} name 世界名称
- * @returns {object|null} 世界对象
- */
-Channel.prototype.getWorldByName = function (name) {
-  for (let world of this.worlds.values()) {
-    if (world.config.name === name) {
-      return world;
-    }
-  }
-  return null;
-};
-
-/**
- * 创建游戏世界
- * @param {object} config 世界配置
- * @param {string} world_id 世界ID
- * @returns {object} 世界对象
- */
-Channel.prototype.createWorld = async function (config, world_id) {
-  // let game = this.game[config.type];
-  // if (!game) {
-  //   throw new Error(`游戏类型 ${config.type} 不存在`);
-  // }
-  // return await game.createWorld(config, world_id);
-};
-
-exports.Channel = Channel;