mm_os/core/game/entity_admin.js

MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。

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
};