@woosh/meep-engine 2.110.14 → 2.110.15

package/src/engine/intelligence/mcts/MonteCarlo.spec.js

@@ -1,244 +0,0 @@
-import { jest } from '@jest/globals';
-import Vector1 from "../../../core/geom/Vector1.js";
-import { MonteCarloTreeSearch } from "./MonteCarlo.js";
-import { MoveEdge } from "./MoveEdge.js";
-import { StateType } from "./StateNode.js";
-
-function cloneObject(o) {
-    return o.clone();
-}
-
-function incrementVector1(v) {
-    return v._add(1);
-}
-
-test("Simulator constructor doesn't throw", () => {
-    new MonteCarloTreeSearch();
-});
-
-test("Simulator initialization", () => {
-    const sim = new MonteCarloTreeSearch();
-
-    function expand(s) {
-        if (s < 3) {
-            return [MoveEdge.fromFunction(incrementVector1)];
-        }
-    }
-
-    sim.initialize({
-        rootState: new Vector1(1),
-        computeValidMoves: expand,
-        computeTerminalFlag: v => v === 3,
-        cloneState: cloneObject
-    });
-
-    expect(sim.computeValidMoves).toBe(expand);
-
-    expect(sim.root).toBeDefined();
-
-    expect(sim.rootState.getValue()).toBe(1);
-});
-
-
-test("Depth of exploration limit", () => {
-    const sim = new MonteCarloTreeSearch();
-
-    sim.maxExplorationDepth = 10;
-
-    const expand = jest.fn(function (s) {
-        return [MoveEdge.fromFunction(incrementVector1)];
-    });
-
-
-    sim.initialize({
-        rootState: new Vector1(1),
-        computeValidMoves: expand,
-        computeTerminalFlag: v => StateType.Undecided,
-        cloneState: cloneObject
-    });
-
-    sim.playout();
-
-    expect(expand).toBeCalledTimes(10);
-});
-
-test("Single linear playout", () => {
-    const sim = new MonteCarloTreeSearch();
-
-    const expand = jest.fn(function (s) {
-        return [MoveEdge.fromFunction(incrementVector1)];
-    });
-
-    function computeTerminalFlag(v) {
-        return v.getValue() === 3 ? StateType.Tie : StateType.Undecided;
-    }
-
-    sim.initialize({
-        rootState: new Vector1(1),
-        computeValidMoves: expand,
-        computeTerminalFlag,
-        cloneState: cloneObject
-    });
-
-    sim.playout();
-
-    expect(expand).toBeCalledTimes(2);
-
-    expect(sim.root.moves.length).toBe(1);
-
-    expect(sim.root.moves[0].target.moves.length).toBe(1);
-});
-
-class TTTState {
-    constructor() {
-        this.crossTurn = true;
-        this.data = new Array(9);
-        this.data.fill(-1);
-    }
-
-    copy(other) {
-        const data = this.data;
-        const length = data.length;
-
-        for (let i = 0; i < length; i++) {
-            data[i] = other.data[i];
-        }
-
-        this.crossTurn = other.crossTurn;
-    }
-
-    clone() {
-        const result = new TTTState();
-        result.copy(this);
-
-        return result;
-    }
-
-    playSquare(index) {
-        this.data[index] = this.crossTurn ? 1 : 2;
-        this.crossTurn = !this.crossTurn;
-    }
-
-    countEmpty() {
-        let result = 0;
-
-        this.traverseEmpty(i => result++);
-
-        return result;
-    }
-
-    traverseEmpty(v) {
-        const data = this.data;
-        const length = data.length;
-
-        for (let i = 0; i < length; i++) {
-            if (data[i] === -1) {
-                v(i);
-            }
-        }
-    }
-
-    winingSide() {
-        const data = this.data;
-
-        function checkWin(offset, stride) {
-            let prevValue = data[offset];
-
-            let i;
-
-            let count = 1;
-
-            for (i = offset + stride; i < 9, count < 3; i += stride, count++) {
-                const v = data[i];
-                if (v !== prevValue) {
-                    return -1;
-                } else {
-                    prevValue = v;
-                }
-            }
-
-            return prevValue;
-        }
-
-        const conditions = [
-            //horizontal
-            [0, 1],
-            [3, 1],
-            [6, 1],
-            //vertical
-            [0, 3],
-            [1, 3],
-            [2, 3],
-            //diagonal
-            [0, 4],
-            [2, 2]
-        ];
-
-        for (let i = 0; i < conditions.length; i++) {
-            const condition = conditions[i];
-
-            const side = checkWin(condition[0], condition[1]);
-
-            if (side !== -1) {
-                return side;
-            }
-        }
-
-        return -1;
-    }
-}
-
-test("10 steps through tic-tac-toe terminates", () => {
-    const sim = new MonteCarloTreeSearch();
-
-    const expand = jest.fn(function (s) {
-        const result = [];
-
-        s.traverseEmpty(index => {
-            const edge = MoveEdge.fromFunction(s => {
-
-                s.playSquare(index);
-
-                return s;
-            });
-
-            result.push(edge);
-        });
-
-        return result;
-    });
-
-    function computeTerminalFlag(s) {
-        const winingSide = s.winingSide();
-
-
-        if (winingSide === 1) {
-            return StateType.Win;
-        } else if (winingSide === 2) {
-            return StateType.Loss;
-        } else {
-            const c = s.countEmpty();
-            if (c === 0) {
-                return StateType.Tie;
-            } else {
-                return StateType.Undecided;
-            }
-        }
-    }
-
-    const initialState = new TTTState();
-
-    sim.initialize({
-        rootState: initialState,
-        computeValidMoves: expand,
-        computeTerminalFlag,
-        cloneState: cloneObject
-    });
-
-
-    for (let i = 0; i < 10; i++) {
-        sim.playout();
-    }
-
-
-});

package/src/engine/intelligence/mcts/StateNode.spec.js

@@ -1,49 +0,0 @@
-import { StateNode, StateType } from "./StateNode.js";
-import { MoveEdge } from "./MoveEdge.js";
-import { jest } from '@jest/globals';
-
-test("expand a node with no moves", () => {
-    const node = new StateNode();
-
-    const expand = jest.fn(function (x) {
-        expect(x).toBe('cat');
-
-        return [];
-    });
-
-    node.expand('cat', expand, (n) => n === "cat");
-
-    expect(node.moves).not.toBeNull();
-
-    expect(node.moves.length).toBe(0);
-});
-
-test("expand a node with 1 move", () => {
-    const node = new StateNode();
-
-    const expand = jest.fn(function (x) {
-        expect(x).toBe('cat');
-
-        return [
-            MoveEdge.fromFunction(state => {
-                expect(state).toBe('cat');
-
-                return "hello"
-            })
-        ];
-    });
-
-    node.expand('cat', expand, (n) => n === "hello" ? StateType.Win : StateType.Undecided);
-
-    expect(node.moves).not.toBeNull();
-
-    expect(node.moves.length).toBe(1);
-
-    const moveEdge = node.moves[0];
-
-    expect(moveEdge).not.toBeNull();
-    expect(moveEdge).toBeDefined();
-
-    expect(moveEdge instanceof MoveEdge).toBe(true);
-    expect(moveEdge.move).toBeDefined();
-});

package/src/engine/intelligence/optimization/RandomOptimizer.spec.js

@@ -1,57 +0,0 @@
-import { RandomOptimizer } from "./RandomOptimizer.js";
-
-test("sort optimization", () => {
-    /**
-     *
-     * @type {RandomOptimizer<number[]>}
-     */
-    const op = new RandomOptimizer();
-
-    op.initialize({
-        state: [5, 4, 3, 2, 1],
-        computeValidActions(s) {
-            const result = [];
-
-            const l = s.length;
-
-            for (let i = 0; i < l; i++) {
-                for (let j = i + 1; j < l; j++) {
-
-                    const i0 = i;
-                    const i1 = j;
-
-                    result.push(function (s) {
-                        const temp = s[i0];
-
-                        s[i0] = s[i1];
-                        s[i1] = temp;
-                    });
-                }
-            }
-
-            return result;
-        },
-        cloneState(s) {
-            return s.slice();
-        },
-        scoreFunction(s) {
-            let r = 0;
-
-            for (let i = 0; i < s.length; i++) {
-                const e = s[i];
-
-                r += i * e;
-            }
-
-            return r;
-        }
-    });
-
-    for (let i = 0; i < 1000; i++) {
-        if (!op.stepThrough(100)) {
-            break;
-        }
-    }
-
-    expect(op.state).toEqual([1, 2, 3, 4, 5]);
-});

package/src/engine/intelligence/resource/ResourceAllocationSolver.spec.js

@@ -1,104 +0,0 @@
-import { ResourceAllocationSolver } from "./ResourceAllocationSolver.js";
-import { Resource } from "./Resource.js";
-import { ResourceAllocation } from "./ResourceAllocation.js";
-import { ResourceAllocationBid } from "./ResourceAllocationBid.js";
-
-test("constructor doesn't throw", () => {
-    new ResourceAllocationSolver();
-});
-
-test("solve empty", () => {
-    const solver = new ResourceAllocationSolver();
-
-    const allocations = solver.solve();
-
-    expect(allocations).toEqual([]);
-});
-
-test("solve for 1 resource exact assignment", () => {
-    const solver = new ResourceAllocationSolver();
-
-    solver.addResource(new Resource(1, "a"));
-
-    const bidA = new ResourceAllocationBid(
-        new ResourceAllocation([
-            new Resource(1, "a")
-        ]),
-        1
-    );
-
-    solver.addBid(
-        bidA
-    );
-
-    const allocations = solver.solve();
-
-    expect(allocations).toEqual([bidA]);
-});
-
-test("solve for 1 resource, 2 different bids", () => {
-    const solver = new ResourceAllocationSolver();
-
-    solver.addResource(new Resource(1, "a"));
-
-    const bidA = new ResourceAllocationBid(
-        new ResourceAllocation([
-            new Resource(1, "a")
-        ]),
-        1
-    );
-
-    const bidB = new ResourceAllocationBid(
-        new ResourceAllocation([
-            new Resource(1, "a")
-        ]),
-        1
-    );
-
-    bidA.weight = 1;
-    bidB.weight = 2;
-
-    solver.addBids([
-        bidA,
-        bidB
-    ]);
-
-    const allocations = solver.solve();
-
-    expect(allocations.length).toEqual(1);
-    expect(allocations[0]).toBe(bidB);
-});
-
-test("solve for 2 resource, 2 different bids", () => {
-    const solver = new ResourceAllocationSolver();
-
-    solver.addResource(new Resource(2, "a"));
-
-    const bidA = new ResourceAllocationBid(
-        new ResourceAllocation([
-            new Resource(1, "a")
-        ]),
-        1
-    );
-
-    const bidB = new ResourceAllocationBid(
-        new ResourceAllocation([
-            new Resource(1, "a")
-        ]),
-        1
-    );
-
-    bidA.weight = 1;
-    bidB.weight = 2;
-
-    solver.addBids([
-        bidA,
-        bidB
-    ]);
-
-    const allocations = solver.solve();
-
-    expect(allocations.length).toBe(2);
-    expect(allocations.indexOf(bidA)).not.toBe(-1);
-    expect(allocations.indexOf(bidB)).not.toBe(-1);
-});

package/src/engine/intelligence/resource/StrategicResourceAllocator.spec.js

@@ -1,46 +0,0 @@
-import { StrategicResourceAllocator } from "./StrategicResourceAllocator.js";
-import { Resource } from "./Resource.js";
-import { TacticalModule } from "./TacticalModule.js";
-import { ResourceAllocationBid } from "./ResourceAllocationBid.js";
-import { ResourceAllocation } from "./ResourceAllocation.js";
-import { jest } from '@jest/globals';
-
-test("constructor doesn't throw", () => {
-    new StrategicResourceAllocator();
-});
-
-test("allocate 0 resources with no modules", () => {
-    const allocator = new StrategicResourceAllocator();
-
-    expect(() => {
-        allocator.allocate([]);
-    }).not.toThrow();
-});
-
-test("allocate 1 resource with no modules", () => {
-    const allocator = new StrategicResourceAllocator();
-
-    expect(() => {
-        allocator.allocate([new Resource(1, "a")]);
-    }).not.toThrow();
-});
-
-test("allocate 1 resource with 1 module", () => {
-    const allocator = new StrategicResourceAllocator();
-
-    const module = new TacticalModule();
-
-    module.collectBids = jest.fn(resources => {
-        return Promise.resolve([
-            new ResourceAllocationBid(new ResourceAllocation(resources), 1)
-        ]);
-    });
-
-    allocator.addTacticalModule(module);
-
-    const resources = [new Resource(1, "a")];
-    allocator.allocate(resources);
-
-    expect(module.collectBids).toHaveBeenCalledTimes(1);
-    expect(module.collectBids).toHaveBeenCalledWith(resources);
-});

package/src/engine/knowledge/database/StaticKnowledgeDataTable.spec.js

@@ -1,26 +0,0 @@
-import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
-
-test("constructor does not throw", () => {
-    expect(() => new StaticKnowledgeDataTable()).not.toThrow();
-});
-
-test("resetting empty works as expected", () => {
-    const table = new StaticKnowledgeDataTable();
-
-    table.reset();
-
-    expect(table.size()).toEqual(0);
-});
-
-test("getter", () => {
-
-    const table = new StaticKnowledgeDataTable();
-
-    expect(table.get("x")).toEqual(null);
-
-    const item = { id: "x" };
-
-    table.add(item);
-
-    expect(table.get('x')).toBe(item);
-});

package/src/engine/knowledge/database/StaticKnowledgeDatabase.spec.js

@@ -1,23 +0,0 @@
-import { StaticKnowledgeDatabase } from "./StaticKnowledgeDatabase.js";
-import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
-
-test("constructor does not throw", () => {
-    new StaticKnowledgeDatabase()
-});
-
-test("reset empty", () => {
-    const database = new StaticKnowledgeDatabase();
-
-    database.reset();
-});
-
-test("add/get", () => {
-    const database = new StaticKnowledgeDatabase();
-
-    const table = new StaticKnowledgeDataTable();
-    database.add("x", "y", table)
-
-    const actual = database.getTable('x');
-
-    expect(actual).toBe(table);
-});