mm_os 4.3.6 → 5.0.0

package/core/game/entity_admin.js

@@ -1,230 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-
-/**
- * 实体管理器
- */
-class EntityAdmin extends Drive {
-  /**
-   * 构造函数
-   * @param {object} config 配置对象
-   */
-  constructor(config) {
-    super(config);
-    this._entities = new Map();
-    this._componentIndex = new Map();
-  }
-}
-
-/**
- * 初始化核心组件
- * @param {Map} entities 实体集合
- * @param {object} factory 实体工厂
- * @param {object} eventer 事件总线
- * @param {object} logger 日志记录器
- */
-EntityAdmin.prototype._initCore = async function (entities, factory, eventer, logger) {
-  if (!entities) {
-    this.log('error', '实体集合为空');
-    return;
-  }
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  if (factory) {
-    this._factory = factory;
-  }
-  this._entities = entities;
-};
-
-/**
- * 获取所有实体
- * @returns {Iterator} 实体迭代器
- */
-EntityAdmin.prototype.getEntities = function () {
-  return this._entities.values();
-};
-
-/**
- * 获取实体
- * @param {string} id 实体ID
- * @returns {object} 实体
- */
-EntityAdmin.prototype.getEntity = function (id) {
-  return this._entities.get(id);
-};
-
-/**
- * 添加实体
- * @param {object} entity 实体
- */
-EntityAdmin.prototype.addEntity = function (entity) {
-  this._entities.set(entity.getId(), entity);
-  this._updateComponentIndex(entity);
-  // 触发实体创建事件
-  this.emitEvent('entity_create', {
-    entity_id: entity.getId(),
-    entity_type: entity.type || 'unknown',
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 更新组件索引
- * @param {object} entity 实体
- * @returns {void}
- */
-EntityAdmin.prototype._updateComponentIndex = function (entity) {
-  for (let [compName] of entity._component) {
-    if (!this._componentIndex.has(compName)) {
-      this._componentIndex.set(compName, new Set());
-    }
-    this._componentIndex.get(compName).add(entity.getId());
-  }
-};
-
-/**
- * 删除实体
- * @param {string} id 实体ID
- */
-EntityAdmin.prototype.delEntity = function (id) {
-  let entity = this._entities.get(id);
-  if (entity) {
-    // 触发实体销毁事件
-    this.emitEvent('entity_destroy', {
-      entity_id: id,
-      entity_type: entity.type || 'unknown',
-      timestamp: Date.now()
-    });
-    this._delCompIndex(entity);
-    this._entities.delete(id);
-  }
-};
-
-/**
- * 从组件索引中移除实体
- * @param {object} entity 实体
- * @returns {void}
- */
-EntityAdmin.prototype._delCompIndex = function (entity) {
-  for (let [compName] of entity._component) {
-    let index = this._componentIndex.get(compName);
-    if (index) {
-      index.delete(entity.getId());
-      if (index.size === 0) {
-        this._componentIndex.delete(compName);
-      }
-    }
-  }
-};
-
-/**
- * 检查实体是否存在
- * @param {string} id 实体ID
- * @returns {boolean} 是否存在
- */
-EntityAdmin.prototype.hasEntity = function (id) {
-  return this._entities.has(id);
-};
-
-/**
- * 创建实体
- * @param {object} model 实体配置
- * @returns {object} 实体
- */
-EntityAdmin.prototype.createEntity = function (model) {
-  var factory = this._factory[model.type];
-  if (!factory) {
-    this.log('error', `实体类型 ${model.type} 不存在`);
-    return null;
-  }
-  let entity = factory.create(model);
-  this.addEntity(entity);
-  return entity;
-};
-
-/**
- * 删除实体组件
- * @param {object} entity 实体
- * @param {string} name 组件类型
- */
-EntityAdmin.prototype.delComponent = function (entity, name) {
-  entity.delComponent(name);
-  // 触发实体组件移除事件
-  this.emitEvent('entity_component_del', {
-    entity_id: entity.getId(),
-    component: name,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 获取实体组件
- * @param {object} entity 实体
- * @param {string} name 组件类型
- * @returns {object} 组件
- */
-EntityAdmin.prototype.getComponent = function (entity, name) {
-  return entity.getComponent(name);
-};
-
-/**
- * 添加实体组件
- * @param {object} entity 实体
- * @param {string} name 组件类型
- */
-EntityAdmin.prototype.addComponent = function (entity, name) {
-  let component = this._component[name].create();
-  entity.addComponent(name, component);
-  // 触发实体组件添加事件
-  this.emitEvent('entity_component_add', {
-    entity_id: entity.getId(),
-    component: name,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 查询包含特定组件的实体
- * @param {Array} names 组件类型数组
- * @returns {Array} 实体数组
- */
-EntityAdmin.prototype.getByComponents = function (names) {
-  if (!names || names.length === 0) {
-    return [];
-  }
-  
-  let first_comp = names[0];
-  let candidates = this._componentIndex.get(first_comp);
-  if (!candidates) {
-    return [];
-  }
-  
-  let result = [];
-  for (let entity_id of candidates) {
-    let entity = this._entities.get(entity_id);
-    if (entity) {
-      let has_all = true;
-      for (let i = 1; i < names.length; i++) {
-        if (!entity.hasComponent(names[i])) {
-          has_all = false;
-          break;
-        }
-      }
-      if (has_all) {
-        result.push(entity);
-      }
-    }
-  }
-  return result;
-};
-
-module.exports = {
-  EntityAdmin
-};

package/core/game/index.js

@@ -1,186 +0,0 @@
-const {
-  Drive,
-  Manager
-} = require('mm_machine');
-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 {
-  Scene
-} = require('../scene/index.js');
-
-/**
- * 游戏
- */
-class Game extends Drive {
-  static config = {
-    name: 'default',
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 游戏配置
-   * @param {object} parent 父驱动
-   */
-  constructor(config, parent = null) {
-    super({...Game.config, ...config }, parent);
-    // // 游戏场景集合
-    // this.scene = {};
-    // 游戏系统集合
-    this.system = {};
-    // 游戏逻辑集合
-    this.logic = {};
-    // 游戏工厂集合
-    this.factory = {};
-    // 游戏组件集合
-    this.component = {};
-
-    // 管理器集合
-    this.manager = {};
-  }
-}
-
-// /**
-//  * 预设游戏配置
-//  */
-// Game.prototype._preset = function () {
-//   this.file = null;
-//   this.sql = null;
-//   this.cache = null;
-// };
-
-/**
- * 初始化游戏核心
- * @param {object} server 游戏服务器
- * @param {object} eventer 事件分发器
- * @param {object} logger 日志记录器
- */
-Game.prototype._initCore = async function (server, eventer, logger) {
-  if (!server) {
-    throw new TypeError('游戏服务器不能为空');
-  }
-  else {
-    this.getServer = function () {
-      return server;
-    };
-  }
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  // 初始化管理
-  await this._initManager();
-  // 加载资源
-  await this._loadSources();
-};
-
-/**
- * 初始化管理器集合
- * @returns {Promise<void>} 初始化完成
- */
-Game.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);
-};
-
-/**
- * 创建管理器实例
- * @param {string} name 管理器名称
- * @param {string} title 管理器标题
- * @param {Function} cls 管理器类
- * @returns {object} 管理器实例
- */
-Game.prototype._createManager = function (name, title, cls) {
-  let dir = this.getDir();
-  var manager = new Manager({
-    name: name,
-    title: title,
-    filename: name + '.json',
-    tpl_dir: `../${name}/`.fullname(__dirname),
-    base_dir: '',
-    dir: `./${name}`.fullname(dir)
-  }, this, this[name], cls);
-  this.manager[name] = manager;
-  return manager;
-};
-
-/**
- * 加载资源
- */
-Game.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')
-  ]);
-};
-
-/**
- * 初始化资源
- */
-Game.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.manager.logic.runAll('init', this.getLogger());
-  await this.manager.system.runAll('init', this, this.getEventer(), this.getLogger());
-  await this.manager.scene.runAll('init', this, this.getEventer(), this.getLogger());
-};
-
-/**
- * 启动核心
- */
-Game.prototype._startCore = async function () {
-  // 初始化资源
-  await this._initSources();
-  // 启动资源
-  await this._startSources();
-};
-
-/**
- * 启动资源
- */
-Game.prototype._startSources = async function () {
-  // 并行启动游戏系统和场景
-  await Promise.all([
-    // 启动游戏系统
-    this.manager.system.runAll('start'),
-    // 启动游戏场景
-    this.manager.scene.runAll('start')
-  ]);
-};
-
-module.exports = {
-  Game
-};

package/core/handler/config.tpl.json

@@ -1,22 +0,0 @@
-{
-	// 名称
-	"name": "${name}",
-	// 标题
-	"title": "${title || '示例处理器'}",
-	// 描述
-	"description": "${description || '介绍该处理器有什么用'}",
-	// 主文件
-	"main": "${main || 'index.js'}",
-	// 作用域，决定加载到什么区域
-	"scope": "${scope || 'server'}",
-	// 状态 0：禁用 1：启用
-	"state": 1,
-	// 排序，越小越靠前
-	"sort": 100,
-	// 依赖的领域服务
-	"services": [],
-	// 依赖的仓储
-	"stores": [],
-	// 依赖的富血模型
-	"models": []
-}

package/core/handler/index.js

@@ -1,181 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-
-/**
- * 应用处理器基类（应用服务层）
- * 负责处理请求，调用服务层，返回响应
- */
-class Handler extends Drive {
-  static config = {
-    name: 'default',
-    title: '处理器',
-    // 依赖的服务
-    services: [],
-    // 依赖的仓储
-    stores: [],
-    // 依赖的富血模型
-    models: [],
-    timeout: 30000,
-    perf_log: false, // 是否记录性能日志
-  };
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父对象
-   */
-  constructor(config, parent) {
-    super({ ...Handler.config, ...config || {} }, parent);
-
-    // 仓储管理集合
-    this._store = {};
-    // 服务管理集合
-    this._service = {};
-    // 富血模型管理集合
-    this._model = {};
-  }
-}
-
-/**
- * 预设
- */
-Handler.prototype._preset = function () {
-  /** === 基础设施 === */
-  // 文件管理器
-  this._filer = null;
-
-  // 消息推送器
-  this._sender = null;
-  // 广播器
-  this._pusher = null;
-  // 通知器
-  this._notifier = null;
-};
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Handler.prototype.getTplDir = function () {
-  return __dirname;
-};
-
-/**
- * 初始化依赖检查
- */
-Handler.prototype._checkDeps = function () {
-  let {
-    services,
-    stores,
-    models
-  } = this.config;
-
-  for (var i = 0; i < services.length; i++) {
-    var name = services[i];
-    if (!this._service[name]) {
-      this.log('error', `${name}服务(service)未找到`);
-    }
-  }
-
-  for (var i = 0; i < stores.length; i++) {
-    var name = stores[i];
-    if (!this._store[name]) {
-      this.log('error', `${name}仓储(store)未找到`);
-    }
-  }
-
-  for (var i = 0; i < models.length; i++) {
-    var name = models[i];
-    if (!this._model[name]) {
-      this.log('error', `${name}模型(model)未找到`);
-    }
-  }
-};
-
-/**
- * 初始化核心
- * @param {object} app 当前应用
- * @param {object} eventer 事件总线
- * @param {object} logger 日志管理器
- */
-Handler.prototype._initCore = async function (app, eventer, logger) {
-  // 初始化依赖项
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-
-  let {
-    store,
-    service,
-    model
-  } = app;
-  this._store = store;
-  this._service = service;
-  this._model = model;
-
-  // 检查依赖项
-  this._checkDeps();
-};
-
-/**
- * 销毁处理器
- */
-Handler.prototype._destroy = async function () {
-  try {
-    // 清理资源
-    this._store = null;
-    this._service = null;
-    this._model = null;
-    this._db = null;
-    this._cache = null;
-    this._filer = null;
-
-    this._sender = null;
-    this._pusher = null;
-    this._notifier = null;
-
-  } catch (error) {
-    this.log('error', '销毁发生错误:', error);
-  }
-};
-
-/**
- * 请求预处理方法
- * @param {object} req 请求对象
- * @param {object} res 响应对象
- * @returns {Promise<void>}
- */
-Handler.prototype._before = async function (req, res) {
-  this.log('debug', '请求预处理', { req, res });
-};
-
-/**
- * 请求主处理逻辑
- * 核心业务逻辑应该在此方法中实现
- * @param {object} req 请求对象
- * @param {object} res 响应对象
- * @returns {Promise<object>} 处理结果
- */
-Handler.prototype.main = async function (req, res) {
-  this.log('debug', '默认请求处理，子类应重写此方法', { req, res });
-  // 默认实现，子类必须重写
-  throw new Error('main 方法必须被重写');
-};
-
-/**
- * 请求后处理方法
- * @param {object} req 请求对象
- * @param {object} res 响应对象
- * @param {object} result 处理结果
- * @returns {Promise<void>}
- */
-Handler.prototype._after = async function (req, res, result) {
-  this.log('debug', '请求后处理', { req, res, result });
-};
-
-exports.Handler = Handler;

package/core/handler/script.tpl.js

@@ -1,23 +0,0 @@
-/**
- * 处理器（应用层）
- */
-module.exports = {
-  /**
-   * 初始化
-   * @param {object} app 应用实例
-   * @param {object} eventer 事件总线
-   */
-  async _init(app, eventer) {
-    // this.log('debug', `初始化！`);
-    // 可将监听写在这里
-    // eventer.on('');
-  },
-  /**
-   * 主要逻辑
-   * @param {...any} args 逻辑参数
-   */
-  async main(...args) {
-    this.log('debug', `主要逻辑`);
-    // 主要代码写在这
-  }
-};

package/core/logic/config.tpl.json

@@ -1,14 +0,0 @@
-{
-  // 名称
-  "name": "${name}",
-  // 标题
-  "title": "${title || '战斗逻辑'}",
-  // 描述
-  "description": "${description || '定义战斗逻辑'}",
-  // 主文件
-  "main": "${main || 'index.js'}",
-  // 状态 0：禁用 1：启用
-  "state": 1,
-  // 排序，越小越靠前
-  "sort": 100
-}

package/core/logic/index.js

@@ -1,59 +0,0 @@
-const { Drive } = require('mm_machine');
-
-/**
- * 游戏逻辑基类
- * 负责处理游戏业务规则和玩法逻辑
- * 负责初始化游戏逻辑的核心组件，如日志记录器、工厂等
- * 确保在游戏逻辑开始前，所有必要的组件都已初始化并准备就绪
- */
-class Logic extends Drive {
-  static config = {
-    // 逻辑名称
-    name: 'default',
-    // 逻辑标题
-    title: '基础逻辑',
-    // 逻辑描述
-    description: '游戏逻辑基类，负责处理游戏业务规则和玩法逻辑',
-    // 入口脚本
-    script: './index.js',
-    // 状态 0：禁用 1：启用
-    state: 1,
-    // 排序，越小越靠前
-    sort: 0,
-    // 逻辑类型: core|module|system
-    type: 'system',
-    // 依赖的工厂组件
-    factorys: [],
-  };
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父对象
-   */
-  constructor(config, parent) {
-    // 确保正确合并配置并传递给父类构造函数
-    super({ ...Logic.config, ...config || {} }, parent);
-  }
-}
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Logic.prototype.getTplDir = function() {
-  return __dirname;
-};
-
-/**
- * 初始化核心
- * @param {object} logger 日志记录器实例
- * @returns {Promise<void>}
- */
-Logic.prototype._initCore = async function (logger) {
-  // 初始化依赖项
-  if (logger) {
-    this.setLogger(logger);
-  }
-};
-
-exports.Logic = Logic;