@codehz/ecs 0.0.0

package/index.js

@@ -0,0 +1,756 @@
+// src/entity.ts
+var INVALID_COMPONENT_ID = 0;
+var COMPONENT_ID_MAX = 1023;
+var ENTITY_ID_START = 1024;
+var RELATION_SHIFT = 2 ** 42;
+var WILDCARD_TARGET_ID = 0;
+function createComponentId(id) {
+  if (id < 1 || id > COMPONENT_ID_MAX) {
+    throw new Error(`Component ID must be between 1 and ${COMPONENT_ID_MAX}`);
+  }
+  return id;
+}
+function createEntityId(id) {
+  if (id < ENTITY_ID_START) {
+    throw new Error(`Entity ID must be ${ENTITY_ID_START} or greater`);
+  }
+  return id;
+}
+function createRelationId(componentId, targetId) {
+  if (!isComponentId(componentId)) {
+    throw new Error("First argument must be a valid component ID");
+  }
+  let actualTargetId;
+  if (targetId === "*") {
+    actualTargetId = WILDCARD_TARGET_ID;
+  } else {
+    if (!isEntityId(targetId) && !isComponentId(targetId)) {
+      throw new Error("Second argument must be a valid entity ID, component ID, or '*'");
+    }
+    actualTargetId = targetId;
+  }
+  return -(componentId * RELATION_SHIFT + actualTargetId);
+}
+function isComponentId(id) {
+  return id >= 1 && id <= COMPONENT_ID_MAX;
+}
+function isEntityId(id) {
+  return id >= ENTITY_ID_START;
+}
+function isRelationId(id) {
+  return id < 0;
+}
+function decodeRelationId(relationId) {
+  if (!isRelationId(relationId)) {
+    throw new Error("ID is not a relation ID");
+  }
+  const absId = -relationId;
+  const componentId = Math.floor(absId / RELATION_SHIFT);
+  const targetId = absId % RELATION_SHIFT;
+  if (targetId === WILDCARD_TARGET_ID) {
+    return { componentId, targetId, type: "wildcard" };
+  } else if (isEntityId(targetId)) {
+    return { componentId, targetId, type: "entity" };
+  } else if (isComponentId(targetId)) {
+    return { componentId, targetId, type: "component" };
+  } else {
+    throw new Error("Invalid target ID in relation");
+  }
+}
+function getIdType(id) {
+  if (isComponentId(id))
+    return "component";
+  if (isEntityId(id))
+    return "entity";
+  if (isRelationId(id)) {
+    try {
+      const decoded = decodeRelationId(id);
+      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
+        return "invalid";
+      }
+      switch (decoded.type) {
+        case "entity":
+          return "entity-relation";
+        case "component":
+          return "component-relation";
+        case "wildcard":
+          return "wildcard-relation";
+      }
+    } catch (error) {
+      return "invalid";
+    }
+  }
+  return "invalid";
+}
+function getDetailedIdType(id) {
+  if (isComponentId(id)) {
+    return { type: "component" };
+  }
+  if (isEntityId(id)) {
+    return { type: "entity" };
+  }
+  if (isRelationId(id)) {
+    try {
+      const decoded = decodeRelationId(id);
+      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
+        return { type: "invalid" };
+      }
+      let type;
+      switch (decoded.type) {
+        case "entity":
+          type = "entity-relation";
+          break;
+        case "component":
+          type = "component-relation";
+          break;
+        case "wildcard":
+          type = "wildcard-relation";
+          break;
+      }
+      return {
+        type,
+        componentId: decoded.componentId,
+        targetId: decoded.targetId
+      };
+    } catch (error) {
+      return { type: "invalid" };
+    }
+  }
+  return { type: "invalid" };
+}
+function inspectEntityId(id) {
+  if (id === INVALID_COMPONENT_ID) {
+    return "Invalid Component ID (0)";
+  }
+  if (isComponentId(id)) {
+    return `Component ID (${id})`;
+  }
+  if (isEntityId(id)) {
+    return `Entity ID (${id})`;
+  }
+  if (isRelationId(id)) {
+    try {
+      const decoded = decodeRelationId(id);
+      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
+        return `Invalid Relation ID (${id})`;
+      }
+      const componentStr = `Component ID (${decoded.componentId})`;
+      const targetStr = decoded.type === "entity" ? `Entity ID (${decoded.targetId})` : decoded.type === "component" ? `Component ID (${decoded.targetId})` : "Wildcard (*)";
+      return `Relation ID: ${componentStr} -> ${targetStr}`;
+    } catch (error) {
+      return `Invalid Relation ID (${id})`;
+    }
+  }
+  return `Unknown ID (${id})`;
+}
+
+class EntityIdManager {
+  nextId = ENTITY_ID_START;
+  freelist = new Set;
+  allocate() {
+    if (this.freelist.size > 0) {
+      const id = this.freelist.values().next().value;
+      this.freelist.delete(id);
+      return id;
+    } else {
+      const id = this.nextId;
+      this.nextId++;
+      if (this.nextId >= Number.MAX_SAFE_INTEGER) {
+        throw new Error("Entity ID overflow: reached maximum safe integer");
+      }
+      return id;
+    }
+  }
+  deallocate(id) {
+    if (!isEntityId(id)) {
+      throw new Error("Can only deallocate valid entity IDs");
+    }
+    if (id >= this.nextId) {
+      throw new Error("Cannot deallocate an ID that was never allocated");
+    }
+    this.freelist.add(id);
+  }
+  getFreelistSize() {
+    return this.freelist.size;
+  }
+  getNextId() {
+    return this.nextId;
+  }
+}
+
+class ComponentIdManager {
+  nextId = 1;
+  allocate() {
+    if (this.nextId > COMPONENT_ID_MAX) {
+      throw new Error(`Component ID overflow: maximum ${COMPONENT_ID_MAX} components allowed`);
+    }
+    const id = this.nextId;
+    this.nextId++;
+    return id;
+  }
+  getNextId() {
+    return this.nextId;
+  }
+  hasAvailableIds() {
+    return this.nextId <= COMPONENT_ID_MAX;
+  }
+}
+// src/utils.ts
+function getOrComputeCache(cache, key, compute) {
+  let value = cache.get(key);
+  if (value === undefined) {
+    value = compute();
+    cache.set(key, value);
+  }
+  return value;
+}
+function getOrCreateWithSideEffect(cache, key, create) {
+  let value = cache.get(key);
+  if (value === undefined) {
+    value = create();
+    cache.set(key, value);
+  }
+  return value;
+}
+
+// src/archetype.ts
+class Archetype {
+  componentTypes;
+  entities = [];
+  componentData = new Map;
+  entityToIndex = new Map;
+  componentDataSourcesCache = new Map;
+  constructor(componentTypes) {
+    this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+    for (const componentType of this.componentTypes) {
+      this.componentData.set(componentType, []);
+    }
+  }
+  get size() {
+    return this.entities.length;
+  }
+  matches(componentTypes) {
+    if (this.componentTypes.length !== componentTypes.length) {
+      return false;
+    }
+    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+    return this.componentTypes.every((type, index) => type === sortedTypes[index]);
+  }
+  addEntity(entityId, componentData) {
+    if (this.entityToIndex.has(entityId)) {
+      throw new Error(`Entity ${entityId} is already in this archetype`);
+    }
+    const index = this.entities.length;
+    this.entities.push(entityId);
+    this.entityToIndex.set(entityId, index);
+    for (const componentType of this.componentTypes) {
+      const data = componentData.get(componentType);
+      if (data === undefined) {
+        throw new Error(`Missing component data for type ${componentType}`);
+      }
+      this.componentData.get(componentType).push(data);
+    }
+  }
+  removeEntity(entityId) {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      return;
+    }
+    this.entities.splice(index, 1);
+    this.entityToIndex.delete(entityId);
+    const removedData = new Map;
+    for (const componentType of this.componentTypes) {
+      const dataArray = this.componentData.get(componentType);
+      removedData.set(componentType, dataArray[index]);
+      dataArray.splice(index, 1);
+    }
+    for (let i = index;i < this.entities.length; i++) {
+      this.entityToIndex.set(this.entities[i], i);
+    }
+    return removedData;
+  }
+  hasEntity(entityId) {
+    return this.entityToIndex.has(entityId);
+  }
+  getComponent(entityId, componentType) {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      return;
+    }
+    return this.componentData.get(componentType)?.[index];
+  }
+  setComponent(entityId, componentType, data) {
+    const index = this.entityToIndex.get(entityId);
+    if (index === undefined) {
+      throw new Error(`Entity ${entityId} is not in this archetype`);
+    }
+    const dataArray = this.componentData.get(componentType);
+    if (!dataArray) {
+      throw new Error(`Component type ${componentType} is not in this archetype`);
+    }
+    dataArray[index] = data;
+  }
+  getEntities() {
+    return [...this.entities];
+  }
+  getComponentData(componentType) {
+    return [...this.componentData.get(componentType) || []];
+  }
+  getEntitiesWithComponents(componentTypes) {
+    const result = [];
+    this.forEachWithComponents(componentTypes, (entity, ...components) => {
+      result.push({ entity, components });
+    });
+    return result;
+  }
+  forEachWithComponents(componentTypes, callback) {
+    const cacheKey = componentTypes.map((id) => id.toString()).join(",");
+    const componentDataSources = getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => {
+      return componentTypes.map((compType) => {
+        if (getIdType(compType) === "wildcard-relation") {
+          const decoded = decodeRelationId(compType);
+          const componentId = decoded.componentId;
+          const matchingRelations = this.componentTypes.filter((ct) => {
+            const ctType = getIdType(ct);
+            if (ctType !== "entity-relation" && ctType !== "component-relation")
+              return false;
+            const decodedCt = decodeRelationId(ct);
+            return decodedCt.componentId === componentId;
+          });
+          return matchingRelations;
+        } else {
+          return this.componentData.get(compType);
+        }
+      });
+    });
+    for (let entityIndex = 0;entityIndex < this.entities.length; entityIndex++) {
+      const entity = this.entities[entityIndex];
+      const components = componentDataSources.map((dataSource, i) => {
+        const compType = componentTypes[i];
+        if (getIdType(compType) === "wildcard-relation") {
+          const matchingRelations = dataSource;
+          const relations = [];
+          for (const relType of matchingRelations) {
+            const dataArray = this.componentData.get(relType);
+            if (dataArray && dataArray[entityIndex] !== undefined) {
+              const decodedRel = decodeRelationId(relType);
+              relations.push([decodedRel.targetId, dataArray[entityIndex]]);
+            }
+          }
+          return relations;
+        } else {
+          const dataArray = dataSource;
+          return dataArray ? dataArray[entityIndex] : undefined;
+        }
+      });
+      callback(entity, ...components);
+    }
+  }
+  forEach(callback) {
+    for (let i = 0;i < this.entities.length; i++) {
+      const components = new Map;
+      for (const componentType of this.componentTypes) {
+        components.set(componentType, this.componentData.get(componentType)[i]);
+      }
+      callback(this.entities[i], components);
+    }
+  }
+}
+
+// src/command-buffer.ts
+class CommandBuffer {
+  commands = [];
+  executeEntityCommands;
+  constructor(executeEntityCommands) {
+    this.executeEntityCommands = executeEntityCommands;
+  }
+  addComponent(entityId, componentType, component) {
+    this.commands.push({ type: "addComponent", entityId, componentType, component });
+  }
+  removeComponent(entityId, componentType) {
+    this.commands.push({ type: "removeComponent", entityId, componentType });
+  }
+  destroyEntity(entityId) {
+    this.commands.push({ type: "destroyEntity", entityId });
+  }
+  execute() {
+    const entityCommands = new Map;
+    for (const cmd of this.commands) {
+      if (!entityCommands.has(cmd.entityId)) {
+        entityCommands.set(cmd.entityId, []);
+      }
+      entityCommands.get(cmd.entityId).push(cmd);
+    }
+    for (const [entityId, commands] of entityCommands) {
+      this.executeEntityCommands(entityId, commands);
+    }
+    this.commands = [];
+  }
+  getCommands() {
+    return [...this.commands];
+  }
+  clear() {
+    this.commands = [];
+  }
+}
+
+// src/query-filter.ts
+function matchesComponentTypes(archetype, componentTypes) {
+  return componentTypes.every((type) => {
+    const detailedType = getDetailedIdType(type);
+    if (detailedType.type === "wildcard-relation") {
+      return archetype.componentTypes.includes(detailedType.componentId);
+    } else {
+      return archetype.componentTypes.includes(type);
+    }
+  });
+}
+function matchesFilter(archetype, filter) {
+  const negativeTypes = filter.negativeComponentTypes || [];
+  return negativeTypes.every((type) => {
+    const detailedType = getDetailedIdType(type);
+    if (detailedType.type === "wildcard-relation") {
+      return !archetype.componentTypes.some((archetypeType) => {
+        if (!isRelationId(archetypeType))
+          return false;
+        const decoded = decodeRelationId(archetypeType);
+        return decoded.componentId === detailedType.componentId;
+      });
+    } else {
+      return !archetype.componentTypes.includes(type);
+    }
+  });
+}
+
+// src/query.ts
+class Query {
+  world;
+  componentTypes;
+  filter;
+  cachedArchetypes = [];
+  isDisposed = false;
+  constructor(world, componentTypes, filter = {}) {
+    this.world = world;
+    this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+    this.filter = filter;
+    this.updateCache();
+    world.registerQuery(this);
+  }
+  getEntities() {
+    if (this.isDisposed) {
+      throw new Error("Query has been disposed");
+    }
+    const result = [];
+    for (const archetype of this.cachedArchetypes) {
+      result.push(...archetype.getEntities());
+    }
+    return result;
+  }
+  getEntitiesWithComponents(componentTypes) {
+    if (this.isDisposed) {
+      throw new Error("Query has been disposed");
+    }
+    const result = [];
+    for (const archetype of this.cachedArchetypes) {
+      const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
+      result.push(...entitiesWithData);
+    }
+    return result;
+  }
+  forEach(componentTypes, callback) {
+    if (this.isDisposed) {
+      throw new Error("Query has been disposed");
+    }
+    for (const archetype of this.cachedArchetypes) {
+      archetype.forEachWithComponents(componentTypes, callback);
+    }
+  }
+  getComponentData(componentType) {
+    if (this.isDisposed) {
+      throw new Error("Query has been disposed");
+    }
+    const result = [];
+    for (const archetype of this.cachedArchetypes) {
+      result.push(...archetype.getComponentData(componentType));
+    }
+    return result;
+  }
+  updateCache() {
+    if (this.isDisposed)
+      return;
+    this.cachedArchetypes = this.world.getMatchingArchetypes(this.componentTypes).filter((archetype) => matchesFilter(archetype, this.filter));
+  }
+  checkNewArchetype(archetype) {
+    if (this.isDisposed)
+      return;
+    if (matchesComponentTypes(archetype, this.componentTypes) && matchesFilter(archetype, this.filter) && !this.cachedArchetypes.includes(archetype)) {
+      this.cachedArchetypes.push(archetype);
+    }
+  }
+  dispose() {
+    if (!this.isDisposed) {
+      this.world.unregisterQuery(this);
+      this.cachedArchetypes = [];
+      this.isDisposed = true;
+    }
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  get disposed() {
+    return this.isDisposed;
+  }
+}
+
+// src/world.ts
+class World {
+  entityIdManager = new EntityIdManager;
+  archetypes = [];
+  archetypeMap = new Map;
+  entityToArchetype = new Map;
+  systems = [];
+  queries = [];
+  commandBuffer;
+  componentToArchetypes = new Map;
+  constructor() {
+    this.commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
+  }
+  getComponentTypesHash(componentTypes) {
+    return componentTypes.join(",");
+  }
+  createEntity() {
+    const entityId = this.entityIdManager.allocate();
+    let emptyArchetype = this.getOrCreateArchetype([]);
+    emptyArchetype.addEntity(entityId, new Map);
+    this.entityToArchetype.set(entityId, emptyArchetype);
+    return entityId;
+  }
+  _destroyEntity(entityId) {
+    const archetype = this.entityToArchetype.get(entityId);
+    if (!archetype) {
+      return;
+    }
+    archetype.removeEntity(entityId);
+    this.entityToArchetype.delete(entityId);
+    this.entityIdManager.deallocate(entityId);
+  }
+  hasEntity(entityId) {
+    return this.entityToArchetype.has(entityId);
+  }
+  addComponent(entityId, componentType, component) {
+    if (!this.hasEntity(entityId)) {
+      throw new Error(`Entity ${entityId} does not exist`);
+    }
+    this.commandBuffer.addComponent(entityId, componentType, component);
+  }
+  removeComponent(entityId, componentType) {
+    if (!this.hasEntity(entityId)) {
+      throw new Error(`Entity ${entityId} does not exist`);
+    }
+    this.commandBuffer.removeComponent(entityId, componentType);
+  }
+  destroyEntity(entityId) {
+    this.commandBuffer.destroyEntity(entityId);
+  }
+  hasComponent(entityId, componentType) {
+    const archetype = this.entityToArchetype.get(entityId);
+    return archetype ? archetype.componentTypes.includes(componentType) : false;
+  }
+  getComponent(entityId, componentType) {
+    const archetype = this.entityToArchetype.get(entityId);
+    return archetype ? archetype.getComponent(entityId, componentType) : undefined;
+  }
+  registerSystem(system) {
+    this.systems.push(system);
+  }
+  unregisterSystem(system) {
+    const index = this.systems.indexOf(system);
+    if (index !== -1) {
+      this.systems.splice(index, 1);
+    }
+  }
+  update(...params) {
+    for (const system of this.systems) {
+      system.update(this, ...params);
+    }
+    this.commandBuffer.execute();
+  }
+  flushCommands() {
+    this.commandBuffer.execute();
+  }
+  createQuery(componentTypes, filter = {}) {
+    return new Query(this, componentTypes, filter);
+  }
+  registerQuery(query) {
+    this.queries.push(query);
+  }
+  unregisterQuery(query) {
+    const index = this.queries.indexOf(query);
+    if (index !== -1) {
+      this.queries.splice(index, 1);
+    }
+  }
+  getMatchingArchetypes(componentTypes) {
+    if (componentTypes.length === 0) {
+      return [...this.archetypes];
+    }
+    const regularComponents = [];
+    const wildcardRelations = [];
+    for (const type of componentTypes) {
+      const detailedType = getDetailedIdType(type);
+      if (detailedType.type === "wildcard-relation") {
+        wildcardRelations.push({
+          componentId: detailedType.componentId,
+          relationId: type
+        });
+      } else {
+        regularComponents.push(type);
+      }
+    }
+    let matchingArchetypes = [];
+    if (regularComponents.length > 0) {
+      const sortedRegularTypes = [...regularComponents].sort((a, b) => a - b);
+      if (sortedRegularTypes.length === 1) {
+        const componentType = sortedRegularTypes[0];
+        matchingArchetypes = this.componentToArchetypes.get(componentType) || [];
+      } else {
+        const archetypeLists = sortedRegularTypes.map((type) => this.componentToArchetypes.get(type) || []);
+        const firstList = archetypeLists[0] || [];
+        const intersection = new Set;
+        for (const archetype of firstList) {
+          let hasAllComponents = true;
+          for (let i = 1;i < archetypeLists.length; i++) {
+            const otherList = archetypeLists[i];
+            if (!otherList.includes(archetype)) {
+              hasAllComponents = false;
+              break;
+            }
+          }
+          if (hasAllComponents) {
+            intersection.add(archetype);
+          }
+        }
+        matchingArchetypes = Array.from(intersection);
+      }
+    } else {
+      matchingArchetypes = [...this.archetypes];
+    }
+    for (const wildcard of wildcardRelations) {
+      const componentArchetypes = this.componentToArchetypes.get(wildcard.componentId) || [];
+      matchingArchetypes = matchingArchetypes.filter((archetype) => componentArchetypes.includes(archetype));
+    }
+    return matchingArchetypes;
+  }
+  queryEntities(componentTypes, includeComponents) {
+    const matchingArchetypes = this.getMatchingArchetypes(componentTypes);
+    if (includeComponents) {
+      const result = [];
+      for (const archetype of matchingArchetypes) {
+        const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
+        result.push(...entitiesWithData);
+      }
+      return result;
+    } else {
+      const result = [];
+      for (const archetype of matchingArchetypes) {
+        result.push(...archetype.getEntities());
+      }
+      return result;
+    }
+  }
+  executeEntityCommands(entityId, commands) {
+    const hasDestroy = commands.some((cmd) => cmd.type === "destroyEntity");
+    if (hasDestroy) {
+      this._destroyEntity(entityId);
+      return;
+    }
+    const currentArchetype = this.entityToArchetype.get(entityId);
+    if (!currentArchetype) {
+      return;
+    }
+    const currentComponents = new Map;
+    for (const componentType of currentArchetype.componentTypes) {
+      const data = currentArchetype.getComponent(entityId, componentType);
+      if (data !== undefined) {
+        currentComponents.set(componentType, data);
+      }
+    }
+    const adds = new Map;
+    const removes = new Set;
+    for (const cmd of commands) {
+      switch (cmd.type) {
+        case "addComponent":
+          if (cmd.componentType && cmd.component !== undefined) {
+            adds.set(cmd.componentType, cmd.component);
+            removes.delete(cmd.componentType);
+          }
+          break;
+        case "removeComponent":
+          if (cmd.componentType) {
+            removes.add(cmd.componentType);
+            adds.delete(cmd.componentType);
+          }
+          break;
+      }
+    }
+    const finalComponents = new Map(currentComponents);
+    for (const componentType of removes) {
+      finalComponents.delete(componentType);
+    }
+    for (const [componentType, component] of adds) {
+      finalComponents.set(componentType, component);
+    }
+    const finalComponentTypes = Array.from(finalComponents.keys()).sort((a, b) => a - b);
+    const currentComponentTypes = currentArchetype.componentTypes.sort((a, b) => a - b);
+    const needsArchetypeChange = finalComponentTypes.length !== currentComponentTypes.length || !finalComponentTypes.every((type, index) => type === currentComponentTypes[index]);
+    if (needsArchetypeChange) {
+      const newArchetype = this.getOrCreateArchetype(finalComponentTypes);
+      currentArchetype.removeEntity(entityId);
+      newArchetype.addEntity(entityId, finalComponents);
+      this.entityToArchetype.set(entityId, newArchetype);
+    } else {
+      for (const [componentType, component] of adds) {
+        currentArchetype.setComponent(entityId, componentType, component);
+      }
+    }
+  }
+  getOrCreateArchetype(componentTypes) {
+    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+    const hashKey = this.getComponentTypesHash(sortedTypes);
+    return getOrCreateWithSideEffect(this.archetypeMap, hashKey, () => {
+      const newArchetype = new Archetype(sortedTypes);
+      this.archetypes.push(newArchetype);
+      for (const componentType of sortedTypes) {
+        const archetypes = this.componentToArchetypes.get(componentType) || [];
+        archetypes.push(newArchetype);
+        this.componentToArchetypes.set(componentType, archetypes);
+      }
+      for (const query of this.queries) {
+        query.checkNewArchetype(newArchetype);
+      }
+      return newArchetype;
+    });
+  }
+}
+export {
+  isRelationId,
+  isEntityId,
+  isComponentId,
+  inspectEntityId,
+  getIdType,
+  getDetailedIdType,
+  decodeRelationId,
+  createRelationId,
+  createEntityId,
+  createComponentId,
+  World,
+  WILDCARD_TARGET_ID,
+  RELATION_SHIFT,
+  Query,
+  INVALID_COMPONENT_ID,
+  EntityIdManager,
+  ENTITY_ID_START,
+  ComponentIdManager,
+  COMPONENT_ID_MAX,
+  Archetype
+};