@codehz/ecs 0.7.2 → 0.7.4

package/src/__tests__/query/optional.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+describe("Query", () => {
+  describe("Optional Components in Queries", () => {
+    type Position = { x: number; y: number };
+    type Velocity = { x: number; y: number };
+    type Health = { value: number };
+
+    const positionComponent = component<Position>();
+    const velocityComponent = component<Velocity>();
+    const healthComponent = component<Health>();
+
+    it("should handle optional components in forEach", () => {
+      const world = new World();
+      const query = world.createQuery([positionComponent]);
+
+      const entity1 = world.new();
+      const entity2 = world.new();
+      const entity3 = world.new();
+
+      world.set(entity1, positionComponent, { x: 1, y: 2 });
+      world.set(entity1, velocityComponent, { x: 0.1, y: 0.2 });
+      world.set(entity2, positionComponent, { x: 3, y: 4 });
+      // entity2 has no velocity
+      world.set(entity3, positionComponent, { x: 5, y: 6 });
+      world.set(entity3, healthComponent, { value: 100 });
+
+      world.sync();
+
+      const results: Array<{ entity: EntityId; position: Position; velocity?: { value: Velocity } }> = [];
+
+      query.forEach([positionComponent, { optional: velocityComponent }], (entity, position, velocity) => {
+        results.push({ entity, position, velocity });
+      });
+
+      expect(results.length).toBe(3);
+
+      const result1 = results.find((r) => r.entity === entity1);
+      const result2 = results.find((r) => r.entity === entity2);
+      const result3 = results.find((r) => r.entity === entity3);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result3).toBeDefined();
+
+      expect(result1!.position).toEqual({ x: 1, y: 2 });
+      expect(result1!.velocity).toEqual({ value: { x: 0.1, y: 0.2 } });
+
+      expect(result2!.position).toEqual({ x: 3, y: 4 });
+      expect(result2!.velocity).toBeUndefined();
+
+      expect(result3!.position).toEqual({ x: 5, y: 6 });
+      expect(result3!.velocity).toBeUndefined();
+    });
+
+    it("should handle optional components in getEntitiesWithComponents", () => {
+      const world = new World();
+      const query = world.createQuery([positionComponent]);
+
+      const entity1 = world.new();
+      const entity2 = world.new();
+
+      world.set(entity1, positionComponent, { x: 1, y: 2 });
+      world.set(entity1, velocityComponent, { x: 0.1, y: 0.2 });
+      world.set(entity2, positionComponent, { x: 3, y: 4 });
+      // entity2 has no velocity
+
+      world.sync();
+
+      const results = query.getEntitiesWithComponents([positionComponent, { optional: velocityComponent }]);
+
+      expect(results.length).toBe(2);
+
+      const result1 = results.find((r) => r.entity === entity1);
+      const result2 = results.find((r) => r.entity === entity2);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+
+      expect(result1!.components[0]).toEqual({ x: 1, y: 2 });
+      expect(result1!.components[1]).toEqual({ value: { x: 0.1, y: 0.2 } });
+
+      expect(result2!.components[0]).toEqual({ x: 3, y: 4 });
+      expect(result2!.components[1]).toBeUndefined();
+    });
+
+    it("should handle optional components in iterate", () => {
+      const world = new World();
+      const query = world.createQuery([positionComponent]);
+
+      const entity1 = world.new();
+      const entity2 = world.new();
+
+      world.set(entity1, positionComponent, { x: 1, y: 2 });
+      world.set(entity1, velocityComponent, { x: 0.1, y: 0.2 });
+      world.set(entity2, positionComponent, { x: 3, y: 4 });
+      // entity2 has no velocity
+
+      world.sync();
+
+      const results: Array<{ entity: EntityId; position: Position; velocity?: { value: Velocity } }> = [];
+
+      for (const [entity, position, velocity] of query.iterate([positionComponent, { optional: velocityComponent }])) {
+        results.push({ entity, position, velocity });
+      }
+
+      expect(results.length).toBe(2);
+
+      const result1 = results.find((r) => r.entity === entity1);
+      const result2 = results.find((r) => r.entity === entity2);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+
+      expect(result1!.position).toEqual({ x: 1, y: 2 });
+      expect(result1!.velocity).toEqual({ value: { x: 0.1, y: 0.2 } });
+
+      expect(result2!.position).toEqual({ x: 3, y: 4 });
+      expect(result2!.velocity).toBeUndefined();
+    });
+
+    it("should handle mixed mandatory and optional components", () => {
+      const world = new World();
+      const query = world.createQuery([positionComponent, velocityComponent]);
+
+      const entity1 = world.new();
+      const entity2 = world.new();
+      const entity3 = world.new();
+
+      world.set(entity1, positionComponent, { x: 1, y: 2 });
+      world.set(entity1, velocityComponent, { x: 0.1, y: 0.2 });
+      world.set(entity1, healthComponent, { value: 100 });
+
+      world.set(entity2, positionComponent, { x: 3, y: 4 });
+      world.set(entity2, velocityComponent, { x: 0.2, y: 0.3 });
+      // entity2 has no health
+
+      world.set(entity3, positionComponent, { x: 5, y: 6 });
+      world.set(entity3, velocityComponent, { x: 0.3, y: 0.4 });
+      world.set(entity3, healthComponent, { value: 50 });
+
+      world.sync();
+
+      const results: Array<{
+        entity: EntityId;
+        position: Position;
+        velocity: Velocity;
+        health?: { value: Health };
+      }> = [];
+
+      query.forEach(
+        [positionComponent, velocityComponent, { optional: healthComponent }],
+        (entity, position, velocity, health) => {
+          results.push({ entity, position, velocity, health });
+        },
+      );
+
+      expect(results.length).toBe(3);
+
+      const result1 = results.find((r) => r.entity === entity1);
+      const result2 = results.find((r) => r.entity === entity2);
+      const result3 = results.find((r) => r.entity === entity3);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result3).toBeDefined();
+
+      expect(result1!.position).toEqual({ x: 1, y: 2 });
+      expect(result1!.velocity).toEqual({ x: 0.1, y: 0.2 });
+      expect(result1!.health).toEqual({ value: { value: 100 } });
+
+      expect(result2!.position).toEqual({ x: 3, y: 4 });
+      expect(result2!.velocity).toEqual({ x: 0.2, y: 0.3 });
+      expect(result2!.health).toBeUndefined();
+
+      expect(result3!.position).toEqual({ x: 5, y: 6 });
+      expect(result3!.velocity).toEqual({ x: 0.3, y: 0.4 });
+      expect(result3!.health).toEqual({ value: { value: 50 } });
+    });
+
+    it("should handle optional wildcard relations", () => {
+      const world = new World();
+
+      const wildcardPositionRelation = relation(positionComponent, "*");
+      const query = world.createQuery([velocityComponent]);
+
+      const entity1 = world.new();
+      const entity2 = world.new();
+      const targetEntity = world.new();
+
+      world.set(entity1, velocityComponent, { x: 0.1, y: 0.2 });
+      world.set(entity1, relation(positionComponent, targetEntity), { x: 1, y: 2 });
+
+      world.set(entity2, velocityComponent, { x: 0.2, y: 0.3 });
+      // entity2 has no position relation
+
+      world.sync();
+
+      const results: Array<{
+        entity: EntityId;
+        velocity: Velocity;
+        positionRelation?: { value: [EntityId<unknown>, Position][] };
+      }> = [];
+
+      query.forEach(
+        [velocityComponent, { optional: wildcardPositionRelation }],
+        (entity, velocity, positionRelation) => {
+          results.push({ entity, velocity, positionRelation });
+        },
+      );
+
+      expect(results.length).toBe(2);
+
+      const result1 = results.find((r) => r.entity === entity1);
+      const result2 = results.find((r) => r.entity === entity2);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+
+      expect(result1!.velocity).toEqual({ x: 0.1, y: 0.2 });
+      expect(result1!.positionRelation).toEqual({
+        value: [[targetEntity, { x: 1, y: 2 }]],
+      });
+
+      expect(result2!.velocity).toEqual({ x: 0.2, y: 0.3 });
+      expect(result2!.positionRelation).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/query/perf.test.ts

@@ -0,0 +1,99 @@
+import { World, component } from "../../index";
+
+// Define component types
+type Position = { x: number; y: number };
+type Velocity = { x: number; y: number };
+type Health = { value: number };
+
+// Create component IDs
+const positionComponent = component<Position>();
+const velocityComponent = component<Velocity>();
+const healthComponent = component<Health>();
+
+// Performance test function
+function performanceTest() {
+  console.log("=== Query Performance Test ===");
+
+  const world = new World();
+
+  // Create many entities
+  console.log("Creating 1000 entities...");
+  const startCreate = performance.now();
+
+  for (let i = 0; i < 1000; i++) {
+    const entity = world.new();
+
+    // Add position component
+    world.set(entity, positionComponent, {
+      x: Math.random() * 100,
+      y: Math.random() * 100,
+    });
+
+    // 50% of entities have velocity component
+    if (i % 2 === 0) {
+      world.set(entity, velocityComponent, {
+        x: Math.random() - 0.5,
+        y: Math.random() - 0.5,
+      });
+    }
+
+    // 25% of entities have health component
+    if (i % 4 === 0) {
+      world.set(entity, healthComponent, {
+        value: Math.floor(Math.random() * 100) + 1,
+      });
+    }
+  }
+
+  world.sync();
+
+  const endCreate = performance.now();
+  console.log(`Entity creation time: ${(endCreate - startCreate).toFixed(2)}ms`);
+
+  // Create queries
+  const positionVelocityQuery = world.createQuery([positionComponent, velocityComponent]);
+  const healthQuery = world.createQuery([healthComponent]);
+
+  // Test getEntitiesWithComponents performance
+  console.log("\nTesting getEntitiesWithComponents performance...");
+  const iterations = 100;
+
+  let totalTime = 0;
+  for (let i = 0; i < iterations; i++) {
+    const start = performance.now();
+    positionVelocityQuery.getEntitiesWithComponents([positionComponent, velocityComponent]);
+    const end = performance.now();
+    totalTime += end - start;
+  }
+  console.log(`Average getEntitiesWithComponents time: ${(totalTime / iterations).toFixed(4)}ms`);
+
+  // Test forEach performance
+  totalTime = 0;
+  for (let i = 0; i < iterations; i++) {
+    const start = performance.now();
+    positionVelocityQuery.forEach([positionComponent, velocityComponent], (_entity, _position, _velocity) => {
+      // No-op, just for measuring iteration performance
+    });
+    const end = performance.now();
+    totalTime += end - start;
+  }
+  console.log(`Average forEach time: ${(totalTime / iterations).toFixed(4)}ms`);
+
+  // Verify result correctness
+  const entitiesWithData = positionVelocityQuery.getEntitiesWithComponents([positionComponent, velocityComponent]);
+  console.log(`\nFound ${entitiesWithData.length} entities with position and velocity`);
+
+  let forEachCount = 0;
+  positionVelocityQuery.forEach([positionComponent, velocityComponent], () => {
+    forEachCount++;
+  });
+  console.log(`forEach iterated over ${forEachCount} entities`);
+
+  // Cleanup
+  positionVelocityQuery.dispose();
+  healthQuery.dispose();
+
+  console.log("\nPerformance test completed!");
+}
+
+performanceTest();