@irysius/grid-math/pathfinding/PathExecutor.js

Tools to assist with grid math and algorithms

(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "../Vector2", "../helpers/Iterable", "../WorldPosition"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    const Vector2_1 = require("../Vector2");
    const Iterable_1 = require("../helpers/Iterable");
    const WorldPosition_1 = require("../WorldPosition");
    function asStep(curr, sw) {
        return {
            curr,
            next: sw.nextValues[0]
        };
    }
    function PathExecutor(path, msPerStep) {
        let _sw = Iterable_1.SlidingWindow(path, { prevCapacity: 0, nextCapacity: 1 });
        let sw = Iterable_1.map(asStep)(_sw);
        // the first step should really be where you're at.
        let { value: step, done } = sw.next();
        let value = step.curr;
        let msStep = 0;
        let delta = createDelta(step);
        function createDelta(step) {
            // (next - curr) / msPerStep
            if (!step.next) {
                return WorldPosition_1.create(0, 0);
            }
            else {
                return Vector2_1.multiply(Vector2_1.subtract(step.next, step.curr), 1 / msPerStep);
            }
        }
        function update(msElapsed) {
            if (done) {
                return;
            }
            msStep += msElapsed;
            // In the event msElapsed is way bigger than msPerStep, we need to ff to the correct step.
            let overflowTicks = 0;
            while (msStep > msPerStep) {
                msStep -= msPerStep;
                overflowTicks++;
            }
            if (overflowTicks) {
                let i, next, _step;
                for (i = 0; i < overflowTicks; ++i) {
                    next = sw.next();
                    // break early if there's no more steps
                    if (next.done) {
                        break;
                    }
                    _step = next.value || step;
                }
                delta = createDelta(_step);
                // need to adjust with the remainder ms
                value = Vector2_1.add(_step.curr, Vector2_1.multiply(delta, msStep));
                done = next.done;
            }
            else {
                // need to just add the delta to the current value
                value = Vector2_1.add(value, Vector2_1.multiply(delta, msElapsed));
            }
        }
        let proxy = { update };
        Object.defineProperty(proxy, 'value', {
            get: () => value, enumerable: true
        });
        Object.defineProperty(proxy, 'done', {
            get: () => done, enumerable: true
        });
        return proxy;
    }
    exports.PathExecutor = PathExecutor;
});