mm_os 4.3.6 → 5.0.0

package/core/scene/index.js

@@ -1,467 +0,0 @@
-const {
-  Drive
-} = require('mm_machine');
-
-/**
- * 场景基类
- * 负责管理游戏场景中的实体和图层，处理场景生命周期
- * 场景是Entity实例的容器，管理实体的生命周期
- */
-class Scene extends Drive {
-  static config = {
-    // 场景名称
-    name: 'default',
-    // 场景描述
-    desc: '',
-    // 场景优先级
-    priority: 0,
-    // 是否激活场景
-    active: true
-  };
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父场景对象
-   */
-  constructor(config, parent) {
-    super({ ...Scene.config, ...config || {} }, parent);
-    // 系统实例集合，主要调用场景系统SceneSystem
-    this._system = {};
-    // 图层映射集合
-    this._layers = {};
-    // 地图实例集合
-    this.map = {};
-    // /**
-    //  * 地图集合
-    //  * @type {object} 地图对象
-    //  */
-    // this.maps = new Map();
-    // // 实体集合
-    // this._entities = new Map();
-  }
-}
-
-/**
- * 预设
- */
-Scene.prototype._preset = function () {
-  // 是否激活场景
-  this.active = this.config.active;
-};
-
-/**
- * 获取模板目录
- * @returns {string} 模板目录
- */
-Scene.prototype.getTplDir = function () {
-  return __dirname;
-};
-
-/**
- * 初始化核心
- * @override
- * @param {object} system 系统对象
- * @param {object} eventer 事件对象
- * @param {object} logger 日志对象
- * @returns {Promise<void>}
- */
-Scene.prototype._initCore = async function (system, eventer, logger) {
-  // 初始化依赖项
-  if (logger) {
-    this.setLogger(logger);
-  }
-  if (eventer) {
-    this.getEventer = function () {
-      return eventer;
-    };
-  }
-  if (system) {
-    this._system = system;
-  }
-
-  // 初始化场景
-  await this._loadSources();
-  // 初始化地图
-  await this._initMap();
-  // 初始化实体
-  await this._initEntities();
-
-  // 触发场景加载事件
-  this.emitEvent('scene_load', {
-    scene_id: this.scene_id,
-    scene_name: this.config.name,
-    timestamp: Date.now()
-  });
-};
-
-/**
- * 初始化地图
- * @private
- */
-Scene.prototype._initMap = async function () {
-  // 子类应重写此方法初始化地图
-};
-
-/**
- * 加载场景资源
- * @private
- * @returns {Promise<void>}
- */
-Scene.prototype._loadSources = async function () {
-  // 子类应重写此方法加载场景所需资源
-};
-
-/**
- * 添加实体到场景
- * @param {object} entity 实体对象
- * @returns {boolean} 添加是否成功
- */
-Scene.prototype.addEntity = function (entity) {
-  // 参数校验
-  if (!entity || typeof entity !== 'object') {
-    this.log('error', '实体必须是非空对象');
-    return false;
-  }
-
-  // 检查实体是否已存在
-  if (this._entities.has(entity.entity_id)) {
-    return true; // 已存在，返回成功
-  }
-
-  // 添加实体
-  this._entities.set(entity.entity_id, entity);
-
-  // 设置实体的场景引用
-  if (entity.setScene && typeof entity.setScene === 'function') {
-    entity.setScene(this);
-  }
-
-  this.log('info', `实体 [${entity.entity_id}] 添加到场景`);
-
-  return true;
-};
-
-/**
- * 从场景移除实体
- * @param {object|string} entity 实体对象或实体ID
- * @returns {boolean} 移除是否成功
- */
-Scene.prototype.delEntity = function (entity) {
-  // 参数校验
-  if (!entity) {
-    this.log('error', '实体参数不能为空');
-    return false;
-  }
-
-  // 如果是ID，直接从Map中移除
-  if (typeof entity === 'string') {
-    if (!this._entities.has(entity)) {
-      return false; // 实体不存在
-    }
-    this._entities.delete(entity);
-    this.log('info', `实体 [${entity}] 从场景移除`);
-    return true;
-  }
-
-  // 如果是对象，使用实体ID移除
-  if (!entity.entity_id || !this._entities.has(entity.entity_id)) {
-    return false; // 实体不存在于场景中
-  }
-
-  this._entities.delete(entity.entity_id);
-
-  this.log('info', `实体 [${entity.entity_id}] 从场景移除`);
-
-  return true;
-};
-
-/**
- * 根据ID或属性查找实体
- * @param {string | number | object} query 查询条件
- * @returns {object|null} 找到的实体或null
- */
-Scene.prototype.findEntity = function (query) {
-  if (!query) {
-    return null;
-  }
-
-  if (typeof query === 'string' || typeof query === 'number') {
-    return this._findById(query);
-  }
-
-  if (query.prototype && typeof query === 'function') {
-    return this._findByType(query);
-  }
-
-  if (typeof query === 'object') {
-    return this._findByProps(query);
-  }
-
-  return null;
-};
-
-/**
- * 根据ID查找实体
- * @param {string | number} id 实体ID
- * @returns {object|null} 找到的实体或null
- */
-Scene.prototype._findById = function (id) {
-  return this._entities.get(id) || null;
-};
-
-/**
- * 根据构造函数类型查找实体
- * @param {Function} type 构造函数
- * @returns {object|null} 找到的实体或null
- */
-Scene.prototype._findByType = function (type) {
-  for (let entity of this._entities.values()) {
-    if (entity instanceof type) {
-      return entity;
-    }
-  }
-  return null;
-};
-
-/**
- * 根据属性对象查找实体
- * @param {object} props 属性对象
- * @returns {object|null} 找到的实体或null
- */
-Scene.prototype._findByProps = function (props) {
-  for (let entity of this._entities.values()) {
-    if (this._matchProps(entity, props)) {
-      return entity;
-    }
-  }
-  return null;
-};
-
-/**
- * 检查实体属性是否匹配
- * @param {object} entity 实体
- * @param {object} props 属性对象
- * @returns {boolean} 是否匹配
- */
-Scene.prototype._matchProps = function (entity, props) {
-  for (let key in props) {
-    if (entity[key] !== props[key]) {
-      return false;
-    }
-  }
-  return true;
-};
-
-/**
- * 查找符合条件的所有实体
- * @param {object} query 查询条件
- * @returns {Array} 符合条件的实体数组
- */
-Scene.prototype.findEntities = function (query = {}) {
-  if (!query || typeof query !== 'object') {
-    return [...this._entities.values()];
-  }
-
-  let result = [];
-  for (let entity of this._entities.values()) {
-    let match = true;
-    for (let key in query) {
-      if (entity[key] !== query[key]) {
-        match = false;
-        break;
-      }
-    }
-    if (match) {
-      result.push(entity);
-    }
-  }
-  return result;
-};
-
-/**
- * 添加图层
- * @param {string} name 图层名称
- * @param {object} layer 图层对象
- * @returns {boolean} 添加是否成功
- */
-Scene.prototype.addLayer = function (name, layer) {
-  // 参数校验
-  if (!name || typeof name !== 'string') {
-    this.log('error', '图层名称必须是非空字符串');
-    return false;
-  }
-
-  if (!layer || typeof layer !== 'object') {
-    this.log('error', '图层对象必须是非空对象');
-    return false;
-  }
-
-  // 添加图层
-  this._layers[name] = layer;
-
-  return true;
-};
-
-/**
- * 获取图层
- * @param {string} name 图层名称
- * @returns {object | null} 图层对象或null
- */
-Scene.prototype.getLayer = function (name) {
-  if (!name || typeof name !== 'string') {
-    this.log('error', '图层名称必须是非空字符串');
-    return null;
-  }
-
-  return this._layers[name] || null;
-};
-
-/**
- * 更新场景
- * @param {number} delta 时间间隔（毫秒）
- */
-Scene.prototype.set = function (delta) {
-  // 如果场景不活跃，不更新
-  if (!this.active) {
-    return;
-  }
-
-  // 更新所有实体
-  for (let entity of this._entities.values()) {
-    try {
-      if (entity.update && typeof entity.update === 'function') {
-        entity.update(delta);
-      }
-    } catch (error) {
-      this.log('error', '更新实体时出错:', error);
-      // 可以选择移除出错的实体
-      // this.delEntity(entity);
-    }
-  }
-};
-
-/**
- * 渲染场景
- */
-Scene.prototype.render = function () {
-  // 如果场景不活跃，不渲染
-  if (!this.active) {
-    return;
-  }
-
-  // 渲染所有图层
-  Object.values(this._layers).forEach(layer => {
-    try {
-      if (layer.render && typeof layer.render === 'function') {
-        layer.render();
-      }
-    } catch (error) {
-      this.log('error', '渲染图层时出错:', error);
-    }
-  });
-};
-
-/**
- * 清理场景资源
- * @override
- */
-Scene.prototype._destroy = function () {
-  try {
-    // 触发场景卸载事件
-    this.emitEvent('scene_unload', {
-      scene_id: this.scene_id,
-      scene_name: this.config.name,
-      timestamp: Date.now()
-    });
-
-    // 清理所有实体
-    for (let entity of this.map._entities.values()) {
-      try {
-        if (entity.destroy && typeof entity.destroy === 'function') {
-          entity.destroy();
-        }
-      } catch (error) {
-        this.log('error', '销毁实体时出错:', error);
-      }
-    }
-
-    // 清空引用
-    this.map._entities = null;
-  } catch (error) {
-    this.log('error', '场景销毁失败:', error);
-  }
-};
-
-/**
- * 实体进入场景
- * @param {object} entity 实体对象
- * @returns {boolean} 是否成功进入
- */
-Scene.prototype.enter = async function (entity) {
-  // 参数校验
-  if (!entity || typeof entity !== 'object') {
-    throw new TypeError('实体对象必须是非空对象');
-  }
-
-  // 添加实体到场景
-  this._entities.set(entity.entity_id, entity);
-
-  // 触发实体进入场景事件（如果事件总线存在）
-  this.emitEvent('entity_enter_scene', {
-    scene_id: this.scene_id,
-    scene_name: this.config.name,
-    entity_id: entity.entity_id,
-    timestamp: Date.now()
-  });
-
-  return true;
-};
-
-/**
- * 实体离开场景
- * @param {object} entity 实体对象
- * @returns {boolean} 是否成功离开
- */
-Scene.prototype.leave = async function (entity) {
-  // 参数校验
-  if (!entity || typeof entity !== 'object') {
-    throw new TypeError('实体对象必须是非空对象');
-  }
-
-  // 从场景移除实体
-  if (!entity.entity_id || !this._entities.has(entity.entity_id)) {
-    throw new Error('实体不在场景中');
-  }
-  this._entities.delete(entity.entity_id);
-
-  // 触发实体离开场景事件（如果事件总线存在）
-  this.emitEvent('entity_leave_scene', {
-    scene_id: this.scene_id,
-    scene_name: this.config.name,
-    entity_id: entity.entity_id,
-    timestamp: Date.now()
-  });
-  return true;
-};
-
-/**
- * 更新场景
- * @param {number} delta 时间间隔（毫秒）
- */
-Scene.prototype.update = function (delta) {
-  // 如果场景不活跃，不更新
-  if (!this.isRunning()) {
-    return;
-  }
-
-  // 触发场景更新事件
-  this.emitEvent('scene_update', {
-    scene_id: this.scene_id,
-    scene_name: this.config.name,
-    delta: delta,
-    timestamp: Date.now()
-  });
-};
-
-// 导出模块
-exports.Scene = Scene;