@codehz/ecs 0.0.9 → 0.1.0

package/README.md

@@ -38,12 +38,12 @@ const VelocityId = component<Velocity>(2);
 const world = new World();
 
 // 创建实体
-const entity = world.createEntity();
-world.addComponent(entity, PositionId, { x: 0, y: 0 });
-world.addComponent(entity, VelocityId, { x: 1, y: 0.5 });
+const entity = world.new();
+world.set(entity, PositionId, { x: 0, y: 0 });
+world.set(entity, VelocityId, { x: 1, y: 0.5 });
 
 // 应用更改
-world.flushCommands();
+world.sync();
 
 // 创建查询并更新
 const query = world.createQuery([PositionId, VelocityId]);
@@ -77,8 +77,8 @@ world.registerLifecycleHook(VelocityId, {
 });
 
 // 添加组件时会触发钩子
-world.addComponent(entity, PositionId, { x: 0, y: 0 });
-world.flushCommands(); // 钩子在这里被调用
+world.set(entity, PositionId, { x: 0, y: 0 });
+world.sync(); // 钩子在这里被调用
 ```
 
 ### 通配符关系生命周期钩子
@@ -98,7 +98,7 @@ const PositionId = component<Position>(1);
 const world = new World();
 
 // 创建实体
-const entity = world.createEntity();
+const entity = world.new();
 
 // 创建通配符关系ID，用于监听所有 Position 相关的关系
 const wildcardPositionRelation = relation(PositionId, "*");
@@ -114,10 +114,10 @@ world.registerLifecycleHook(wildcardPositionRelation, {
 });
 
 // 创建实体间的关系
-const entity2 = world.createEntity();
+const entity2 = world.new();
 const positionRelation = relation(PositionId, entity2);
-world.addComponent(entity, positionRelation, { x: 10, y: 20 });
-world.flushCommands(); // 通配符钩子会被触发
+world.set(entity, positionRelation, { x: 10, y: 20 });
+world.sync(); // 通配符钩子会被触发
 ```
 
 ### Exclusive Relations
@@ -137,20 +137,20 @@ const world = new World();
 world.setExclusive(ChildOf);
 
 // 创建实体
-const child = world.createEntity();
-const parent1 = world.createEntity();
-const parent2 = world.createEntity();
+const child = world.new();
+const parent1 = world.new();
+const parent2 = world.new();
 
 // 添加第一个关系
-world.addComponent(child, relation(ChildOf, parent1));
-world.flushCommands();
-console.log(world.hasComponent(child, relation(ChildOf, parent1))); // true
+world.set(child, relation(ChildOf, parent1));
+world.sync();
+console.log(world.has(child, relation(ChildOf, parent1))); // true
 
 // 添加第二个关系 - 会自动移除第一个
-world.addComponent(child, relation(ChildOf, parent2));
-world.flushCommands();
-console.log(world.hasComponent(child, relation(ChildOf, parent1))); // false
-console.log(world.hasComponent(child, relation(ChildOf, parent2))); // true
+world.set(child, relation(ChildOf, parent2));
+world.sync();
+console.log(world.has(child, relation(ChildOf, parent1))); // false
+console.log(world.has(child, relation(ChildOf, parent2))); // true
 ```
 
 ### 运行示例
@@ -169,16 +169,16 @@ bun run examples/simple/demo.ts
 
 ### World
 
-- `createEntity()`: 创建新实体
-- `addComponent(entity, componentId, data)`: 向实体添加组件
-- `removeComponent(entity, componentId)`: 从实体移除组件
+- `new()`: 创建新实体
+- `set(entity, componentId, data)`: 向实体添加组件
+- `delete(entity, componentId)`: 从实体移除组件
 - `setExclusive(componentId)`: 将组件标记为独占关系
 - `createQuery(componentIds)`: 创建查询
 - `registerSystem(system)`: 注册系统
 - `registerLifecycleHook(componentId, hook)`: 注册组件或通配符关系生命周期钩子
 - `unregisterLifecycleHook(componentId, hook)`: 注销组件或通配符关系生命周期钩子
-- `update(deltaTime)`: 更新世界
-- `flushCommands()`: 应用命令缓冲区
+- `update(...params)`: 更新世界（参数取决于泛型配置）
+- `sync()`: 应用命令缓冲区
 
 ### Entity
 
@@ -196,19 +196,48 @@ bun run examples/simple/demo.ts
 
 ```typescript
 class MySystem implements System {
-  update(world: World, deltaTime: number): void {
+  update(): void {
     // 系统逻辑
   }
 }
 ```
 
-系统支持依赖关系排序，确保正确的执行顺序：
+如果需要接收额外参数（如时间增量），可以指定泛型参数：
 
 ```typescript
-// 注册系统时指定依赖
+class MovementSystem implements System<[deltaTime: number]> {
+  update(deltaTime: number): void {
+    // 使用 deltaTime 更新位置
+  }
+}
+```
+
+系统支持依赖关系排序，确保正确的执行顺序。依赖关系通过系统的 `dependencies` 属性指定：
+
+```typescript
+class InputSystem implements System<[deltaTime: number]> {
+  readonly dependencies: readonly System<[deltaTime: number]>[] = [];
+  update(deltaTime: number): void {
+    // 处理输入
+  }
+}
+
+class MovementSystem implements System<[deltaTime: number]> {
+  readonly dependencies: readonly System<[deltaTime: number]>[];
+
+  constructor(inputSystem: InputSystem) {
+    this.dependencies = [inputSystem]; // 指定依赖
+  }
+
+  update(deltaTime: number): void {
+    // 更新位置
+  }
+}
+
+// 注册系统
+const inputSystem = new InputSystem();
 world.registerSystem(inputSystem);
-world.registerSystem(movementSystem, [inputSystem]); // movementSystem 依赖 inputSystem
-world.registerSystem(renderSystem, [movementSystem]); // renderSystem 依赖 movementSystem
+world.registerSystem(new MovementSystem(inputSystem));
 ```
 
 系统将按照拓扑排序执行，依赖系统始终在被依赖系统之前运行。

package/archetype.d.ts

@@ -59,27 +59,27 @@ export declare class Archetype {
      * Check if an entity is in this archetype
      * @param entityId The entity to check
      */
-    hasEntity(entityId: EntityId): boolean;
+    exists(entityId: EntityId): boolean;
     /**
      * Get component data for a specific entity and wildcard relation type
      * Returns an array of all matching relation instances
      * @param entityId The entity
      * @param componentType The wildcard relation type
      */
-    getComponent<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, any][];
+    get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, any][];
     /**
      * Get component data for a specific entity and component type
      * @param entityId The entity
      * @param componentType The component type
      */
-    getComponent<T>(entityId: EntityId, componentType: EntityId<T>): T;
+    get<T>(entityId: EntityId, componentType: EntityId<T>): T;
     /**
      * Set component data for a specific entity and component type
      * @param entityId The entity
      * @param componentType The component type
      * @param data The component data
      */
-    setComponent<T>(entityId: EntityId, componentType: EntityId<T>, data: T): void;
+    set<T>(entityId: EntityId, componentType: EntityId<T>, data: T): void;
     /**
      * Get all entities in this archetype
      */

package/changeset.d.ts

@@ -8,11 +8,11 @@ export declare class ComponentChangeset {
     /**
      * Add a component to the changeset
      */
-    addComponent<T>(componentType: EntityId<T>, component: T): void;
+    set<T>(componentType: EntityId<T>, component: T): void;
     /**
      * Remove a component from the changeset
      */
-    removeComponent<T>(componentType: EntityId<T>): void;
+    delete<T>(componentType: EntityId<T>): void;
     /**
      * Check if the changeset has any changes
      */

package/command-buffer.d.ts

@@ -3,7 +3,7 @@ import type { EntityId } from "./entity";
  * Command for deferred execution
  */
 export interface Command {
-    type: "addComponent" | "removeComponent" | "destroyEntity";
+    type: "set" | "delete" | "destroy";
     entityId: EntityId;
     componentType?: EntityId<any>;
     component?: any;
@@ -21,16 +21,16 @@ export declare class CommandBuffer {
     /**
      * Add a component to an entity (deferred)
      */
-    addComponent(entityId: EntityId, componentType: EntityId<void>): void;
-    addComponent<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
+    set(entityId: EntityId, componentType: EntityId<void>): void;
+    set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
     /**
      * Remove a component from an entity (deferred)
      */
-    removeComponent<T>(entityId: EntityId, componentType: EntityId<T>): void;
+    delete<T>(entityId: EntityId, componentType: EntityId<T>): void;
     /**
      * Destroy an entity (deferred)
      */
-    destroyEntity(entityId: EntityId): void;
+    destroy(entityId: EntityId): void;
     /**
      * Execute all commands and clear the buffer
      */

package/index.js

@@ -280,10 +280,10 @@ class Archetype {
     }
     return removedData;
   }
-  hasEntity(entityId) {
+  exists(entityId) {
     return this.entityToIndex.has(entityId);
   }
-  getComponent(entityId, componentType) {
+  get(entityId, componentType) {
     const index = this.entityToIndex.get(entityId);
     if (index === undefined) {
       throw new Error(`Entity ${entityId} is not in this archetype`);
@@ -308,7 +308,7 @@ class Archetype {
       return data === MISSING_COMPONENT ? undefined : data;
     }
   }
-  setComponent(entityId, componentType, data) {
+  set(entityId, componentType, data) {
     if (!this.componentData.has(componentType)) {
       throw new Error(`Component type ${componentType} is not in this archetype`);
     }
@@ -392,11 +392,11 @@ class Archetype {
 class ComponentChangeset {
   adds = new Map;
   removes = new Set;
-  addComponent(componentType, component2) {
+  set(componentType, component2) {
     this.adds.set(componentType, component2);
     this.removes.delete(componentType);
   }
-  removeComponent(componentType) {
+  delete(componentType) {
     this.removes.add(componentType);
     this.adds.delete(componentType);
   }
@@ -440,14 +440,14 @@ class CommandBuffer {
   constructor(executeEntityCommands) {
     this.executeEntityCommands = executeEntityCommands;
   }
-  addComponent(entityId, componentType, component2) {
-    this.commands.push({ type: "addComponent", entityId, componentType, component: component2 });
+  set(entityId, componentType, component2) {
+    this.commands.push({ type: "set", entityId, componentType, component: component2 });
   }
-  removeComponent(entityId, componentType) {
-    this.commands.push({ type: "removeComponent", entityId, componentType });
+  delete(entityId, componentType) {
+    this.commands.push({ type: "delete", entityId, componentType });
   }
-  destroyEntity(entityId) {
-    this.commands.push({ type: "destroyEntity", entityId });
+  destroy(entityId) {
+    this.commands.push({ type: "destroy", entityId });
   }
   execute() {
     const MAX_ITERATIONS = 100;
@@ -664,7 +664,7 @@ class World {
   getComponentTypesHash(componentTypes) {
     return componentTypes.join(",");
   }
-  createEntity() {
+  new() {
     const entityId = this.entityIdManager.allocate();
     let emptyArchetype = this.getOrCreateArchetype([]);
     emptyArchetype.addEntity(entityId, new Map);
@@ -683,7 +683,7 @@ class World {
         const currentComponents = new Map;
         for (const compType of sourceArchetype.componentTypes) {
           if (compType !== componentType) {
-            const data = sourceArchetype.getComponent(sourceEntityId, compType);
+            const data = sourceArchetype.get(sourceEntityId, compType);
             if (data !== undefined) {
               currentComponents.set(compType, data);
             }
@@ -709,11 +709,11 @@ class World {
     this.entityToArchetype.delete(entityId);
     this.entityIdManager.deallocate(entityId);
   }
-  hasEntity(entityId) {
+  exists(entityId) {
     return this.entityToArchetype.has(entityId);
   }
-  addComponent(entityId, componentType, component2) {
-    if (!this.hasEntity(entityId)) {
+  set(entityId, componentType, component2) {
+    if (!this.exists(entityId)) {
       throw new Error(`Entity ${entityId} does not exist`);
     }
     const detailedType = getDetailedIdType(componentType);
@@ -723,31 +723,31 @@ class World {
     if (detailedType.type === "wildcard-relation") {
       throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
     }
-    this.commandBuffer.addComponent(entityId, componentType, component2);
+    this.commandBuffer.set(entityId, componentType, component2);
   }
-  removeComponent(entityId, componentType) {
-    if (!this.hasEntity(entityId)) {
+  delete(entityId, componentType) {
+    if (!this.exists(entityId)) {
       throw new Error(`Entity ${entityId} does not exist`);
     }
     const detailedType = getDetailedIdType(componentType);
     if (detailedType.type === "invalid") {
       throw new Error(`Invalid component type: ${componentType}`);
     }
-    this.commandBuffer.removeComponent(entityId, componentType);
+    this.commandBuffer.delete(entityId, componentType);
   }
-  destroyEntity(entityId) {
-    this.commandBuffer.destroyEntity(entityId);
+  destroy(entityId) {
+    this.commandBuffer.destroy(entityId);
   }
-  hasComponent(entityId, componentType) {
+  has(entityId, componentType) {
     const archetype = this.entityToArchetype.get(entityId);
     return archetype ? archetype.componentTypes.includes(componentType) : false;
   }
-  getComponent(entityId, componentType) {
+  get(entityId, componentType) {
     const archetype = this.entityToArchetype.get(entityId);
     if (!archetype) {
       throw new Error(`Entity ${entityId} does not exist`);
     }
-    return archetype.getComponent(entityId, componentType);
+    return archetype.get(entityId, componentType);
   }
   registerSystem(system) {
     this.systemScheduler.addSystem(system);
@@ -773,11 +773,11 @@ class World {
   update(...params) {
     const systems = this.systemScheduler.getExecutionOrder();
     for (const system of systems) {
-      system.update(this, ...params);
+      system.update(...params);
     }
     this.commandBuffer.execute();
   }
-  flushCommands() {
+  sync() {
     this.commandBuffer.execute();
   }
   createQuery(componentTypes, filter = {}) {
@@ -895,7 +895,7 @@ class World {
   }
   executeEntityCommands(entityId, commands) {
     const changeset = new ComponentChangeset;
-    const hasDestroy = commands.some((cmd) => cmd.type === "destroyEntity");
+    const hasDestroy = commands.some((cmd) => cmd.type === "destroy");
     if (hasDestroy) {
       this._destroyEntity(entityId);
       return changeset;
@@ -906,26 +906,26 @@ class World {
     }
     const currentComponents = new Map;
     for (const componentType of currentArchetype.componentTypes) {
-      const data = currentArchetype.getComponent(entityId, componentType);
+      const data = currentArchetype.get(entityId, componentType);
       currentComponents.set(componentType, data);
     }
     for (const cmd of commands) {
       switch (cmd.type) {
-        case "addComponent":
+        case "set":
           if (cmd.componentType) {
             const detailedType = getDetailedIdType(cmd.componentType);
             if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && this.exclusiveComponents.has(detailedType.componentId)) {
               for (const componentType of currentArchetype.componentTypes) {
                 const componentDetailedType = getDetailedIdType(componentType);
                 if ((componentDetailedType.type === "entity-relation" || componentDetailedType.type === "component-relation") && componentDetailedType.componentId === detailedType.componentId) {
-                  changeset.removeComponent(componentType);
+                  changeset.delete(componentType);
                 }
               }
             }
-            changeset.addComponent(cmd.componentType, cmd.component);
+            changeset.set(cmd.componentType, cmd.component);
           }
           break;
-        case "removeComponent":
+        case "delete":
           if (cmd.componentType) {
             const detailedType = getDetailedIdType(cmd.componentType);
             if (detailedType.type === "wildcard-relation") {
@@ -934,12 +934,12 @@ class World {
                 const componentDetailedType = getDetailedIdType(componentType);
                 if (componentDetailedType.type === "entity-relation" || componentDetailedType.type === "component-relation") {
                   if (componentDetailedType.componentId === baseComponentId) {
-                    changeset.removeComponent(componentType);
+                    changeset.delete(componentType);
                   }
                 }
               }
             } else {
-              changeset.removeComponent(cmd.componentType);
+              changeset.delete(cmd.componentType);
             }
           }
           break;
@@ -956,7 +956,7 @@ class World {
       this.entityToArchetype.set(entityId, newArchetype);
     } else {
       for (const [componentType, component2] of changeset.adds) {
-        currentArchetype.setComponent(entityId, componentType, component2);
+        currentArchetype.set(entityId, componentType, component2);
       }
     }
     for (const componentType of changeset.removes) {

package/package.json

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

package/system-scheduler.d.ts

@@ -2,19 +2,19 @@ import type { System } from "./system";
 /**
  * System Scheduler for managing system dependencies and execution order
  */
-export declare class SystemScheduler<ExtraParams extends any[] = [deltaTime: number]> {
+export declare class SystemScheduler<UpdateParams extends any[] = [deltaTime: number]> {
     private systems;
     private cachedExecutionOrder;
     /**
      * Add a system with optional dependencies
      * @param system The system to add
      */
-    addSystem(system: System<ExtraParams>): void;
+    addSystem(system: System<UpdateParams>): void;
     /**
      * Get the execution order of systems based on dependencies
      * Uses topological sort
      */
-    getExecutionOrder(): System<ExtraParams>[];
+    getExecutionOrder(): System<UpdateParams>[];
     /**
      * Clear all systems and dependencies
      */

package/system.d.ts

@@ -1,14 +1,13 @@
-import type { World } from "./world";
 /**
  * Base System interface
  */
-export interface System<ExtraParams extends any[] = [deltaTime: number]> {
+export interface System<UpdateParams extends any[] = []> {
     /**
      * Update the system
      */
-    update(world: World<ExtraParams>, ...params: ExtraParams): void;
+    update(...params: UpdateParams): void;
     /**
      * Dependencies of this system (systems that must run before this one)
      */
-    readonly dependencies?: readonly System<ExtraParams>[];
+    readonly dependencies?: readonly System<UpdateParams>[];
 }

package/world.d.ts

@@ -10,7 +10,7 @@ import type { ComponentTuple, LifecycleHook } from "./types";
  * World class for ECS architecture
  * Manages entities, components, and systems
  */
-export declare class World<ExtraParams extends any[] = [deltaTime: number]> {
+export declare class World<UpdateParams extends any[] = []> {
     private entityIdManager;
     private archetypes;
     private archetypeMap;
@@ -43,7 +43,7 @@ export declare class World<ExtraParams extends any[] = [deltaTime: number]> {
     /**
      * Create a new entity
      */
-    createEntity(): EntityId;
+    new(): EntityId;
     /**
      * Destroy an entity and remove all its components (immediate execution)
      */
@@ -51,41 +51,41 @@ export declare class World<ExtraParams extends any[] = [deltaTime: number]> {
     /**
      * Check if an entity exists
      */
-    hasEntity(entityId: EntityId): boolean;
+    exists(entityId: EntityId): boolean;
     /**
      * Add a component to an entity (deferred)
      */
-    addComponent(entityId: EntityId, componentType: EntityId<void>): void;
-    addComponent<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
+    set(entityId: EntityId, componentType: EntityId<void>): void;
+    set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
     /**
      * Remove a component from an entity (deferred)
      */
-    removeComponent<T>(entityId: EntityId, componentType: EntityId<T>): void;
+    delete<T>(entityId: EntityId, componentType: EntityId<T>): void;
     /**
      * Destroy an entity and remove all its components (deferred)
      */
-    destroyEntity(entityId: EntityId): void;
+    destroy(entityId: EntityId): void;
     /**
      * Check if an entity has a specific component
      */
-    hasComponent<T>(entityId: EntityId, componentType: EntityId<T>): boolean;
+    has<T>(entityId: EntityId, componentType: EntityId<T>): boolean;
     /**
      * Get component data for a specific entity and wildcard relation type
      * Returns an array of all matching relation instances
      * @param entityId The entity
      * @param componentType The wildcard relation type
      */
-    getComponent<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, T][];
+    get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, T][];
     /**
      * Get component data for a specific entity and component type
      * @param entityId The entity
      * @param componentType The component type
      */
-    getComponent<T>(entityId: EntityId, componentType: EntityId<T>): T;
+    get<T>(entityId: EntityId, componentType: EntityId<T>): T;
     /**
      * Register a system with optional dependencies
      */
-    registerSystem(system: System<ExtraParams>): void;
+    registerSystem(system: System<UpdateParams>): void;
     /**
      * Register a lifecycle hook for component or wildcard relation events
      */
@@ -102,11 +102,11 @@ export declare class World<ExtraParams extends any[] = [deltaTime: number]> {
     /**
      * Update the world (run all systems in dependency order)
      */
-    update(...params: ExtraParams): void;
+    update(...params: UpdateParams): void;
     /**
      * Execute all deferred commands immediately without running systems
      */
-    flushCommands(): void;
+    sync(): void;
     /**
      * Create a cached query for efficient entity lookups
      */