@codehz/ecs 0.3.2 → 0.3.4

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);
@@ -809,11 +889,6 @@ class World {
       if (snapshot.entityManager) {
         this.entityIdManager.deserializeState(snapshot.entityManager);
       }
-      if (Array.isArray(snapshot.exclusiveComponents)) {
-        for (const id of snapshot.exclusiveComponents) {
-          this.exclusiveComponents.add(id);
-        }
-      }
       if (Array.isArray(snapshot.entities)) {
         for (const entry of snapshot.entities) {
           const entityId = entry.id;
@@ -883,7 +958,7 @@ class World {
       return;
     }
     const componentReferences = this.getEntityReferences(entityId);
-    for (const { sourceEntityId, componentType } of componentReferences) {
+    for (const [sourceEntityId, componentType] of componentReferences) {
       const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
       if (sourceArchetype) {
         const currentComponents = new Map;
@@ -1083,8 +1158,12 @@ class World {
       matchingArchetypes = [...this.archetypes];
     }
     for (const wildcard of wildcardRelations) {
-      const componentArchetypes = this.archetypesByComponent.get(wildcard.componentId) || [];
-      matchingArchetypes = matchingArchetypes.filter((archetype) => componentArchetypes.includes(archetype));
+      matchingArchetypes = matchingArchetypes.filter((archetype) => archetype.componentTypes.some((archetypeType) => {
+        if (!isRelationId(archetypeType))
+          return false;
+        const decoded = decodeRelationId(archetypeType);
+        return decoded.componentId === wildcard.componentId;
+      }));
     }
     return matchingArchetypes;
   }
@@ -1207,26 +1286,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.get(sourceEntityId).delete(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) ?? [];
   }
   cleanupEmptyArchetype(archetype) {
     if (archetype.getEntities().length > 0) {
@@ -1331,7 +1405,6 @@ class World {
     return {
       version: 1,
       entityManager: this.entityIdManager.serializeState(),
-      exclusiveComponents: Array.from(this.exclusiveComponents),
       entities
     };
   }

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.2",
+  "version": "0.3.4",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/world.d.ts

@@ -176,7 +176,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;
     /**
@@ -197,7 +197,6 @@ export declare class World<UpdateParams extends any[] = []> {
 export type SerializedWorld = {
     version: number;
     entityManager: any;
-    exclusiveComponents: EntityId[];
     entities: SerializedEntity[];
 };
 export type SerializedEntity = {