mm_os 3.3.0 → 4.0.0

package/core/game/entity_admin.js

@@ -0,0 +1,230 @@
+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

@@ -0,0 +1,186 @@
+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();
+  // 初始化资源
+  await this._initSources();
+};
+
+/**
+ * 初始化管理器集合
+ * @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._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

@@ -0,0 +1,22 @@
+{
+	// 名称
+	"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

@@ -0,0 +1,181 @@
+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

@@ -0,0 +1,23 @@
+/**
+ * 处理器（应用层）
+ */
+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

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

package/core/logic/index.js

@@ -0,0 +1,59 @@
+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;