mm_os 3.3.0 → 4.0.0

package/core/channel/index.js

@@ -0,0 +1,899 @@
+const {
+  Drive,
+  Manager
+} = 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();
+  await this._initSources();
+
+  await this._loadWorlds();
+
+  await this._initRoomAdmin();
+
+  await this._loadRooms();
+
+  await this._initMatcher();
+};
+
+/**
+ * 加载世界
+ * @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.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;