refactor(world): optimize entity removal process

- Simplified the entity removal logic by swapping the last entity with the one being removed for O(1) performance.
- Updated component data handling to ensure correct removal and prevent undefined values.
- Removed unnecessary method for calculating final component types, streamlining the code.

Author: codehz

src/archetype.ts

@@ -106,23 +106,31 @@ export class Archetype {
       return undefined;
     }
 
-    // Remove from entity list
-    this.entities.splice(index, 1);
-    this.entityToIndex.delete(entityId);
-
-    // Extract component data
+    // Extract component data before removal
     const removedData = new Map<EntityId<any>, any>();
     for (const componentType of this.componentTypes) {
       const dataArray = this.getComponentData(componentType);
-      removedData.set(componentType, dataArray[index]);
-      dataArray.splice(index, 1);
+      removedData.set(componentType, dataArray[index] === MISSING_COMPONENT ? undefined : dataArray[index]);
     }
 
-    // Update indices for remaining entities
-    for (let i = index; i < this.entities.length; i++) {
-      this.entityToIndex.set(this.entities[i]!, i);
+    const lastIndex = this.entities.length - 1;
+    if (index !== lastIndex) {
+      // Swap with last entity for O(1) removal
+      const lastEntity = this.entities[lastIndex]!;
+      this.entities[index] = lastEntity;
+      this.entityToIndex.set(lastEntity, index);
+
+      // Swap component data
+      for (const componentType of this.componentTypes) {
+        const dataArray = this.getComponentData(componentType);
+        [dataArray[index], dataArray[lastIndex]] = [dataArray[lastIndex], dataArray[index]];
+      }
     }
 
+    // Remove the last element
+    this.entities.pop();
+    this.entityToIndex.delete(entityId);
+
     return removedData;
   }
 

src/changeset.test.ts

@@ -124,9 +124,9 @@ describe("ComponentChangeset", () => {
       existing.set(VelocityId, { x: 1, y: 2 });
       existing.set(HealthId, 100);
 
-      const finalTypes = changeset.getFinalComponentTypes(existing);
+      const finalTypes = changeset.applyTo(existing);
 
-      expect(finalTypes).toEqual([PositionId, HealthId]); // Sorted by ID
+      expect([...finalTypes.keys()]).toEqual([HealthId, PositionId]);
     });
   });
 

src/changeset.ts

@@ -72,12 +72,4 @@ export class ComponentChangeset {
 
     return finalComponents;
   }
-
-  /**
-   * Get the final component types after applying changes
-   */
-  getFinalComponentTypes(existingComponents: Map<EntityId<any>, any>): EntityId<any>[] {
-    const finalComponents = this.applyTo(existingComponents);
-    return Array.from(finalComponents.keys()).sort((a, b) => a - b);
-  }
 }

src/world.ts

@@ -604,18 +604,15 @@ export class World<UpdateParams extends any[] = []> {
     // Apply changes to current components to get final state
     const finalComponents = changeset.applyTo(currentComponents);
 
-    // Calculate final component types
-    const finalComponentTypes = changeset.getFinalComponentTypes(currentComponents);
-
     // Check if we need to move to a different archetype
-    const currentComponentTypes = currentArchetype.componentTypes.sort((a, b) => a - b);
+    const currentComponentTypes = currentArchetype.componentTypes;
     const needsArchetypeChange =
-      finalComponentTypes.length !== currentComponentTypes.length ||
-      !finalComponentTypes.every((type, index) => type === currentComponentTypes[index]);
+      finalComponents.size !== currentComponentTypes.length ||
+      !currentComponentTypes.every((type) => finalComponents.has(type));
 
     if (needsArchetypeChange) {
       // Move to new archetype with final component state
-      const newArchetype = this.ensureArchetype(finalComponentTypes);
+      const newArchetype = this.ensureArchetype(finalComponents.keys().toArray());
 
       // Remove from current archetype
       currentArchetype.removeEntity(entityId);
@@ -668,7 +665,7 @@ export class World<UpdateParams extends any[] = []> {
    * @returns The archetype for the given component types
    */
   private ensureArchetype(componentTypes: EntityId<any>[]): Archetype {
-    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+    const sortedTypes = componentTypes.toSorted((a, b) => a - b);
     const hashKey = this.createArchetypeSignature(sortedTypes);
 
     return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => {