@latticexyz/recs 2.0.12-main-9be2bb86 → 2.0.12-main-e43c0938

package/src/Indexer.spec.ts

@@ -1,288 +0,0 @@
-import {
-  defineComponent,
-  setComponent,
-  removeComponent,
-  getComponentValue,
-  hasComponent,
-  withValue,
-  componentValueEquals,
-  getEntitiesWithValue,
-  overridableComponent,
-} from "./Component";
-import { createIndexer } from "./Indexer";
-import { Type } from "./constants";
-import { createEntity, getEntitySymbol } from "./Entity";
-import { AnyComponent, Entity, World } from "./types";
-import { createWorld } from "./World";
-
-describe("Indexer", () => {
-  let world: World;
-
-  beforeEach(() => {
-    world = createWorld();
-  });
-
-  it("emit changes to its stream", () => {
-    const entity = createEntity(world);
-    const component = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-
-    const mock = jest.fn();
-    component.update$.subscribe((update) => {
-      mock(update);
-    });
-
-    setComponent(component, entity, { x: 1, y: 2 });
-    setComponent(component, entity, { x: 7, y: 2 });
-    setComponent(component, entity, { x: 7, y: 2 });
-    removeComponent(component, entity);
-
-    expect(mock).toHaveBeenNthCalledWith(1, { entity, value: [{ x: 1, y: 2 }, undefined], component });
-    expect(mock).toHaveBeenNthCalledWith(2, {
-      entity,
-      component,
-      value: [
-        { x: 7, y: 2 },
-        { x: 1, y: 2 },
-      ],
-    });
-    expect(mock).toHaveBeenNthCalledWith(3, {
-      entity,
-      component,
-      value: [
-        { x: 7, y: 2 },
-        { x: 7, y: 2 },
-      ],
-    });
-    expect(mock).toHaveBeenNthCalledWith(4, { entity, component, value: [undefined, { x: 7, y: 2 }] });
-  });
-
-  describe("setComponent", () => {
-    let component: AnyComponent;
-    let entity: Entity;
-    let value: number;
-
-    beforeEach(() => {
-      component = defineComponent(world, { value: Type.Number }, { indexed: true });
-      entity = createEntity(world);
-      value = 1;
-      setComponent(component, entity, { value });
-    });
-
-    it("should store the component value", () => {
-      expect(component.values.value.get(getEntitySymbol(entity))).toBe(value);
-    });
-
-    it("should store the entity", () => {
-      expect(hasComponent(component, entity)).toBe(true);
-    });
-
-    it.todo("should store the value array");
-  });
-
-  describe("removeComponent", () => {
-    let component: AnyComponent;
-    let entity: Entity;
-    let value: number;
-
-    beforeEach(() => {
-      component = defineComponent(world, { value: Type.Number }, { indexed: true });
-      entity = createEntity(world);
-      value = 1;
-      setComponent(component, entity, { value });
-      removeComponent(component, entity);
-    });
-
-    it("should remove the component value", () => {
-      expect(component.values.value.get(getEntitySymbol(entity))).toBe(undefined);
-    });
-
-    it("should remove the entity", () => {
-      expect(hasComponent(component, entity)).toBe(false);
-    });
-
-    // it("shouldremove the component from the entity's component set", () => {
-    //   expect(world.entities.get(entity)?.has(component)).toBe(false);
-    // });
-  });
-
-  describe("hasComponent", () => {
-    it("should return true if the entity has the component", () => {
-      const component = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity = createEntity(world);
-      const value = { x: 1, y: 2 };
-      setComponent(component, entity, value);
-
-      expect(hasComponent(component, entity)).toEqual(true);
-    });
-  });
-
-  describe("getComponentValue", () => {
-    it("should return the correct component value", () => {
-      const component = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity = createEntity(world);
-      const value = { x: 1, y: 2 };
-      setComponent(component, entity, value);
-
-      const receivedValue = getComponentValue(component, entity);
-      expect(receivedValue).toEqual(value);
-    });
-  });
-
-  describe("getComponentValueStrict", () => {
-    it.todo("should return the correct component value");
-    it.todo("should error if the component value does not exist");
-  });
-
-  describe("componentValueEquals", () => {
-    it("values should equal equal values", () => {
-      const value1 = { x: 1, y: 2, z: "x" };
-      const value2 = { x: 1, y: 2, z: "x" };
-      const value3 = { x: "1", y: 2, z: "x" };
-
-      expect(componentValueEquals(value1, value2)).toBe(true);
-      expect(componentValueEquals(value2, value3)).toBe(false);
-    });
-  });
-
-  describe("withValue", () => {
-    it("should return a ComponentWithValue", () => {
-      const component = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const value = { x: 1, y: 2 };
-      const componentWithValue = withValue(component, value);
-      expect(componentWithValue).toEqual([component, value]);
-    });
-  });
-
-  describe("getEntitiesWithValue", () => {
-    it("Should return all and only entities with this value", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity1 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
-      createEntity(world, [withValue(Position, { x: 2, y: 1 })]);
-      createEntity(world);
-      const entity4 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
-
-      expect(getEntitiesWithValue(Position, { x: 1, y: 2 })).toEqual(new Set([entity1, entity4]));
-    });
-
-    it("Should keep the entities with value up to date", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number });
-      const entity1 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
-      const entity2 = createEntity(world, [withValue(Position, { x: 2, y: 1 })]);
-      createEntity(world);
-      const PositionIndexer = createIndexer(Position);
-      expect(getEntitiesWithValue(PositionIndexer, { x: 1, y: 2 })).toEqual(new Set([entity1]));
-
-      const entity3 = createEntity(world, [withValue(Position, { x: 1, y: 2 })]);
-      expect(getEntitiesWithValue(PositionIndexer, { x: 1, y: 2 })).toEqual(new Set([entity1, entity3]));
-
-      setComponent(Position, entity2, { x: 1, y: 2 });
-      expect(getEntitiesWithValue(PositionIndexer, { x: 1, y: 2 })).toEqual(new Set([entity1, entity2, entity3]));
-
-      setComponent(PositionIndexer, entity1, { x: 2, y: 2 });
-      expect(getEntitiesWithValue(PositionIndexer, { x: 1, y: 2 })).toEqual(new Set([entity2, entity3]));
-    });
-  });
-
-  describe("overridableComponent", () => {
-    it("should return a overridable component", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const OverridablePosition = overridableComponent(Position);
-      expect("addOverride" in OverridablePosition).toBe(true);
-      expect("addOverride" in OverridablePosition).toBe(true);
-    });
-
-    it("should mirror all values of the source component", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity1 = createEntity(world);
-      setComponent(Position, entity1, { x: 1, y: 2 });
-
-      const OverridablePosition = overridableComponent(Position);
-      expect(getComponentValue(OverridablePosition, entity1)).toEqual({ x: 1, y: 2 });
-    });
-
-    it("the overridable component should be updated if the original component is updated", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity1 = createEntity(world);
-      setComponent(Position, entity1, { x: 1, y: 2 });
-
-      const OverridableComponent = overridableComponent(Position);
-
-      setComponent(Position, entity1, { x: 2, y: 2 });
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 2 });
-
-      const entity2 = createEntity(world, [withValue(Position, { x: 3, y: 3 })]);
-      expect(getComponentValue(OverridableComponent, entity2)).toEqual({ x: 3, y: 3 });
-    });
-
-    it("should return the updated component value if there is a relevant update for the given entity", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity1 = createEntity(world);
-      const entity2 = createEntity(world);
-      setComponent(Position, entity1, { x: 1, y: 2 });
-      setComponent(Position, entity2, { x: 5, y: 6 });
-
-      const OverridableComponent = overridableComponent(Position);
-      OverridableComponent.addOverride("firstOverride", { entity: entity1, value: { x: 2, y: 3 } });
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
-      expect(getComponentValue(OverridableComponent, entity2)).toEqual({ x: 5, y: 6 });
-
-      OverridableComponent.addOverride("secondOverride", { entity: entity1, value: { x: 3, y: 3 } });
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 3, y: 3 });
-
-      OverridableComponent.removeOverride("secondOverride");
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
-
-      setComponent(Position, entity1, { x: 10, y: 20 });
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 2, y: 3 });
-
-      OverridableComponent.removeOverride("firstOverride");
-      expect(getComponentValue(OverridableComponent, entity1)).toEqual({ x: 10, y: 20 });
-    });
-
-    it("adding an override should trigger reactions depending on the getComponentValue of the overriden component", () => {
-      const Position = defineComponent(world, { x: Type.Number, y: Type.Number }, { indexed: true });
-      const entity1 = createEntity(world);
-      setComponent(Position, entity1, { x: 1, y: 2 });
-
-      const OverridablePosition = overridableComponent(Position);
-
-      const spy = jest.fn();
-      OverridablePosition.update$.subscribe(spy);
-
-      expect(spy).toHaveBeenCalledTimes(0);
-
-      OverridablePosition.addOverride("firstOverride", { entity: entity1, value: { x: 3, y: 3 } });
-      expect(spy).toHaveBeenCalledTimes(1);
-      expect(spy).toHaveBeenLastCalledWith({
-        entity: entity1,
-        component: OverridablePosition,
-        value: [
-          { x: 3, y: 3 },
-          { x: 1, y: 2 },
-        ],
-      });
-
-      OverridablePosition.removeOverride("firstOverride");
-      expect(spy).toHaveBeenCalledTimes(2);
-      expect(spy).toHaveBeenLastCalledWith({
-        entity: entity1,
-        component: OverridablePosition,
-        value: [
-          { x: 1, y: 2 },
-          { x: 3, y: 3 },
-        ],
-      });
-
-      OverridablePosition.addOverride("secondOverride", {
-        entity: "42" as Entity,
-        value: { x: 2, y: 3 },
-      });
-      expect(spy).toHaveBeenLastCalledWith({
-        entity: "42" as Entity,
-        component: OverridablePosition,
-        value: [{ x: 2, y: 3 }, undefined],
-      });
-      expect(spy).toHaveBeenCalledTimes(3);
-    });
-  });
-});

package/src/Indexer.ts

@@ -1,71 +0,0 @@
-import { getComponentEntities, getComponentValue } from "./Component";
-import { getEntityString, getEntitySymbol } from "./Entity";
-import { Component, ComponentValue, Entity, EntitySymbol, Indexer, Metadata, Schema } from "./types";
-
-/**
- * Create an indexed component from a given component.
- *
- * @remarks
- * An indexed component keeps a "reverse mapping" from {@link ComponentValue} to the Set of {@link createEntity Entities} with this value.
- * This adds a performance overhead to modifying component values and a memory overhead since in the worst case there is one
- * Set per entity (if every entity has a different component value).
- * In return the performance for querying for entities with a given component value is close to O(1) (instead of O(#entities) in a regular non-indexed component).
- * As a rule of thumb only components that are added to many entities and are queried with {@link HasValue} a lot should be indexed (eg. the Position component).
- *
- * @dev This could be made more (memory) efficient by using a hash of the component value as key, but would require handling hash collisions.
- *
- * @param component {@link defineComponent Component} to index.
- * @returns Indexed version of the component.
- */
-export function createIndexer<S extends Schema, M extends Metadata, T = unknown>(
-  component: Component<S, M, T>,
-): Indexer<S, M, T> {
-  const valueToEntities = new Map<string, Set<EntitySymbol>>();
-
-  function getEntitiesWithValue(value: ComponentValue<S, T>) {
-    const entities = valueToEntities.get(getValueKey(value));
-    return entities ? new Set([...entities].map(getEntityString)) : new Set<Entity>();
-  }
-
-  function getValueKey(value: ComponentValue<S, T>): string {
-    return Object.values(value).join("/");
-  }
-
-  function add(entity: EntitySymbol, value: ComponentValue<S, T> | undefined) {
-    if (!value) return;
-    const valueKey = getValueKey(value);
-    let entitiesWithValue = valueToEntities.get(valueKey);
-    if (!entitiesWithValue) {
-      entitiesWithValue = new Set<EntitySymbol>();
-      valueToEntities.set(valueKey, entitiesWithValue);
-    }
-    entitiesWithValue.add(entity);
-  }
-
-  function remove(entity: EntitySymbol, value: ComponentValue<S, T> | undefined) {
-    if (!value) return;
-    const valueKey = getValueKey(value);
-    const entitiesWithValue = valueToEntities.get(valueKey);
-    if (!entitiesWithValue) return;
-    entitiesWithValue.delete(entity);
-  }
-
-  // Initial indexing
-  for (const entity of getComponentEntities(component)) {
-    const value = getComponentValue(component, entity);
-    add(getEntitySymbol(entity), value);
-  }
-
-  // Keeping index up to date
-  const subscription = component.update$.subscribe(({ entity, value }) => {
-    // Remove from previous location
-    remove(getEntitySymbol(entity), value[1]);
-
-    // Add to new location
-    add(getEntitySymbol(entity), value[0]);
-  });
-
-  component.world.registerDisposer(() => subscription?.unsubscribe());
-
-  return { ...component, getEntitiesWithValue };
-}

package/src/Performance.spec.ts

@@ -1,153 +0,0 @@
-import { defineComponent as defineComponentV2, setComponent as setComponentV2 } from "./Component";
-import { createWorld as createWorldV2 } from "./World";
-import { createEntity as createEntityV2 } from "./Entity";
-import { Type as TypeV2 } from "./constants";
-import { HasValue as HasValueV2 } from "./Query";
-import { defineSystem } from "./System";
-
-export function timeIt(fn: () => unknown) {
-  const start = Date.now();
-  fn();
-  const end = Date.now();
-  const duration = end - start;
-  console.log("Duration:", duration);
-  return duration;
-}
-
-describe("V2", () => {
-  const size = 1000000;
-  it("measure creation of 1000000 entities", () => {
-    console.log("V2");
-    const world = createWorldV2();
-    const Position = defineComponentV2(world, { x: TypeV2.Number, y: TypeV2.Number });
-
-    timeIt(() => {
-      for (let i = 0; i < size; i++) {
-        const entity = createEntityV2(world);
-        setComponentV2(Position, entity, { x: 1, y: 1 });
-      }
-    });
-  });
-
-  it("measure creation of 1000000 entities and reacting to it", () => {
-    console.log("V2");
-    const world = createWorldV2();
-    const Position = defineComponentV2(world, { x: TypeV2.Number, y: TypeV2.Number });
-
-    defineSystem(world, [HasValueV2(Position, { x: 1, y: 1 })], (update) => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const e = update;
-    });
-
-    timeIt(() => {
-      for (let i = 0; i < size; i++) {
-        const entity = createEntityV2(world);
-        setComponentV2(Position, entity, { x: 1, y: 1 });
-      }
-    });
-  });
-});
-
-describe("TypedArray", () => {
-  let array: number[];
-  let typedArray: Uint32Array;
-  const size = 10000000;
-
-  beforeAll(() => {
-    // Set up array
-    array = [];
-    const randomOtherArr: number[] = [];
-    for (let i = 0; i < size; i++) {
-      array.push(i);
-      randomOtherArr.push(i);
-    }
-
-    // Set up buffer
-    const buffer = new ArrayBuffer(4 * size);
-    typedArray = new Uint32Array(buffer);
-
-    for (let i = 0; i < size; i++) {
-      typedArray[i] = i;
-    }
-  });
-
-  it.skip("measure time to create 10 million entite", () => {
-    console.log("Sparse array");
-    const sparse: number[] = [];
-    timeIt(() => {
-      for (let i = 0; i < size * 100; i += 100) {
-        sparse[i] = 0;
-      }
-    });
-
-    console.log("Dense array push");
-    const dense1: number[] = [];
-    timeIt(() => {
-      for (let i = 0; i < size * 100; i += 100) {
-        dense1.push(i);
-      }
-    });
-
-    console.log("Dense array set");
-    const dense2: number[] = [];
-    timeIt(() => {
-      for (let i = 0; i < size; i++) {
-        dense2[i] = i;
-      }
-    });
-
-    console.log("Map");
-    const map = new Map<number, number>();
-    timeIt(() => {
-      for (let i = 0; i < size * 100; i += 100) {
-        map.set(i, i);
-      }
-    });
-
-    console.log("Object");
-    const obj: { [key: number]: number } = {};
-    timeIt(() => {
-      for (let i = 0; i < size * 100; i += 100) {
-        obj[i] = i;
-      }
-    });
-  });
-
-  it.skip("measure time to iterate through regular array with 10 million entries", () => {
-    console.log("Regular array:");
-    timeIt(() => {
-      let sum = 0;
-      for (let i = 0; i < size; i++) {
-        sum += i;
-      }
-      console.log("Sum", sum);
-    });
-
-    console.log("Regular array iterator:");
-    timeIt(() => {
-      let sum = 0;
-      for (const i of array) {
-        sum += i;
-      }
-      console.log("Sum", sum);
-    });
-
-    console.log("Typed array:");
-    timeIt(() => {
-      let sum = 0;
-      for (let i = 0; i < size; i++) {
-        sum += typedArray[i];
-      }
-      console.log("Sum", sum);
-    });
-
-    console.log("Typed array iterator:");
-    timeIt(() => {
-      let sum = 0;
-      for (const i of typedArray) {
-        sum += i;
-      }
-      console.log("Sum", sum);
-    });
-  });
-});