@codehz/ecs 0.2.3 → 0.3.0

package/archetype.d.ts

@@ -102,6 +102,10 @@ export declare class Archetype {
      * Get all entities in this archetype
      */
     getEntities(): EntityId[];
+    /**
+     * Get the mapping of entities to their indices in this archetype
+     */
+    getEntityToIndexMap(): Map<EntityId, number>;
     /**
      * Get component data for all entities of a specific component type
      * @param componentType The component type

package/index.js

@@ -389,6 +389,9 @@ class Archetype {
   getEntities() {
     return this.entities;
   }
+  getEntityToIndexMap() {
+    return this.entityToIndex;
+  }
   getComponentData(componentType) {
     const data = this.componentData.get(componentType);
     if (!data) {
@@ -528,6 +531,7 @@ class ComponentChangeset {
     let changed = false;
     for (const componentType of this.removes) {
       if (!finalComponentTypes.has(componentType)) {
+        this.removes.delete(componentType);
         continue;
       }
       changed = true;
@@ -790,7 +794,7 @@ class World {
   queryCache = new Map;
   systemScheduler = new SystemScheduler;
   commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
-  lifecycleHooks = new Map;
+  hooks = new Map;
   exclusiveComponents = new Set;
   constructor(snapshot) {
     if (snapshot && typeof snapshot === "object") {
@@ -875,6 +879,7 @@ class World {
       const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
       if (sourceArchetype) {
         const currentComponents = new Map;
+        let removedComponent = sourceArchetype.get(sourceEntityId, componentType);
         for (const archetypeComponentType of sourceArchetype.componentTypes) {
           if (archetypeComponentType !== componentType) {
             const componentData = sourceArchetype.get(sourceEntityId, archetypeComponentType);
@@ -889,7 +894,7 @@ class World {
         newArchetype.addEntity(sourceEntityId, currentComponents);
         this.entityToArchetype.set(sourceEntityId, newArchetype);
         this.untrackEntityReference(sourceEntityId, componentType, entityId);
-        this.triggerLifecycleHooks(sourceEntityId, new Map, new Set([componentType]));
+        this.triggerLifecycleHooks(sourceEntityId, new Map, new Map([[componentType, removedComponent]]));
       }
     }
     this.entityReferences.delete(entityId);
@@ -916,7 +921,7 @@ class World {
     }
     this.commandBuffer.set(entityId, componentType, component2);
   }
-  delete(entityId, componentType) {
+  remove(entityId, componentType) {
     if (!this.exists(entityId)) {
       throw new Error(`Entity ${entityId} does not exist`);
     }
@@ -926,7 +931,7 @@ class World {
     }
     this.commandBuffer.delete(entityId, componentType);
   }
-  destroy(entityId) {
+  delete(entityId) {
     this.commandBuffer.destroy(entityId);
   }
   has(entityId, componentType) {
@@ -949,18 +954,29 @@ class World {
   registerSystem(system, additionalDeps = []) {
     this.systemScheduler.addSystem(system, additionalDeps);
   }
-  registerLifecycleHook(componentType, hook) {
-    if (!this.lifecycleHooks.has(componentType)) {
-      this.lifecycleHooks.set(componentType, new Set);
+  hook(componentType, hook) {
+    if (!this.hooks.has(componentType)) {
+      this.hooks.set(componentType, new Set);
+    }
+    this.hooks.get(componentType).add(hook);
+    if (hook.on_init !== undefined) {
+      this.archetypesByComponent.get(componentType)?.forEach((archetype) => {
+        const entities = archetype.getEntityToIndexMap();
+        const componentData = archetype.getComponentData(componentType);
+        for (const [entity, index] of entities) {
+          const data = componentData[index];
+          const value = data === MISSING_COMPONENT ? undefined : data;
+          hook.on_init?.(entity, componentType, value);
+        }
+      });
     }
-    this.lifecycleHooks.get(componentType).add(hook);
   }
-  unregisterLifecycleHook(componentType, hook) {
-    const hooks = this.lifecycleHooks.get(componentType);
+  unhook(componentType, hook) {
+    const hooks = this.hooks.get(componentType);
     if (hooks) {
       hooks.delete(hook);
       if (hooks.size === 0) {
-        this.lifecycleHooks.delete(componentType);
+        this.hooks.delete(componentType);
       }
     }
   }
@@ -1129,9 +1145,13 @@ class World {
       }
     }
     const finalComponentTypes = changeset.getFinalComponentTypes(currentArchetype.componentTypes);
+    const removedCompoents = new Map;
     if (finalComponentTypes) {
       const newArchetype = this.ensureArchetype(finalComponentTypes);
       const currentComponents = currentArchetype.removeEntity(entityId);
+      for (const componentType of changeset.removes) {
+        removedCompoents.set(componentType, currentComponents.get(componentType));
+      }
       newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
       this.entityToArchetype.set(entityId, newArchetype);
     } else {
@@ -1157,7 +1177,7 @@ class World {
         this.trackEntityReference(entityId, componentType, componentType);
       }
     }
-    this.triggerLifecycleHooks(entityId, changeset.adds, changeset.removes);
+    this.triggerLifecycleHooks(entityId, changeset.adds, removedCompoents);
     return changeset;
   }
   ensureArchetype(componentTypes) {
@@ -1225,45 +1245,37 @@ class World {
   }
   triggerLifecycleHooks(entityId, addedComponents, removedComponents) {
     for (const [componentType, component2] of addedComponents) {
-      const directHooks = this.lifecycleHooks.get(componentType);
+      const directHooks = this.hooks.get(componentType);
       if (directHooks) {
         for (const lifecycleHook of directHooks) {
-          if (lifecycleHook.onAdded) {
-            lifecycleHook.onAdded(entityId, componentType, component2);
-          }
+          lifecycleHook.on_set?.(entityId, componentType, component2);
         }
       }
       const detailedType = getDetailedIdType(componentType);
       if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
         const wildcardRelationId = relation(detailedType.componentId, "*");
-        const wildcardHooks = this.lifecycleHooks.get(wildcardRelationId);
+        const wildcardHooks = this.hooks.get(wildcardRelationId);
         if (wildcardHooks) {
           for (const lifecycleHook of wildcardHooks) {
-            if (lifecycleHook.onAdded) {
-              lifecycleHook.onAdded(entityId, componentType, component2);
-            }
+            lifecycleHook.on_set?.(entityId, componentType, component2);
           }
         }
       }
     }
-    for (const componentType of removedComponents) {
-      const directHooks = this.lifecycleHooks.get(componentType);
+    for (const [componentType, component2] of removedComponents) {
+      const directHooks = this.hooks.get(componentType);
       if (directHooks) {
         for (const lifecycleHook of directHooks) {
-          if (lifecycleHook.onRemoved) {
-            lifecycleHook.onRemoved(entityId, componentType);
-          }
+          lifecycleHook.on_remove?.(entityId, componentType, component2);
         }
       }
       const detailedType = getDetailedIdType(componentType);
       if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
         const wildcardRelationId = relation(detailedType.componentId, "*");
-        const wildcardHooks = this.lifecycleHooks.get(wildcardRelationId);
+        const wildcardHooks = this.hooks.get(wildcardRelationId);
         if (wildcardHooks) {
           for (const hook of wildcardHooks) {
-            if (hook.onRemoved) {
-              hook.onRemoved(entityId, componentType);
-            }
+            hook.on_remove?.(entityId, componentType, component2);
           }
         }
       }

package/package.json

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

package/types.d.ts

@@ -6,11 +6,15 @@ export interface LifecycleHook<T = unknown> {
     /**
      * Called when a component is added to an entity
      */
-    onAdded?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
+    on_init?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
     /**
-     * Called when a component is removed from an entity
+     * Called when a component is added to an entity
+     */
+    on_set?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
+    /**
+     * Called when a component is deleted from an entity
      */
-    onRemoved?: (entityId: EntityId, componentType: EntityId<T>) => void;
+    on_remove?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
 }
 export type ComponentType<T> = EntityId<T> | OptionalEntityId<T>;
 export type OptionalEntityId<T> = {

package/world.d.ts

@@ -32,7 +32,7 @@ export declare class World<UpdateParams extends any[] = []> {
     /** Buffers structural changes for deferred execution */
     private commandBuffer;
     /** Stores lifecycle hooks for component and relation events */
-    private lifecycleHooks;
+    private hooks;
     /** Set of component IDs marked as exclusive relations */
     private exclusiveComponents;
     /**
@@ -67,11 +67,11 @@ export declare class World<UpdateParams extends any[] = []> {
     /**
      * Remove a component from an entity (deferred)
      */
-    delete<T>(entityId: EntityId, componentType: EntityId<T>): void;
+    remove<T>(entityId: EntityId, componentType: EntityId<T>): void;
     /**
      * Destroy an entity and remove all its components (deferred)
      */
-    destroy(entityId: EntityId): void;
+    delete(entityId: EntityId): void;
     /**
      * Check if an entity has a specific component
      */
@@ -98,11 +98,11 @@ export declare class World<UpdateParams extends any[] = []> {
     /**
      * Register a lifecycle hook for component or wildcard relation events
      */
-    registerLifecycleHook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
+    hook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
     /**
      * Unregister a lifecycle hook for component or wildcard relation events
      */
-    unregisterLifecycleHook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
+    unhook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
     /**
      * Mark a component as exclusive relation
      * For exclusive relations, an entity can have at most one relation per base component