@codehz/ecs 0.1.4 → 0.1.6

package/changeset.d.ts

@@ -29,8 +29,4 @@ export declare class ComponentChangeset {
      * Apply the changeset to existing components and return the final state
      */
     applyTo(existingComponents: Map<EntityId<any>, any>): Map<EntityId<any>, any>;
-    /**
-     * Get the final component types after applying changes
-     */
-    getFinalComponentTypes(existingComponents: Map<EntityId<any>, any>): EntityId<any>[];
 }

package/index.js

@@ -277,16 +277,25 @@ class Archetype {
     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.getComponentData(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);
+    this.entityToIndex.delete(entityId);
+    const lastIndex = this.entities.length - 1;
+    if (index !== lastIndex) {
+      const lastEntity = this.entities[lastIndex];
+      this.entities[index] = lastEntity;
+      this.entityToIndex.set(lastEntity, index);
+      for (const componentType of this.componentTypes) {
+        const dataArray = this.getComponentData(componentType);
+        dataArray[index] = dataArray[lastIndex];
+      }
+    }
+    this.entities.pop();
+    for (const componentType of this.componentTypes) {
+      this.getComponentData(componentType).pop();
     }
     return removedData;
   }
@@ -430,18 +439,13 @@ class ComponentChangeset {
     }
   }
   applyTo(existingComponents) {
-    const finalComponents = new Map(existingComponents);
     for (const componentType of this.removes) {
-      finalComponents.delete(componentType);
+      existingComponents.delete(componentType);
     }
     for (const [componentType, component2] of this.adds) {
-      finalComponents.set(componentType, component2);
+      existingComponents.set(componentType, component2);
     }
-    return finalComponents;
-  }
-  getFinalComponentTypes(existingComponents) {
-    const finalComponents = this.applyTo(existingComponents);
-    return Array.from(finalComponents.keys()).sort((a, b) => a - b);
+    return existingComponents;
   }
 }
 
@@ -732,8 +736,7 @@ class World {
             currentComponents.set(archetypeComponentType, componentData);
           }
         }
-        const newComponentTypes = Array.from(currentComponents.keys()).sort((a, b) => a - b);
-        const newArchetype = this.ensureArchetype(newComponentTypes);
+        const newArchetype = this.ensureArchetype(currentComponents.keys());
         sourceArchetype.removeEntity(sourceEntityId);
         if (sourceArchetype.getEntities().length === 0) {
           this.cleanupEmptyArchetype(sourceArchetype);
@@ -995,11 +998,10 @@ class World {
       }
     }
     const finalComponents = changeset.applyTo(currentComponents);
-    const finalComponentTypes = changeset.getFinalComponentTypes(currentComponents);
-    const currentComponentTypes = currentArchetype.componentTypes.sort((a, b) => a - b);
-    const needsArchetypeChange = finalComponentTypes.length !== currentComponentTypes.length || !finalComponentTypes.every((type, index) => type === currentComponentTypes[index]);
+    const currentComponentTypes = currentArchetype.componentTypes;
+    const needsArchetypeChange = finalComponents.size !== currentComponentTypes.length || !currentComponentTypes.every((type) => finalComponents.has(type));
     if (needsArchetypeChange) {
-      const newArchetype = this.ensureArchetype(finalComponentTypes);
+      const newArchetype = this.ensureArchetype(finalComponents.keys());
       currentArchetype.removeEntity(entityId);
       newArchetype.addEntity(entityId, finalComponents);
       this.entityToArchetype.set(entityId, newArchetype);
@@ -1030,7 +1032,7 @@ class World {
     return changeset;
   }
   ensureArchetype(componentTypes) {
-    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+    const sortedTypes = Array.from(componentTypes).sort((a, b) => a - b);
     const hashKey = this.createArchetypeSignature(sortedTypes);
     return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => {
       const newArchetype = new Archetype(sortedTypes);

package/package.json

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