mm_os 4.3.6 → 5.0.0

package/core/room/bat/room.js

@@ -1,524 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-const {
-  idGen
-} = require('../../ulits/id_gen.js');
-
-/**
- * 游戏房间
- */
-class GameRoom extends Drive {
-  static config = {
-    // 房间名称
-    'name': '5v5',
-    // 房间标题
-    'title': '',
-    // 是否召集
-    'invite': true,
-    // 房间等级下限
-    'min_level': 0,
-    // 房间等级上限
-    'max_level': 1000,
-    // 房间最大人数
-    'max_players': 5,
-    // 游戏类型 rpg、card
-    'type': 'card',
-    // 游戏类型 排位赛rank、娱乐局casual
-    'mode': 'rank',
-    // 房间主程序
-    'main': ''
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   */
-  constructor(config) {
-    super({
-      ...GameRoom.config,
-      ...config
-    });
-
-    // 房间ID
-    this.room_id = this.genId();
-
-    // 游戏世界ID 
-    this._world_id = '';
-
-    // 房主ID
-    this.owner = '';
-
-    // 玩家ID集合 - 使用Set保证唯一性和高效查找
-    this._player_ids = new Set();
-
-    // 状态 1:waiting等待中, 2:queue队列中, 3:doing进行中
-    this.state = 1;
-
-    // 匹配时间
-    this._match_time = null;
-  }
-};
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-GameRoom.prototype.getTplDir = function() {
-  return __dirname;
-};
-
-/**
- * 生成房间ID
- * @returns {string} 房间ID
- */
-GameRoom.prototype.genId = function () {
-  return idGen.genId('room');
-};
-
-/**
- * 初始化核心
- * @param {object} channel 游戏频道
- * @param {object} eventer 事件管理器
- * @param {object} logger 日志管理器
- */
-GameRoom.prototype._initCore = async function (channel, eventer, logger) {
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  if (!channel) {
-    throw new TypeError('游戏频道不能为空');
-  }
-  // 游戏频道
-  this._channel = channel;
-};
-
-/**
- * 加载房间玩家
- * @returns {Promise<void>}
- */
-GameRoom.prototype._load = async function () {
-  try {
-    // 通过事件方式加载房间内的玩家数据，避免直接操作数据库
-    var players = await this.emitWait('room_player_load', {
-      room_id: this.room_id,
-      room_name: this.config.name,
-      room: this
-    });
-    if (players && players.length > 0) {
-      // 遍历玩家列表，恢复玩家到房间
-      for (var i = 0; i < players.length; i++) {
-        var player_id = players[i];
-        // 添加玩家到房间
-        this._player_ids.add(player_id);
-      }
-      this.log('info', `加载房间玩家成功，共 ${players.length} 人`);
-    }
-  } catch (error) {
-    this.log('error', `加载房间玩家数据失败: `, error);
-  }
-};
-
-/**
- * 设置房主
- * @param {object} player 房主
- */
-GameRoom.prototype.setOwner = function (player) {
-  this.owner = player.player_id;
-};
-
-/**
- * 检查房间是否有玩家
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否有玩家
- */
-GameRoom.prototype._hasPlayer = function (player_id) {
-  return this._player_ids.has(player_id);
-};
-
-/**
- * 添加玩家
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype._addPlayer = function (player_id) {
-  this._player_ids.add(player_id);
-};
-
-/**
- * 移除玩家
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype._delPlayer = function (player_id) {
-  this._player_ids.delete(player_id);
-};
-
-/**
- * 获取游戏世界
- * @returns {object} 游戏世界
- */
-GameRoom.prototype.getWorld = function () {
-  // 从游戏频道获取游戏世界
-  return this._channel.getWorld(this._world_id);
-};
-
-/**
- * 设置游戏世界
- * @param {string} world_id 游戏世界ID
- */
-GameRoom.prototype.setWorldId = function (world_id) {
-  this._world_id = world_id;
-};
-
-/**
- * 创建游戏世界
- * @param {object} config 游戏世界配置
- * @returns {object} 游戏世界
- */
-GameRoom.prototype.createWorld = async function (config) {
-  // 游戏世界
-  var world = await this._channel.createWorld({ ...this.config, ...config });
-  // 设置游戏世界
-  this.setWorldId(world.world_id);
-  return world;
-};
-
-/**
- * 广播消息给房间内所有玩家
- * @param {string} event 事件名称
- * @param {object} data 数据
- */
-GameRoom.prototype.broadcast = function (event, data) {
-  var player_ids = this.getAllPlayerIds();
-  // 直接触发房间广播事件，让事件处理器来处理
-  this.emitEvent('room_broadcast', {
-    room_id: this.room_id,
-    room_name: this.config.name,
-    event: event,
-    data: data,
-    player_ids: player_ids,
-    timestamp: Date.now()
-  });
-  this.log('debug', `广播消息: ${event} 给 ${player_ids.length} 名玩家`);
-};
-
-/**
- * 玩家进入房间
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype.enter = function (player_id) {
-  // 检查玩家是否已在房间内
-  if (this._hasPlayer(player_id)) {
-    throw new Error(`玩家 ${player_id} 已在房间内`);
-  }
-  this._addPlayer(player_id);
-  this.emitEvent('room_enter', {
-    room_id: this.room_id,
-    room_name: this.config.name,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 玩家退出房间
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype.leave = function (player_id) {
-  this._delPlayer(player_id);
-  this.emitEvent('room_leave', {
-    room_id: this.room_id,
-    room_name: this.config.name,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 获取房间玩家数量
- * @returns {number} 玩家数量
- */
-GameRoom.prototype.getPlayerNum = function () {
-  return this._player_ids.size;
-};
-
-/**
- * 获取所有玩家ID
- * @returns {Array} 玩家ID数组
- */
-GameRoom.prototype.getAllPlayerIds = function () {
-  return Array.from(this._player_ids);
-};
-
-/**
- * 开始匹配
- */
-GameRoom.prototype.startMatch = function () {
-  // 检查所有玩家是否已准备
-  if (!this.isAllPlayersReady()) {
-    throw new Error('房间内玩家未全部准备');
-  }
-  // 检查房间是否已开始匹配
-  if (this.state === 2) {
-    throw new Error('房间已开始匹配');
-  }
-  // 检查房间是否已开始游戏
-  else if (this.state === 3) {
-    throw new Error('房间已开始游戏');
-  }
-  
-  this.state = 2;
-  // 记录匹配开始时间
-  this._match_time = Date.now();
-  
-  // 触发开始匹配事件
-  this.emitEvent('room_start_match', {
-    room_id: this.room_id,
-    room_name: this.config.name,
-    timestamp: this._match_time
-  });
-};
-
-/**
- * 匹配玩家
- * 根据房间配置进行玩家匹配
- * @returns {object} 匹配结果
- */
-GameRoom.prototype._matchPlayers = function () {
-  var config = this.config;
-  var format = config.format || '5v5';
-  var mode = config.mode || 'rank';
-  var player_ids = this.getAllPlayerIds();
-  var player_count = player_ids.length;
-
-  var ret = this._checkMatch(player_count, config.max_players || 6);
-  if (!ret.valid) {
-    return { success: false, reason: ret.reason };
-  }
-
-  var teams = this._splitTeams(player_ids, format);
-  if (!teams) {
-    return { success: false, reason: '玩家数量不符合比赛格式要求' };
-  }
-
-  return this._buildMatch(mode, format, teams, player_count);
-};
-
-/**
- * 检查匹配条件
- * @param {number} player_count 玩家数量
- * @param {number} max_players 最大玩家数
- * @returns {object} 检查结果
- */
-GameRoom.prototype._checkMatch = function (player_count, max_players) {
-  if (player_count === 0) {
-    return { valid: false, reason: '房间内没有玩家' };
-  }
-  if (player_count > max_players) {
-    return { valid: false, reason: '房间内玩家数量超过上限' };
-  }
-  return { valid: true };
-};
-
-/**
- * 构建匹配结果
- * @param {string} mode 游戏模式
- * @param {string} format 比赛格式
- * @param {object} teams 队伍配置
- * @param {number} player_count 玩家数量
- * @returns {object} 匹配结果
- */
-GameRoom.prototype._buildMatch = function (mode, format, teams, player_count) {
-  var ret = {
-    success: true,
-    room_id: this.room_id,
-    mode: mode,
-    format: format,
-    teams: teams,
-    player_count: player_count,
-    timestamp: Date.now()
-  };
-
-  this.emitEvent('room_match_success', {
-    room_id: this.room_id,
-    ret: ret
-  });
-
-  return ret;
-};
-
-/**
- * 根据比赛格式分割队伍
- * @param {Array} player_ids 玩家ID数组
- * @param {string} format 比赛格式 (1v1, 3v3, 5v5, 1v3, 1v5)
- * @returns {object|null} 队伍配置
- */
-GameRoom.prototype._splitTeams = function (player_ids, format) {
-  var count = player_ids.length;
-  var format_map = {
-    '1v1': { count: 2, team_a_size: 1 },
-    '3v3': { count: 6, team_a_size: 3 },
-    '5v5': { count: 10, team_a_size: 5 },
-    '1v3': { count: 4, team_a_size: 1 },
-    '1v5': { count: 6, team_a_size: 1 }
-  };
-
-  var rule = format_map[format];
-  if (rule && count === rule.count) {
-    return {
-      team_a: player_ids.slice(0, rule.team_a_size),
-      team_b: player_ids.slice(rule.team_a_size),
-      format: format
-    };
-  }
-
-  if (count >= 2) {
-    var half = Math.floor(count / 2);
-    return { team_a: player_ids.slice(0, half), team_b: player_ids.slice(half), format: format };
-  }
-
-  return null;
-};
-
-/**
- * 获取玩家
- * @param {string} player_id 玩家ID
- * @returns {object} 玩家对象
- */
-GameRoom.prototype._getPlayer = function(player_id) {
-  // 这里需要从游戏频道获取玩家对象
-  return this._channel.getPlayer(player_id);
-};
-
-/**
- * 玩家准备
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype.ready = function(player_id) {
-  // 检查玩家是否已在房间内
-  if (!this._hasPlayer(player_id)) {
-    throw new Error(`玩家 ${player_id} 不在房间内`);
-  }
-  // 获取玩家
-  var player = this._getPlayer(player_id);
-  player.is_ready = true;
-  
-  // 触发玩家准备事件
-  this.emitEvent('player_ready', {
-    room_id: this.room_id,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 玩家取消准备
- * @param {string} player_id 玩家ID
- */
-GameRoom.prototype.cancelReady = function(player_id) {
-  // 检查玩家是否已在房间内
-  if (!this._hasPlayer(player_id)) {
-    throw new Error(`玩家 ${player_id} 不在房间内`);
-  }
-  // 获取玩家
-  var player = this._getPlayer(player_id);
-  player.is_ready = false;
-  
-  // 触发玩家取消准备事件
-  this.emitEvent('player_cancel_ready', {
-    room_id: this.room_id,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 检查所有玩家是否已准备
- * @returns {boolean} 是否全部准备
- */
-GameRoom.prototype.isAllPlayersReady = function() {
-  var player_ids = this.getAllPlayerIds();
-  // 如果房间没有玩家，返回false
-  if (player_ids.length === 0) {
-    return false;
-  }
-
-  // 使用for循环检查除房主外的所有玩家是否已准备
-  for (var i = 0; i < player_ids.length; i++) {
-    var player_id = player_ids[i];
-    
-    // 跳过房主（房主没有准备按钮）
-    if (player_id === this.owner) {
-      continue;
-    }
-    
-    var player = this._getPlayer(player_id);
-    
-    // 如果有一个玩家未准备，返回false
-    if (!player.is_ready) {
-      return false;
-    }
-  }
-  
-  // 所有非房主玩家都已准备
-  return true;
-};
-
-/**
- * 获取准备玩家列表
- * @returns {Array} 准备玩家ID列表
- */
-GameRoom.prototype.getReadyPlayers = function() {
-  var ready_players = [];
-  var player_ids = this.getAllPlayerIds();
-  
-  // 使用for循环获取除房主外的准备玩家列表
-  for (var i = 0; i < player_ids.length; i++) {
-    var player_id = player_ids[i];
-    
-    // 跳过房主（房主没有准备按钮）
-    if (player_id === this.owner) {
-      continue;
-    }
-    
-    var player = this._getPlayer(player_id);
-    
-    // 如果玩家已准备，添加到列表
-    if (player.is_ready) {
-      ready_players.push(player_id);
-    }
-  }
-  
-  return ready_players;
-};
-
-/**
- * 保存房间数据
- * @returns {Promise<void>}
- */
-GameRoom.prototype._save = async function () {
-  try {
-    var room_data = {
-      room_id: this.room_id,
-      name: this.config.name,
-      owner: this.owner,
-      state: this.state,
-      player_ids: this.getAllPlayerIds(),
-      world_id: this._world_id
-    };
-    // 通过事件方式保存房间数据
-    await this.emitWait('room_save', {
-      room_id: this.room_id,
-      room_data: room_data
-    });
-    this.log('debug', `保存房间数据成功`);
-  } catch (error) {
-    this.log('error', `保存房间数据失败: `, error);
-  }
-};
-
-exports.GameRoom = GameRoom;

package/core/room/config.tpl.json

@@ -1,20 +0,0 @@
-{
-  // 房间名称
-  "name": "5v5_rank",
-  // 房间标题
-  "title": "5v5排位赛",
-  // 房间描述
-  "description": "5v5排位赛房间",
-  // 房间等级上限
-  "max_level": 1000,
-  // 房间最大人数
-  "max_players": 5,
-  // 游戏类型 rpg、card
-  "type": "card",
-  // 游戏类型 排位赛rank、娱乐局casual
-  "mode": "rank",
-  // 房间主程序
-  "main": "",
-  // 房间最大房间数
-  "max_rooms": 1000
-}