@codehz/ecs 0.3.3 → 0.3.5

package/index.js

@@ -594,6 +594,86 @@ class CommandBuffer {
   }
 }
 
+// src/multi-map.ts
+class MultiMap {
+  map = new Map;
+  _valueCount = 0;
+  get valueCount() {
+    return this._valueCount;
+  }
+  get keyCount() {
+    return this.map.size;
+  }
+  hasKey(key) {
+    return this.map.has(key);
+  }
+  has(key, value) {
+    const set = this.map.get(key);
+    if (!set)
+      return false;
+    if (arguments.length === 1)
+      return true;
+    return set.has(value);
+  }
+  add(key, value) {
+    let set = this.map.get(key);
+    if (!set) {
+      set = new Set;
+      this.map.set(key, set);
+    }
+    if (!set.has(value)) {
+      set.add(value);
+      this._valueCount++;
+    }
+  }
+  remove(key, value) {
+    const set = this.map.get(key);
+    if (!set)
+      return false;
+    if (!set.has(value))
+      return false;
+    set.delete(value);
+    this._valueCount--;
+    if (set.size === 0)
+      this.map.delete(key);
+    return true;
+  }
+  deleteKey(key) {
+    const set = this.map.get(key);
+    if (!set)
+      return false;
+    this._valueCount -= set.size;
+    this.map.delete(key);
+    return true;
+  }
+  get(key) {
+    const set = this.map.get(key);
+    return set ? new Set(set) : new Set;
+  }
+  *keys() {
+    yield* this.map.keys();
+  }
+  *values() {
+    for (const set of this.map.values()) {
+      for (const v of set)
+        yield v;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  *entries() {
+    for (const [k, set] of this.map.entries()) {
+      for (const v of set)
+        yield [k, v];
+    }
+  }
+  clear() {
+    this.map.clear();
+    this._valueCount = 0;
+  }
+}
+
 // src/query-filter.ts
 function serializeQueryFilter(filter = {}) {
   const negative = (filter.negativeComponentTypes || []).slice().sort((a, b) => a - b);
@@ -804,6 +884,7 @@ class World {
   commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
   hooks = new Map;
   exclusiveComponents = new Set;
+  cascadeDeleteComponents = new Set;
   constructor(snapshot) {
     if (snapshot && typeof snapshot === "object") {
       if (snapshot.entityManager) {
@@ -873,14 +954,29 @@ class World {
     return entityId;
   }
   destroyEntityImmediate(entityId) {
-    const archetype = this.entityToArchetype.get(entityId);
-    if (!archetype) {
-      return;
-    }
-    const componentReferences = this.getEntityReferences(entityId);
-    for (const { sourceEntityId, componentType } of componentReferences) {
-      const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
-      if (sourceArchetype) {
+    const queue = [entityId];
+    const visited = new Set;
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      if (visited.has(cur))
+        continue;
+      visited.add(cur);
+      const archetype = this.entityToArchetype.get(cur);
+      if (!archetype) {
+        continue;
+      }
+      const componentReferences = Array.from(this.getEntityReferences(cur));
+      for (const [sourceEntityId, componentType] of componentReferences) {
+        const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
+        if (!sourceArchetype)
+          continue;
+        const detailedType = getDetailedIdType(componentType);
+        if (detailedType.type === "entity-relation" && this.cascadeDeleteComponents.has(detailedType.componentId)) {
+          if (!visited.has(sourceEntityId)) {
+            queue.push(sourceEntityId);
+          }
+          continue;
+        }
         const currentComponents = new Map;
         let removedComponent = sourceArchetype.get(sourceEntityId, componentType);
         for (const archetypeComponentType of sourceArchetype.componentTypes) {
@@ -896,17 +992,17 @@ class World {
         }
         newArchetype.addEntity(sourceEntityId, currentComponents);
         this.entityToArchetype.set(sourceEntityId, newArchetype);
-        this.untrackEntityReference(sourceEntityId, componentType, entityId);
+        this.untrackEntityReference(sourceEntityId, componentType, cur);
         this.triggerLifecycleHooks(sourceEntityId, new Map, new Map([[componentType, removedComponent]]));
       }
+      this.entityReferences.delete(cur);
+      archetype.removeEntity(cur);
+      if (archetype.getEntities().length === 0) {
+        this.cleanupEmptyArchetype(archetype);
+      }
+      this.entityToArchetype.delete(cur);
+      this.entityIdManager.deallocate(cur);
     }
-    this.entityReferences.delete(entityId);
-    archetype.removeEntity(entityId);
-    if (archetype.getEntities().length === 0) {
-      this.cleanupEmptyArchetype(archetype);
-    }
-    this.entityToArchetype.delete(entityId);
-    this.entityIdManager.deallocate(entityId);
   }
   exists(entityId) {
     return this.entityToArchetype.has(entityId);
@@ -986,6 +1082,9 @@ class World {
   setExclusive(componentId) {
     this.exclusiveComponents.add(componentId);
   }
+  setCascadeDelete(componentId) {
+    this.cascadeDeleteComponents.add(componentId);
+  }
   update(...params) {
     const result = this.systemScheduler.update(...params);
     if (result instanceof Promise) {
@@ -1206,26 +1305,21 @@ class World {
   }
   trackEntityReference(sourceEntityId, componentType, targetEntityId) {
     if (!this.entityReferences.has(targetEntityId)) {
-      this.entityReferences.set(targetEntityId, new Set);
+      this.entityReferences.set(targetEntityId, new MultiMap);
     }
-    this.entityReferences.get(targetEntityId).add({ sourceEntityId, componentType });
+    this.entityReferences.get(targetEntityId).add(sourceEntityId, componentType);
   }
   untrackEntityReference(sourceEntityId, componentType, targetEntityId) {
     const references = this.entityReferences.get(targetEntityId);
     if (references) {
-      references.forEach((reference) => {
-        if (reference.sourceEntityId === sourceEntityId && reference.componentType === componentType) {
-          references.delete(reference);
-        }
-      });
-      if (references.size === 0) {
+      references.remove(sourceEntityId, componentType);
+      if (references.keyCount === 0) {
         this.entityReferences.delete(targetEntityId);
       }
     }
   }
   getEntityReferences(targetEntityId) {
-    const references = this.entityReferences.get(targetEntityId);
-    return references ? Array.from(references) : [];
+    return this.entityReferences.get(targetEntityId) ?? new MultiMap;
   }
   cleanupEmptyArchetype(archetype) {
     if (archetype.getEntities().length > 0) {

package/multi-map.d.ts

@@ -0,0 +1,19 @@
+declare class MultiMap<K, V> {
+    private map;
+    private _valueCount;
+    get valueCount(): number;
+    get keyCount(): number;
+    hasKey(key: K): boolean;
+    has(key: K, value?: V): boolean;
+    add(key: K, value: V): void;
+    remove(key: K, value: V): boolean;
+    deleteKey(key: K): boolean;
+    get(key: K): Set<V>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    entries(): IterableIterator<[K, V]>;
+    clear(): void;
+}
+export { MultiMap };
+export type { MultiMap as MultiMapType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codehz/ecs",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/world.d.ts

@@ -35,6 +35,8 @@ export declare class World<UpdateParams extends any[] = []> {
     private hooks;
     /** Set of component IDs marked as exclusive relations */
     private exclusiveComponents;
+    /** Set of component IDs that will cascade delete when the relation target is deleted */
+    private cascadeDeleteComponents;
     /**
      * Create a new World.
      * If an optional snapshot object is provided (previously produced by `world.serialize()`),
@@ -108,6 +110,13 @@ export declare class World<UpdateParams extends any[] = []> {
      * For exclusive relations, an entity can have at most one relation per base component
      */
     setExclusive(componentId: EntityId): void;
+    /**
+     * Mark a component as cascade-delete relation
+     * For cascade relations, when the relation target entity is deleted,
+     * the referencing entity will also be deleted (cascade).
+     * Only applicable to entity-relation components
+     */
+    setCascadeDelete(componentId: EntityId): void;
     /**
      * Update the world (run all systems in dependency order)
      * This function is synchronous when all systems are synchronous,
@@ -176,7 +185,7 @@ export declare class World<UpdateParams extends any[] = []> {
     /**
      * Get all component references where a target entity is used as a component type
      * @param targetEntityId The target entity
-     * @returns Array of {sourceEntityId, componentType} pairs
+     * @returns A MultiMap of sourceEntityId to componentTypes that reference the target entity
      */
     private getEntityReferences;
     /**