@woosh/meep-engine 2.110.14 → 2.111.0

package/src/engine/ecs/EntityManager.spec.js

@@ -1,210 +0,0 @@
-import { EntityManager } from "./EntityManager.js";
-import { System, SystemState } from "./System.js";
-import { jest } from '@jest/globals';
-import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
-import { EntityComponentDataset } from "./EntityComponentDataset.js";
-
-/**
- *
- * @returns {Promise<EntityManager>}
- */
-function makeEm(systems = []) {
-    const em = new EntityManager();
-
-    //add systems
-    systems.forEach(s => em.addSystem(s));
-
-    return new Promise(function (resolve, reject) {
-        //startup
-        em.startup(function () {
-            resolve(em);
-        }, reject);
-    });
-}
-
-class DummyComponent {
-}
-
-class DummySystem extends System {
-    dependencies = [DummyComponent];
-}
-
-test("constructor doesn't throw", () => {
-    expect(() => new EntityManager()).not.toThrow();
-});
-
-test("startup with no systems without errors", () => {
-    const em = new EntityManager();
-
-    return new Promise(function (resolve, reject) {
-        //startup
-        em.startup(resolve, reject);
-    });
-});
-
-test("startup/shutdown with no systems without errors", async () => {
-    const em = new EntityManager();
-
-    await new Promise(function (resolve, reject) {
-        //startup
-        em.startup(resolve, reject);
-    });
-
-    await new Promise(function (resolve, reject) {
-        //shutdown
-        em.shutdown(resolve, reject)
-    });
-});
-
-test("startup/shutdown with dummy systems without errors", async () => {
-    const em = new EntityManager();
-
-    const dummySystem = new DummySystem();
-
-    const systemStartup = jest.spyOn(dummySystem, 'startup');
-    const systemShutdown = jest.spyOn(dummySystem, 'shutdown');
-
-    em.addSystem(dummySystem);
-
-    await new Promise(function (resolve, reject) {
-        //startup
-        em.startup(resolve, reject);
-    });
-
-    expect(systemStartup).toHaveBeenCalledTimes(1);
-    expect(systemShutdown).not.toHaveBeenCalled();
-
-    await new Promise(function (resolve, reject) {
-        //shutdown
-        em.shutdown(resolve, reject)
-    });
-
-    expect(systemStartup).toHaveBeenCalledTimes(1);
-    expect(systemShutdown).toHaveBeenCalledTimes(1);
-});
-
-test("call to 'simulate' propagate to registered system", () => {
-    const dummySystem = new DummySystem();
-    const update = jest.spyOn(dummySystem, 'update');
-
-    return makeEm([dummySystem])
-        .then((em) => {
-            em.simulate(7);
-
-            expect(update).toHaveBeenCalledTimes(1);
-            expect(update).toHaveBeenLastCalledWith(7);
-        });
-});
-
-
-test("call to 'simulate' ticks fixed update correctly", async () => {
-
-    const dummySystem = new DummySystem();
-    const fixedUpdate = jest.spyOn(dummySystem, 'fixedUpdate');
-
-    const em = await makeEm([dummySystem]);
-
-    em.fixedUpdateStepSize = 1.1;
-
-    em.simulate(3.3001);
-
-    expect(fixedUpdate).toHaveBeenCalledTimes(3);
-    expect(fixedUpdate).toHaveBeenLastCalledWith(1.1);
-});
-
-test("hasSystem", async () => {
-
-    const dummySystem = new DummySystem();
-    const em = await makeEm([]);
-
-    expect(em.hasSystem(DummySystem)).toBe(false);
-
-    await em.addSystem(dummySystem);
-
-    expect(em.hasSystem(DummySystem)).toBe(true);
-});
-
-test("addSystem", async () => {
-    const em = await makeEm([]);
-
-    const s1 = new DummySystem();
-
-    await em.addSystem(s1);
-
-    expect(s1.state.get()).toEqual(SystemState.RUNNING)
-
-    // system is already added, expect silent return
-    expect(() => em.addSystem(s1)).not.toThrow();
-
-    // 2 systems of the same class are not allowed
-    expect(() => em.addSystem(new DummySystem())).toThrow(IllegalStateException);
-});
-
-test("add system to running manager", async () => {
-
-    const em = new EntityManager();
-
-    await new Promise((resolve, reject) => em.startup(resolve, reject));
-
-    const system = new DummySystem();
-
-    await em.addSystem(system);
-
-    expect(em.hasSystem(DummySystem)).toBe(true);
-});
-
-test("removeSystem", async () => {
-
-    const system = new DummySystem();
-
-    const em = await makeEm([system]);
-
-    expect(await em.removeSystem(system)).toBe(true);
-
-    expect(em.hasSystem(DummySystem)).toBe(false);
-
-    expect(system.state.get()).toEqual(SystemState.STOPPED);
-
-    // Try again, this time we expect nothing to happen
-    expect(await em.removeSystem(system)).toEqual(false);
-});
-
-test("attempt to detach dataset when none is attached", () => {
-    const manager = new EntityManager();
-
-    expect(() => manager.detachDataSet()).not.toThrow();
-
-    // do it second time, in case something changes in the above call
-    expect(() => manager.detachDataSet()).not.toThrow();
-});
-
-test("getComponentTypeMap with 1 system", async () => {
-
-    const em = await makeEm([
-        new DummySystem()
-    ]);
-
-    expect(em.getComponentTypeMap()).toEqual([DummyComponent]);
-});
-
-test("attempting to attach another dataset before detaching previous one should throw", () => {
-
-    const em = new EntityManager();
-
-    em.attachDataSet(new EntityComponentDataset());
-
-    expect(() => em.attachDataSet(new EntityComponentDataset())).toThrow();
-
-});
-
-test("attaching same dataset should succeed", () => {
-
-    const em = new EntityManager();
-
-    const ecd = new EntityComponentDataset();
-    em.attachDataSet(ecd);
-
-    em.attachDataSet(ecd); // second time
-
-    expect(em.dataset).toBe(ecd);
-});

package/src/engine/ecs/EntityObserver.spec.js

@@ -1,184 +0,0 @@
-import { jest } from '@jest/globals';
-import { noop } from "../../core/function/noop.js";
-import GridPosition from "../grid/position/GridPosition.js";
-import Entity from "./Entity.js";
-import { EntityComponentDataset } from "./EntityComponentDataset.js";
-import { EntityObserver } from "./EntityObserver.js";
-import { Transform } from "./transform/Transform.js";
-
-/**
- *
- * @return {EntityComponentDataset}
- */
-function makeDataset() {
-
-    const dataset = new EntityComponentDataset();
-
-    dataset.setComponentTypeMap([Transform, GridPosition]);
-
-    return dataset;
-}
-
-test("valid constructor invocation does not throw", () => {
-    new EntityObserver([Transform, GridPosition], noop, noop);
-});
-
-test("callbacks are not invoked in the constructor", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    expect(completed).not.toHaveBeenCalled();
-    expect(broken).not.toHaveBeenCalled();
-});
-
-test("existing entities that match are supplied via callback when attaching", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-
-    const dataset = makeDataset();
-
-    const t0 = new Transform();
-    const g0 = new GridPosition();
-    const entity0 = new Entity().add(t0).add(g0).build(dataset);
-
-    const t1 = new Transform();
-    const g1 = new GridPosition();
-    const entity1 = new Entity().add(t1).add(g1).build(dataset);
-
-    new Entity().add(new Transform()).build(dataset);
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    observer.connect(dataset);
-
-    expect(broken).not.toHaveBeenCalled();
-    expect(completed).toHaveBeenCalledTimes(2);
-
-    expect(completed.mock.calls[0]).toEqual([t0, g0, entity0]);
-    expect(completed.mock.calls[1]).toEqual([t1, g1, entity1]);
-});
-
-test("completed matches are observed when they happen after attachment", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-    const dataset = makeDataset();
-
-    const t0 = new Transform();
-    const g0 = new GridPosition();
-    const entity0 = new Entity().add(t0).build(dataset);
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    observer.connect(dataset);
-
-    expect(broken).not.toHaveBeenCalled();
-    expect(completed).not.toHaveBeenCalled();
-
-    dataset.addComponentToEntity(entity0, g0);
-
-    expect(completed).toHaveBeenCalledTimes(1);
-
-    expect(completed.mock.calls[0]).toEqual([t0, g0, entity0]);
-});
-
-test("broken matches are observed", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-
-    const dataset = makeDataset();
-    const t0 = new Transform();
-    const g0 = new GridPosition();
-    const entityBuilder = new Entity().add(t0).add(g0);
-    const entity0 = entityBuilder.build(dataset);
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    observer.connect(dataset);
-
-    entityBuilder.removeComponent(GridPosition);
-
-    expect(broken).toHaveBeenCalledTimes(1);
-
-    expect(broken.mock.calls[0]).toEqual([t0, g0, entity0]);
-});
-
-test("matching entities added after connect are observed", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-
-    const dataset = makeDataset();
-    const t0 = new Transform();
-    const g0 = new GridPosition();
-    const entityBuilder = new Entity().add(t0).add(g0);
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    const entity0 = entityBuilder.build(dataset);
-
-    observer.connect(dataset);
-
-    expect(completed).toHaveBeenCalledTimes(1);
-
-    expect(completed).toHaveBeenLastCalledWith(t0, g0, entity0);
-});
-
-test("match after connect and break", () => {
-    const completed = jest.fn();
-    const broken = jest.fn();
-
-    const dataset = makeDataset();
-    const t0 = new Transform();
-    const g0 = new GridPosition();
-    const entityBuilder = new Entity().add(t0).add(g0);
-
-    const observer = new EntityObserver([Transform, GridPosition], completed, broken);
-
-    const entity0 = entityBuilder.build(dataset);
-
-    //observe completed
-    observer.connect(dataset);
-
-    expect(completed).toHaveBeenCalledTimes(1);
-
-    expect(completed).toHaveBeenLastCalledWith(t0, g0, entity0);
-
-    //break
-    entityBuilder.removeComponent(GridPosition);
-
-    expect(broken).toHaveBeenCalledTimes(1);
-
-    expect(broken).toHaveBeenLastCalledWith(t0, g0, entity0);
-
-    //remove last component
-    entityBuilder.removeComponent(Transform);
-
-    //broken shouldn't be called more
-    expect(broken).toHaveBeenCalledTimes(1);
-
-    //completed shouldn't be called more
-    expect(completed).toHaveBeenCalledTimes(1);
-
-    //remove entity
-    entityBuilder.destroy();
-
-    //broken shouldn't be called more
-    expect(broken).toHaveBeenCalledTimes(1);
-
-    //completed shouldn't be called more
-    expect(completed).toHaveBeenCalledTimes(1);
-});
-
-test("disconnect doesn't throw", () => {
-    const dataset = makeDataset();
-    const observer = new EntityObserver([Transform, GridPosition], noop, noop);
-
-    observer.connect(dataset);
-
-    observer.disconnect();
-});

package/src/engine/ecs/animation/Animation.spec.js

@@ -1,22 +0,0 @@
-import { Animation } from "./Animation.js";
-import { AnimationClip } from "./AnimationClip.js";
-
-test("constructor does not throw", () => {
-    new Animation()
-});
-
-test("equality", () => {
-
-    const a = new Animation();
-    const b = new Animation();
-
-    expect(a.equals(b)).toBe(true);
-
-    a.clips.add(new AnimationClip());
-
-    expect(a.equals(b)).toBe(false);
-
-    b.clips.add(new AnimationClip());
-
-    expect(a.equals(b)).toBe(true);
-});

package/src/engine/ecs/animation/AnimationClip.spec.js

@@ -1,5 +0,0 @@
-import { AnimationClip } from "./AnimationClip.js";
-
-test("constructor does not throw", () => {
-    expect(() => new AnimationClip()).not.toThrow();
-});

package/src/engine/ecs/components/Tag.spec.js

@@ -1,47 +0,0 @@
-import Tag from "./Tag.js";
-
-test("constructor", () => {
-    new Tag();
-});
-
-test("containsOneOf", () => {
-
-    const tag = Tag.fromJSON(['a', 'b']);
-
-    expect(tag.containsOneOf([])).toBe(false);
-    expect(tag.containsOneOf(['c'])).toBe(false);
-    expect(tag.containsOneOf(['a'])).toBe(true);
-    expect(tag.containsOneOf(['b'])).toBe(true);
-    expect(tag.containsOneOf(['a', 'b'])).toBe(true);
-
-});
-
-test("hash", () => {
-
-    const tag = Tag.fromJSON(['a', 'b']);
-
-    const hash = tag.hash();
-
-    expect(tag.hash()).toEqual(hash);
-
-    expect(typeof hash).toBe("number");
-    expect(Number.isInteger(hash)).toBe(true);
-});
-
-test("equals", () => {
-
-
-    const a = Tag.fromJSON(['a', 'b']);
-    const b = Tag.fromJSON([]);
-    const c = Tag.fromJSON(['a']);
-    const d = Tag.fromJSON(['b']);
-    const e = Tag.fromJSON(['a', 'b']);
-    const f = Tag.fromJSON(['a', 'c']);
-
-    expect(a.equals(b)).toBe(false);
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-    expect(a.equals(e)).toBe(true);
-    expect(a.equals(f)).toBe(false);
-
-});

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.spec.js

@@ -1,126 +0,0 @@
-import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { DynamicRuleDescriptionTable } from "./DynamicRuleDescriptionTable.js";
-import {
-    createRandomReactiveExpression
-} from "../../../../core/model/reactive/model/util/createRandomReactiveExpression.js";
-import { ReactiveReference } from "../../../../core/model/reactive/model/terminal/ReactiveReference.js";
-import { ReactiveLiteralNumber } from "../../../../core/model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveLiteralString } from "../../../../core/model/reactive/model/terminal/ReactiveLiteralString.js";
-import { ReactiveLiteralBoolean } from "../../../../core/model/reactive/model/terminal/ReactiveLiteralBoolean.js";
-import { DynamicRuleDescription } from "./DynamicRuleDescription.js";
-import DataType from "../../../../core/parser/simple/DataType.js";
-import { randomFromArray } from "../../../../core/math/random/randomFromArray.js";
-import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetween.js";
-import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
-
-describe.skip('performance', () => {
-
-    test('match performance', () => {
-        const random = seededRandom(12319);
-
-        const table = new DynamicRuleDescriptionTable();
-
-
-        const names = [];
-
-        const NAME_COUNT = 100;
-        for (let i = 0; i < NAME_COUNT; i++) {
-            names.push(`n${i}`);
-        }
-
-        const references = names.map(n => {
-            const ref = new ReactiveReference(n);
-
-            ref.dataType = DataType.Number;
-
-            return ref;
-        });
-
-        const literals = [];
-
-        for (let i = 0; i < 5; i++) {
-            literals.push(ReactiveLiteralNumber.from(randomFloatBetween(random, -10, 10)));
-        }
-
-        for (let i = 0; i < 5; i++) {
-            literals.push(ReactiveLiteralString.from(`string-${i}`));
-        }
-
-        literals.push(ReactiveLiteralBoolean.from(true));
-        literals.push(ReactiveLiteralBoolean.from(false));
-
-        const terminals = references.concat(literals);
-
-        const expressions = [];
-
-        const EXPRESSION_COUNT = 5000;
-        for (let i = 0; i < EXPRESSION_COUNT; i++) {
-
-            let exp;
-
-            do {
-                exp = createRandomReactiveExpression(random, terminals, randomIntegerBetween(random, 3, 15));
-            } while (exp.dataType !== DataType.Boolean);
-
-            expressions.push(exp);
-
-
-            const r = new DynamicRuleDescription();
-            r.id = `id-${i}`;
-            r.condition = exp;
-
-            r.build();
-
-            table.add(r);
-        }
-
-        table.buildIndex();
-
-        const contexts = [];
-
-        const CONTEXT_COUNT = 5000;
-
-        for (let i = 0; i < CONTEXT_COUNT; i++) {
-            const v = {};
-
-            for (let j = 0; j < NAME_COUNT; j++) {
-                const roll = random();
-
-                if (roll < 0.03) {
-                    continue;
-                }
-
-                const name = names[j];
-
-                v[name] = randomIntegerBetween(random, 3, 15);
-            }
-
-            contexts[i] = v;
-        }
-
-        const prewarm_random = seededRandom(63);
-
-        // pre-warm code
-        for (let i = 0; i < 10; i++) {
-
-            const context = randomFromArray(prewarm_random, contexts);
-
-            table.matchBest(context);
-        }
-
-        const t0 = performance.now();
-
-        for (let i = 0; i < CONTEXT_COUNT; i++) {
-            const context = contexts[i];
-
-            table.matchBest(context);
-        }
-
-        const overall_time = (performance.now() - t0) / 1000;
-
-
-        const overall_time_ps = overall_time * 1e12;
-
-        console.log(`Time per expression: ${Math.round(overall_time_ps / (CONTEXT_COUNT * EXPRESSION_COUNT))}ps(picoseconds)`);
-    });
-});

package/src/engine/ecs/fow/FogOfWar.spec.js

@@ -1,13 +0,0 @@
-import { FogOfWar } from "./FogOfWar.js";
-
-test('getWorldClearance', () => {
-    const fog = new FogOfWar();
-
-    fog.resize(1, 1, 2);
-
-    expect(fog.getWorldClearance(1, 1)).toBe(255);
-
-    fog.reveal(0, 0, 0.5);
-
-    expect(fog.getWorldClearance(1, 1)).toBe(0);
-});

package/src/engine/ecs/guid/UUID.spec.js

@@ -1,100 +0,0 @@
-import { UUID } from "./UUID.js";
-
-test("uniqueness out of 2", () => {
-    const a = UUID.v1();
-    const b = UUID.v1();
-
-    expect(a.equals(b)).toBe(false);
-});
-
-test("equality", () => {
-    const a = UUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
-    const b = UUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
-
-    expect(a.equals(b)).toBe(true);
-
-    b.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
-
-    expect(a.equals(b)).toBe(false);
-});
-
-test("hash stability", () => {
-    const guid = new UUID();
-
-    expect(guid.hash()).toBe(guid.hash());
-});
-
-test("copy", () => {
-    const a = UUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
-    const a_string = a.toString();
-
-    const b = UUID.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
-
-    expect(a.equals(b)).toBe(false);
-
-    b.copy(a);
-
-    expect(a.equals(b)).toBe(true);
-
-    // make sure that "a" is not changed
-    expect(a.toString()).toEqual(a_string);
-});
-
-test("to/from JSON consistency", () => {
-    const a = UUID.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
-
-    const b = new UUID();
-
-    b.fromJSON(a.toJSON());
-
-    expect(b.equals(a)).toBe(true)
-});
-
-test(".data setter performs a copy instead of assignment", () => {
-    const id = new UUID();
-
-    const data = new Uint8Array(16);
-
-    id.data = data;
-
-    expect(id.data).not.toBe(data);
-});
-
-test(".data set/get", () => {
-    const a = new UUID();
-
-    const sample_0 = [
-        0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF,
-    ];
-
-    a.data = sample_0;
-
-    expect(Array.from(a.data)).toEqual(sample_0);
-
-    const sample_1 = [
-        0x00, 0x01, 0x02, 0x03,
-        0x04, 0x05, 0x06, 0x07,
-        0x08, 0x09, 0x0A, 0x0B,
-        0x0C, 0x0D, 0x0E, 0x0F,
-    ];
-
-    a.data = sample_1;
-
-    expect(Array.from(a.data)).toEqual(sample_1);
-});
-
-test("version bits in v4", () => {
-    const uuid = UUID.v4();
-
-    expect((uuid.data[6] >> 4) & 0xF).toEqual(4);
-});
-
-test("static 'string' method",()=>{
-    const s = UUID.string();
-
-    expect(typeof s).toBe("string");
-    expect(s.length).toBe(36);
-});