mm_os 4.3.7 → 5.0.1

package/core/game/bat/world.js

@@ -1,622 +0,0 @@
-const {
-  Drive,
-  Manager
-} = require('mm_machine');
-const {
-  Scene
-} = require('../../scene/index.js');
-const {
-  System
-} = require('../../system/index.js');
-const {
-  Logic
-} = require('../../logic/index.js');
-const {
-  Factory
-} = require('../../factory/index.js');
-const {
-  Component
-} = require('../../component/index.js');
-const {
-  EntityAdmin
-} = require('../entity_admin.js');
-const {
-  GameLoop
-} = require('../../scene/loop.js');
-const {
-  idGen
-} = require('../../../ulits/id_gen.js');
-
-/**
- * 游戏世界
- */
-class GameWorld extends Drive {
-  static config = {
-    // 游戏名称
-    'name': 'world',
-    // 游戏标题
-    'title': '游戏世界',
-    // 游戏描述
-    'description': '这是一个游戏世界',
-    // 游戏主脚本 - 可自定义游戏初始化，一般情况不需要定义
-    'main': '',
-    // 游戏状态 - 1 正常 0 禁用
-    'state': 1,
-    // 游戏排序 - 数字越小越靠前
-    'sort': 100,
-    // 游戏类型 - 角色扮演rpg、卡牌游戏card、策略游戏strategy、模拟经营simulation
-    'type': 'rpg',
-    // 游戏实体类型 - 玩家player、NPC、怪物、物品等
-    'entity_type': 'player'
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   */
-  constructor(config = {}) {
-    super({ ...GameWorld.config, ...config });
-
-    // 游戏世界ID
-    this.world_id = this.genId();
-    // 玩家ID集合 - 使用Set保证唯一性和高效查找
-    this._player_ids = new Set();
-
-    // 游戏实体
-    this.entities = new Map();
-
-    // 实体管理器
-    this.entityAdmin = null;
-    // 游戏循环
-    this.loop = null;
-
-    // 游戏场景集合
-    this.scene = {};
-    // 游戏系统集合
-    this.system = {};
-    // 游戏逻辑集合
-    this.logic = {};
-    // 游戏工厂集合
-    this.factory = {};
-    // 游戏组件集合
-    this.component = {};
-
-    // 管理器集合
-    this.manager = {};
-  }
-}
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-GameWorld.prototype.getTplDir = function () {
-  return __dirname;
-};
-
-/**
- * 获取游戏管理器目录
- * @returns {string} 游戏管理器目录
- */
-GameWorld.prototype.getDir = function () {
-  return this.getGame().getDir();
-};
-
-/**
- * 生成游戏世界ID
- * @returns {string} 游戏世界ID
- */
-GameWorld.prototype.genId = function () {
-  return idGen.genId('world');
-};
-
-/**
- * 创建管理器实例
- * @param {string} name 管理器名称
- * @param {string} title 管理器标题
- * @param {Function} cls 管理器类
- * @returns {object} 管理器实例
- */
-GameWorld.prototype._createManager = function (name, title, cls) {
-  var dir = this.getDir();
-  var manager = new Manager({
-    name,
-    title,
-    scope: this.config.name,
-    dir: `./${name}`.fullname(dir)
-  }, this, this[name], cls);
-
-  this.manager[name] = manager;
-  return manager;
-};
-
-/**
- * 初始化管理器集合
- * @returns {Promise<void>} 初始化完成
- */
-GameWorld.prototype._initManager = async function () {
-  // 创建所有管理器实例
-  var component = this._createManager('component', '组件', Component);
-  var factory = this._createManager('factory', '工厂', Factory);
-  var logic = this._createManager('logic', '逻辑', Logic);
-  var system = this._createManager('system', '系统', System);
-  var scene = this._createManager('scene', '场景', Scene);
-
-  // 并行执行所有管理器的初始化操作
-  var initPromises = [
-    component.do('init'),
-    factory.do('init'),
-    logic.do('init'),
-    system.do('init'),
-    scene.do('init'),
-  ];
-
-  await Promise.all(initPromises);
-  // 创建实体管理器
-  this.entityAdmin = new EntityAdmin();
-};
-
-/**
- * 初始化游戏循环
- * @private
- */
-GameWorld.prototype._initGameLoop = async function () {
-  // 游戏循环
-  this._loop = new GameLoop(this.config.game_loop);
-  await this._loop.do('init', this, this.getEventer(), this.getLogger());
-};
-
-/**
- * 加载资源
- */
-GameWorld.prototype._loadSources = async function () {
-  // 加载无需依赖关系，所以可以同时加载
-  await Promise.all([
-    this.manager.component.runAll('load'),
-    this.manager.factory.runAll('load'),
-    this.manager.logic.runAll('load'),
-    this.manager.system.runAll('load'),
-    this.manager.scene.runAll('load')
-  ]);
-};
-
-/**
- * 初始化资源
- */
-GameWorld.prototype._initSources = async function () {
-  // 初始化顺序 scene -> system -> logic -> factory -> entity -> component ，需要依赖下级，所以自下而上初始化
-  await this.manager.component.runAll('init', this.getLogger());
-  await this.manager.factory.runAll('init', this.component, this.getEventer(), this.getLogger());
-  await this.entityAdmin.do('init', this.entities, this.factory, this.getEventer(), this.getLogger());
-  await this.manager.logic.runAll('init', this.getLogger());
-  await this.manager.system.runAll('init', this, this.getEventer(), this.getLogger());
-  await this.manager.scene.runAll('init', this.system, this.getEventer(), this.getLogger());
-};
-
-/**
- * 初始化核心
- * @param {object} channel 游戏频道
- * @param {object} eventer 事件总线
- * @param {object} logger 日志管理器
- * @returns {void}
- */
-GameWorld.prototype._initCore = async function (channel, eventer, logger) {
-  // 初始化依赖项
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  if (!channel) {
-    throw new Error('游戏世界必须绑定游戏频道');
-  }
-  else if (channel) {
-    this.getChannel = function () {
-      return channel;
-    };
-  }
-
-  // 初始化管理
-  await this._initManager();
-  // 加载资源
-  await this._loadSources();
-  // 初始化资源
-  await this._initSources();
-  // 初始化游戏循环
-  await this._initGameLoop();
-};
-
-/**
- * 加载实体
- * @returns {Promise<void>}
- */
-GameWorld.prototype._loadEntities = async function () {
-  try {
-    // 通过事件方式加载已存在的实体数据，避免直接操作数据库
-    var entities = await this.emitWait('entity_load', {
-      world_id: this.world_id,
-      world_name: this.config.name
-    });
-    if (entities && entities.length > 0) {
-      // 遍历实体列表，恢复实体对象
-      for (var i = 0; i < entities.length; i++) {
-        var info = entities[i];
-        // 使用工厂创建实体
-        var factory = this.createEntity(info.type, info.model);
-        if (factory) {
-          // 恢复玩家ID
-          if (info.player_id) {
-            this._player_ids.add(info.player_id);
-          }
-        }
-      }
-    }
-  } catch (error) {
-    this.log('error', `加载实体数据失败: `, error);
-  }
-};
-
-/**
- * 启动资源
- */
-GameWorld.prototype._startSources = async function () {
-  // 并行启动游戏系统和场景
-  await Promise.all([
-    // 启动游戏系统
-    this.manager.system.runAll('start'),
-    // 启动游戏场景
-    this.manager.scene.runAll('start')
-  ]);
-};
-
-/**
- * 启动核心
- */
-GameWorld.prototype._startCore = async function () {
-  // 加载实体（在启动前恢复已存在的实体）
-  await this._loadEntities();
-  // 启动资源
-  await this._startSources();
-  // 启动游戏循环
-  await this._loop.do('start');
-};
-
-/**
- * 游戏世界更新
- */
-GameWorld.prototype.update = async function () {
-  await this.manager.system.runAll('update');
-  await this.manager.scene.runAll('update');
-};
-
-/**
- * 保存脏数据实体
- * @returns {Promise<void>}
- */
-GameWorld.prototype._saveDirtyEntities = async function () {
-  try {
-    var entities = [];
-    // 遍历所有实体，收集脏数据
-    for (var entity of this.entities.values()) {
-      if (entity.isDirty()) {
-        entities.push(entity);
-        // 触发实体数据变化事件
-        this.emitEvent('entity_changed', {
-          entity: entity,
-          world_id: this.world_id,
-          timestamp: Date.now()
-        });
-      }
-    }
-    if (entities.length > 0) {
-      // 通过事件方式保存脏数据实体
-      await this.emitWait('entity_save', {
-        world_id: this.world_id,
-        world_name: this.config.name,
-        entities: entities
-      });
-      // 重置脏标记
-      for (var i = 0; i < entities.length; i++) {
-        entities[i].isDirty(false);
-      }
-      this.log('debug', `保存脏数据实体 ${entities.length} 个`);
-    }
-  } catch (error) {
-    this.log('error', `保存脏数据实体失败: `, error);
-  }
-};
-
-/**
- * 保存所有实体
- * @returns {Promise<void>}
- */
-GameWorld.prototype._saveAllEntities = async function () {
-  try {
-    var all_entities = Array.from(this.entities.values());
-    if (all_entities.length > 0) {
-      // 通过事件方式保存所有实体
-      await this.emitWait('entity_save', {
-        world_id: this.world_id,
-        world_name: this.config.name,
-        entities: all_entities
-      });
-      this.log('info', `保存所有实体 ${all_entities.length} 个`);
-    }
-  } catch (error) {
-    this.log('error', `保存所有实体失败: `, error);
-  }
-};
-
-/**
- * 销毁游戏世界
- * @private
- * @returns {Promise<void>} 销毁完成后的Promise
- */
-GameWorld.prototype._destroy = async function () {
-  // 销毁前保存所有实体
-  await this._saveAllEntities();
-  await this.manager.system.runAll('destroy');
-  await this.manager.scene.runAll('destroy');
-};
-
-/**
- * 获取实体
- * @param {object} id 实体ID
- * @returns {object|null} 实体对象，如果不存在则返回null
- */
-GameWorld.prototype.getEntity = function (id) {
-  return this.entities.get(id);
-};
-
-/**
- * 获取组件相关实体
- * @param {Array} types 组件类型数组
- * @returns {Array} 符合条件的实体数组
- */
-GameWorld.prototype.getEntitiesByTypes = function (types) {
-  // 实现实体查询逻辑
-  let result = [];
-  for (let entity of this.entities.values()) {
-    if (types.every(type => entity.hasComponent(type))) {
-      result.push(entity);
-    }
-  }
-  return result;
-};
-
-/**
- * 获取相关标签实体
- * @param {Array} tags 标签数组
- * @returns {Array} 符合条件的实体数组
- */
-GameWorld.prototype.getEntitiesByTags = function (tags) {
-  // 实现实体查询逻辑
-  let result = [];
-  for (let entity of this.entities.values()) {
-    if (tags.every(type => entity.hasTag(type))) {
-      result.push(entity);
-    }
-  }
-  return result;
-};
-
-/**
- * 创建实体
- * @param {string} type 实体类型 - 可选值为 玩家、NPC、怪物、物品等
- * @param {object} model 实体模型 - 可选，根据实体类型定义
- * @returns {object} 创建的实体对象
- */
-GameWorld.prototype.createEntity = function (type = 'player', model = {}) {
-  // 使用工厂创建实体
-  var factory = this.factory[type];
-  if (!factory) {
-    throw new Error(`${this.config.title}游戏工厂(${type})不存在`);
-  }
-  let entity = factory.create(model);
-  this.entities.set(entity.entity_id, entity);
-
-  // 注册实体与玩家的映射关系
-  if (entity.player_id) {
-    // 尝试获取 Pusher 实例并注册映射
-    if ($.pusher) {
-      $.pusher.registerEntityPlayer(entity.entity_id, entity.player_id);
-    }
-  }
-
-  // 触发实体创建事件
-  this.emitEvent('entity_created', {
-    entity: entity,
-    world_id: this.world_id,
-    timestamp: Date.now()
-  });
-
-  return entity;
-};
-
-/**
- * 玩家进入世界
- * @param {string} player_id 玩家ID
- * @param {string} entity_type 实体类型 - 可选值为 玩家、NPC、怪物、物品等
- * @returns {object} 玩家实体对象
- */
-GameWorld.prototype.enter = async function (player_id, entity_type) {
-  // 参数校验
-  if (!player_id) {
-    throw new TypeError('玩家ID无效');
-  }
-  let player = this.getChannel().getPlayer(player_id);
-  // 参数校验
-  if (!player) {
-    throw new TypeError('玩家对象无效');
-  }
-  if (this._player_ids.has(player_id)) {
-    throw new Error(`玩家 ${player_id} 已存在`);
-  }
-
-  try {
-    this._addPlayer(player_id);
-    // 创建玩家实体
-    let entity = this.createEntity(entity_type || this.config.entity_type, player);
-
-    // 触发玩家进入世界事件
-    this.emitEvent('player_enter_world', {
-      world_id: this.world_id,
-      world_name: this.config.name,
-      player_id: player.player_id,
-      player_level: player.level,
-      timestamp: Date.now()
-    });
-
-    // 将玩家添加到默认场景
-    let default_scene = this.scene['default'];
-    if (default_scene) {
-      await default_scene.addPlayer(entity);
-    }
-    return entity;
-  } catch (error) {
-    this.log('error', `玩家进入世界失败: `, error);
-    throw error;
-  }
-};
-
-/**
- * 玩家离开世界
- * @param {string} player_id 玩家ID
- * @returns {object} 离开的玩家实体
- */
-GameWorld.prototype.leave = async function (player_id) {
-  // 参数校验
-  if (!player_id) {
-    throw new TypeError('玩家ID无效');
-  }
-  // 查找玩家实体
-  let entity = this.entities.get(player_id);
-  if (!entity) {
-    throw new Error(`玩家 ${player_id} 不存在`);
-  }
-
-  // 从默认场景移除玩家
-  let default_scene = this.scene['default'];
-  if (default_scene) {
-    await default_scene.leave(entity);
-  }
-
-  // 触发玩家离开世界事件
-  this.emitEvent('player_leave_world', {
-    world_id: this.world_id,
-    world_name: this.config.name,
-    player_id: player_id,
-    timestamp: Date.now()
-  });
-
-  // 触发实体删除事件
-  this.emitEvent('entity_deleted', {
-    entity_id: entity.entity_id,
-    world_id: this.world_id,
-    timestamp: Date.now()
-  });
-
-  // 从实体管理器移除玩家实体
-  this.entities.delete(player_id);
-  // 从玩家ID集合中移除
-  this._removePlayer(player_id);
-  return entity;
-};
-
-/**
- * 玩家进入场景
- * @param {string} player_id 玩家ID
- * @param {string} scene_id 场景ID
- * @returns {boolean} 是否成功进入
- */
-GameWorld.prototype.enterScene = async function (player_id, scene_id) {
-  // 参数校验
-  if (!player_id) {
-    throw new TypeError('玩家ID无效');
-  }
-  if (!scene_id) {
-    throw new TypeError('场景ID无效');
-  }
-  // 查找玩家实体
-  let entity = this.entities.get(player_id);
-  if (!entity) {
-    throw new Error(`玩家 ${player_id} 不存在`);
-  }
-  // 查找场景
-  let scene = this.scene[scene_id];
-  if (!scene) {
-    throw new Error(`场景 ${scene_id} 不存在`);
-  }
-  // 触发玩家进入场景事件
-  this.emitEvent('player_enter_scene', {
-    world_id: this.world_id,
-    world_name: this.config.name,
-    player_id: player_id,
-    scene_id: scene_id,
-    timestamp: Date.now()
-  });
-
-  // 将玩家添加到场景
-  await scene.addPlayer(entity);
-  return true;
-};
-
-/**
- * 添加玩家到世界
- * @param {string} player_id 玩家ID
- */
-GameWorld.prototype._addPlayer = function (player_id) {
-  // 参数校验
-  if (!player_id) {
-    throw new TypeError('玩家ID无效');
-  }
-  // 检查玩家是否已存在
-  if (this._player_ids.has(player_id)) {
-    throw new Error(`玩家 ${player_id} 已存在`);
-  }
-  // 添加玩家ID到集合
-  this._player_ids.add(player_id);
-};
-
-/**
- * 移除玩家
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否成功移除
- */
-GameWorld.prototype._removePlayer = function (player_id) {
-  // 参数校验
-  if (!player_id) {
-    throw new TypeError('玩家ID无效');
-  }
-  return this._player_ids.delete(player_id);
-};
-
-/**
- * 获取世界玩家数量
- * @returns {number} 玩家数量
- */
-GameWorld.prototype.getPlayerNum = function () {
-  return this._player_ids.size;
-};
-
-/**
- * 检查玩家是否在世界中
- * @param {string} player_id 玩家ID
- * @returns {boolean} 是否存在
- */
-GameWorld.prototype.hasPlayer = function (player_id) {
-  return this._player_ids.has(player_id);
-};
-
-/**
- * 获取所有玩家ID
- * @returns {Array} 玩家ID数组
- */
-GameWorld.prototype.getAllPlayerIds = function () {
-  return Array.from(this._player_ids);
-};
-
-exports.GameWorld = GameWorld;

package/core/game/config.tpl.json

@@ -1,16 +0,0 @@
-{
-  // 游戏名称
-  "name": "${name || 'world'}",
-  // 游戏标题
-  "title": "${title || '游戏'}",
-  // 游戏描述
-  "description": "${description || '这是一个游戏'}",
-  // 游戏主脚本 - 可自定义游戏初始化，一般情况不需要定义
-  "main": "${main || 'index.js'}",
-  // 游戏状态 - 1 正常 0 禁用
-  "state": 1,
-  // 游戏排序 - 数字越小越靠前
-  "sort": 100,
-  // 游戏类型 - 角色扮演rpg、卡牌游戏card、策略游戏strategy、模拟经营simulation
-  "type": "${type || 'card'}"
-}