@woosh/meep-engine 2.51.0 → 2.53.0

package/src/engine/navigation/PathFinder.js

@@ -1,172 +0,0 @@
-/**
- * Created by Alex on 03/02/14.
- */
-import Vector3 from '../physics/Vector3';
-
-
-/**
- * PathFinder uses a worker to allow asynchronous path finding, freeing up resources for rendering and game logic
- * @constructor
- */
-const PathFinder = function (readyCallback) {
-    const self = this;
-    this.__pathTimout = 10000;
-    const callbacks = this.callbacks = [];
-
-    this.worker = new Worker("src/model/navigation/PathWorker.js");
-    const api = {
-        meshBuilt: function (options) {
-            console.warn("mesh built");
-            self.__pathTimout = 500;
-        },
-        pathFound: function (options) {
-            const data = options.map(function (v) {
-                return new Vector3(v.x, 0, v.y);
-            });
-            //remove first callback from the queue
-            const callback = callbacks.shift();
-            //invoke the callback
-            if (callback) {
-                callback(data);
-            }
-        },
-        workerReady: function () {
-            if (readyCallback !== void 0) {
-                readyCallback();
-            }
-        }
-    };
-    const onmessage = function onmessage(event) {
-        const data = event.data;
-        const method = api[data.method];
-        if (method) {
-            method.call(api, data.options);
-        } else {
-            console.error("method '" + data.method + "' is not a supported");
-        }
-    };
-    const onerror = function onerror(event) {
-        console.error("PathFinder error: ", event);
-        //bail all pending callbacks
-        self.callbacks.forEach(function (callback) {
-            callback(void 0);
-        });
-        self.callbacks = [];
-        //restart the worker
-        self.worker = new Worker("src/model/navigation/PathWorker.js");
-        self.worker.onmessage = onmessage;
-        self.worker.onerror = onerror;
-        //bump up timeout until mesh is built
-        self.__pathTimout = 2000;
-        self.worker.postMessage({ method: "buildMesh", options: self.__buildMeshData });
-    };
-    this.worker.onmessage = onmessage;
-    this.worker.onerror = onerror;
-
-};
-PathFinder.prototype.destroyMesh = function () {
-    this.worker.postMessage({ method: "destroyMesh" });
-};
-/**
- * Construct navigation mesh
- * @param {Object} groundSize
- * @param {Walls} walls
- */
-PathFinder.prototype.buildMesh = function (groundSize, walls) {
-    // destroy old mesh
-//        this.destroyMesh();
-
-    function transformTo2D(vertex) {
-        return { x: vertex.x, y: vertex.y };
-    }
-
-    const constrains = [];
-//		walls.shapes.forEach(function (shape) {
-//			constrains.push(shape.makeGeometry().vertices.map(function (vertex) {
-//				return transformTo2D(vertex);
-//			}));
-//		});
-    walls.paths.forEach(function (path) {
-        if (path !== void 0) {
-            const points = path.actions.map(function (item) {
-                let type = item.action;
-                const args = item.args;
-                return { x: args[0], y: args[1] };
-            });
-            constrains.push(points);
-        }
-    });
-    let minX = Number.MAX_VALUE, minY = Number.MAX_VALUE, maxX = Number.MIN_VALUE, maxY = Number.MIN_VALUE;
-    constrains.forEach(function (polygon) {
-        polygon.forEach(function (point) {
-            minX = minX > point.x ? point.x : minX;
-            minY = minY > point.y ? point.y : minY;
-            maxX = maxX < point.x ? point.x : maxX;
-            maxY = maxY < point.y ? point.y : maxY;
-        });
-    });
-    const buffer = 20; // TODO Calculate the right world map boundary
-    minX -= buffer;
-    minY -= buffer;
-    maxX += buffer;
-    maxY += buffer;
-    const boundary = [
-        { x: minX, y: minY },
-        { x: minX, y: maxY },
-        { x: maxX, y: maxY },
-        { x: maxX, y: minY }
-    ];
-
-    const data = this.__buildMeshData = { boundary: boundary, constrains: constrains };
-    //bump up timeout until mesh is built
-    this.__pathTimout = 2000;
-    this.worker.postMessage({ method: "buildMesh", options: data });
-//        Lct.init(data.boundary);
-//        Lct.insertPolygons(data.constrains);
-};
-
-function vector3to2DJSON(v) {
-    // return {x: v.x, y: v.y, z: v.z};
-    return { x: v.x, y: v.z };
-}
-
-PathFinder.prototype.findPath = function (start, goal, clearance, callback) {
-    //start timer so we can bail out if path is not found
-    let timer;
-
-    function wrappedCallback(arg) {
-        clearTimeout(timer);
-        callback(arg);
-    }
-
-    const callbacks = this.callbacks;
-    callbacks.push(wrappedCallback);
-    const options = {
-        start: vector3to2DJSON(start),
-        goal: vector3to2DJSON(goal),
-        clearance: clearance
-    };
-    this.worker.postMessage({ method: "findPath", options: options });
-    //start timer so we can bail out if path is not found
-    timer = setTimeout(function bail() {
-        const index = callbacks.indexOf(wrappedCallback);
-        callbacks.splice(index, 1, function overdue() {
-            //the response is overdue, but it has arrived. do nothing
-        });
-        //call callback with BadNews(tm)
-        callback(void 0);
-    }, this.__pathTimout);
-
-//        var startTime = Date.now();
-//        var path = Lct.getPath(options.start, options.goal, options.clearance);
-//        var endTime = Date.now();
-//        console.log("found path in " + (endTime - startTime) + "ms");
-//        var data = path.vectors.map(function (v) {
-//            return new Vector3(v.x, 0, v.y);
-//        });
-//        //invoke the callback
-//        if (callback) {
-//            callback(data);
-//        }
-};
-export default PathFinder;

package/src/engine/navigation/PathWorker.js

@@ -1,78 +0,0 @@
-importScripts('../../../lib/require.src', '../../../lib/three.src');
-
-const onMessageActual = null;
-const deferredMessages = [];
-
-require(
-    {
-        baseUrl: ".",
-        paths: {
-            model: '../../model',
-            lib: '../../../lib'
-        }
-    },
-    [
-        'lib/lct/lct-built'
-    ],
-    function (Lct) {
-
-        const pathQueue = [];
-        const initialized = false;
-        const api = {
-            destroyMesh: function (options) {
-                Lct.reset();
-                initialized = false;
-            },
-            buildMesh: function (initData) {
-                Lct.init(initData.boundary);
-                Lct.insertPolygons(initData.constrains);
-                initialized = true;
-                postMessage({ method: "meshBuilt" });
-                //execute path finding for all deferred requests
-                while (pathQueue.length > 0) {
-                    const pathArgs = pathQueue.shift();
-                    api.findPath(pathArgs);
-                }
-            },
-            findPath: function (options) {
-                if (!initialized) {
-                    //queue up
-                    pathQueue.push(options);
-                    return;
-                }
-                const start = options.start;
-                const goal = options.goal;
-                const clearance = options.clearance;
-
-                let startTime = Date.now();
-                let path;
-                path = Lct.getPath(start, goal, clearance);
-                let endTime = Date.now();
-//				console.log("found path[" + path.vectors.length + "] from " + JSON.stringify(start) + " to " + JSON.stringify(goal) + " of clearance " + clearance + " in " + (endTime - startTime) + "ms");
-                postMessage({ method: "pathFound", options: path.vectors });
-            }
-        };
-        onMessageActual = function (message) {
-            const data = message.data;
-            const method = api[data.method];
-            if (method) {
-                method.call(api, data.options);
-            } else {
-                console.error("method '" + data.method + "' is not a supported");
-            }
-        };
-        console.log("path worker started");
-        postMessage({ method: "workerReady", options: null });
-        //handle deferred messages
-        deferredMessages.forEach(onMessageActual);
-    }
-);
-
-onmessage = function (message) {
-
-    if (onMessageActual == null) {
-        deferredMessages.push(message);
-    } else {
-        onMessageActual(message);
-    }
-};

package/src/engine/navigation/ecs/systems/PathFinderSystem.js

@@ -1,63 +0,0 @@
-/**
- * Created by Alex on 11/08/2014.
- */
-import { System } from '../../../ecs/System.js';
-import { Transform } from '../../../ecs/transform/Transform.js';
-import PathFinder from '../components/PathFinder.js';
-import Navigator from '../../PathFinder.js';
-import Vector3 from "../../../../core/geom/Vector3.js";
-import Path from "../components/Path.js";
-
-const v3 = new Vector3();
-
-class PathFinderSystem extends System {
-    constructor() {
-        super();
-        this.dependencies = [PathFinder];
-    }
-
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-        this.navigator = new Navigator();
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        const nav = this.navigator;
-
-        /**
-         *
-         * @param {PathFinder} finder
-         * @param {Path} path
-         * @param {Transform} transform
-         * @param {number} entity
-         */
-        function visitEntity(finder, path, transform, entity) {
-
-            const desination = finder.desination;
-
-            if (finder.finding === false) {
-                path.getPosition(path.getPointCount() - 1, v3);
-
-                //check if existing path is going to the destination
-                if (!v3.equals(desination)) {
-
-                    finder.finding = true;
-
-                    //find path
-                    nav.findPath(transform.position, desination, 2, function (path) {
-                        finder.finding = false;
-
-                        path.setPositionsFromVectorArray(path);
-                    });
-                }
-            }
-
-        }
-
-        entityManager.traverseEntities([PathFinder, Path, Transform], visitEntity);
-    }
-}
-
-
-export default PathFinderSystem;

package/src/engine/navigation/ecs/systems/PathSystem.js

@@ -1,19 +0,0 @@
-/**
- * Created by Alex on 17/10/2016.
- */
-
-
-import { System } from '../../../ecs/System.js';
-import Path from '../components/Path.js';
-
-class PathSystem extends System {
-    constructor() {
-        super();
-        this.dependencies = [Path];
-        //
-        this.entityManager = null;
-    }
-}
-
-
-export default PathSystem;

package/src/engine/navigation/funnel/Funnel.js

@@ -1,196 +0,0 @@
-/**
- * Created by Alex on 29/03/2014.
- */
-
-
-
-
-const EPSILON = 0.000001;
-
-function triarea2(a, b, c) {
-    const ax = b.x - a.x;
-    const ay = b.y - a.y;
-    const bx = c.x - a.x;
-    const by = c.y - a.y;
-
-    return bx * ay - ax * by;
-}
-
-function vdistsqr(a, b) {
-    const x = b.x - a.x;
-    const y = b.y - a.y;
-
-    return x * x + y * y;
-}
-
-function vequal(a, b) {
-    return vdistsqr(a, b) < EPSILON;
-}
-
-function counterClockWise2(v0, v1, v2) {
-    const vs = [v0, v1, v2];
-    let a = 0;
-    for (let i = 0; i < 3; i++) {
-        const p0 = vs[i];
-        const p1 = vs[(i + 1) % 3];
-        a += (p1.x - p0.x) * (p1.y + p0.y);
-    }
-    return a < 0;
-}
-
-function counterClockWise(v0, v1, v2) {
-
-    const a = (v0.x + v1.x) * (v0.y - v1.y) + (v1.x + v2.x) * (v1.y - v2.y);
-    return a < 0;
-}
-
-function getOffsetVertex(prevPoint, currPoint, nextPoint, size) {
-    if (prevPoint == currPoint || currPoint == nextPoint) {
-        return new THREE.Vector2(currPoint.x, currPoint.y);
-    }
-
-    // Calculate line angles.
-    const nextAngle = Math.atan2(nextPoint.y - currPoint.y, nextPoint.x - currPoint.x);
-    const prevAngle = Math.atan2(currPoint.y - prevPoint.y, currPoint.x - prevPoint.x);
-
-    // Calculate minimum distance between line angles.
-    let distance = nextAngle - prevAngle;
-
-    if (Math.abs(distance) > Math.PI) {
-        distance -= distance > 0 ? Math.PI * 2 : -Math.PI * 2;
-    }
-
-    // Calculate left perpendicular to average angle.
-    const angle = prevAngle + (distance / 2) + (Math.PI / 2);
-    const normal = new THREE.Vector2(Math.cos(angle), Math.sin(angle));
-
-    return normal.multiplyScalar(size).add(new THREE.Vector2(currPoint.x, currPoint.y));
-}
-
-function getPrev(list, currentIndex) {
-    let prev = currentIndex;
-
-    for (let i = prev; i >= 0; i--) {
-        if (list[i] != list[prev]) {
-            prev = i;
-            break;
-        }
-    }
-
-    return prev;
-}
-
-function getNext(list, currentIndex) {
-    let next = currentIndex;
-
-    for (let i = next; i < list.length; i++) {
-        if (list[i] != list[next]) {
-            next = i;
-            break;
-        }
-    }
-
-    return next;
-}
-
-function Channel() {
-    this.portals = [];
-}
-
-Channel.prototype.push = function (p1, p2) {
-    if (p2 === undefined) p2 = p1;
-    this.portals.push({ left: p1, right: p2 });
-};
-
-Channel.prototype.fixLeftRight = function () {
-    for (let i = 1; i < this.portals.length; i++) {
-        const previous = this.portals[i - 1];
-        const current = this.portals[i];
-        let ccw = counterClockWise2(previous.right, current.right, current.left);
-        if (!ccw) {
-            const t = current.left;
-            //swap
-            current.left = current.right;
-            current.right = t;
-        }
-    }
-};
-
-Channel.prototype.stringPull = function (agentSize) {
-    const size = agentSize || 0;
-    const portals = this.portals;
-    const pts = [];
-    // Init scan state
-    let portalApex, portalLeft, portalRight;
-    let apexIndex = 0, leftIndex = 0, rightIndex = 0;
-
-    portalApex = portals[0].left;
-    portalLeft = portals[0].left;
-    portalRight = portals[0].right;
-
-    // Add start point.
-    pts.push(portalApex);
-
-    for (let i = 1; i < portals.length; i++) {
-        const left = portals[i].left;
-        const right = portals[i].right;
-
-        // Update right vertex.
-        if (triarea2(portalApex, portalRight, right) <= 0.0) {
-            if (vequal(portalApex, portalRight) || triarea2(portalApex, portalLeft, right) > 0.0) {
-                // Tighten the funnel.
-                portalRight = right;
-                rightIndex = i;
-            } else {
-                // Right over left, insert left to path and restart scan from portal left point.
-                const offsetLeftVertex = getOffsetVertex(portals[getPrev(portals, leftIndex)].left, portalLeft, portals[getNext(portals, leftIndex)].left, size);
-                pts.push({ x: offsetLeftVertex.x, y: offsetLeftVertex.y });
-                // Make current left the new apex.
-                portalApex = portalLeft;
-                apexIndex = leftIndex;
-                // Reset portal
-                portalLeft = portalApex;
-                portalRight = portalApex;
-                leftIndex = apexIndex;
-                rightIndex = apexIndex;
-                // Restart scan
-                i = apexIndex;
-                continue;
-            }
-        }
-
-        // Update left vertex.
-        if (triarea2(portalApex, portalLeft, left) >= 0.0) {
-            if (vequal(portalApex, portalLeft) || triarea2(portalApex, portalRight, left) < 0.0) {
-                // Tighten the funnel.
-                portalLeft = left;
-                leftIndex = i;
-            } else {
-                // Left over right, insert right to path and restart scan from portal right point.
-                const offsetRightVertex = getOffsetVertex(portals[getPrev(portals, rightIndex)].right, portalRight, portals[getNext(portals, rightIndex)].right, size);
-                pts.push({ x: offsetRightVertex.x, y: offsetRightVertex.y });
-                // Make current right the new apex.
-                portalApex = portalRight;
-                apexIndex = rightIndex;
-                // Reset portal
-                portalLeft = portalApex;
-                portalRight = portalApex;
-                leftIndex = apexIndex;
-                rightIndex = apexIndex;
-                // Restart scan
-                i = apexIndex;
-                continue;
-            }
-        }
-    }
-
-    if ((pts.length == 0) || (!vequal(pts[pts.length - 1], portals[portals.length - 1].left))) {
-        // Append last point to path.
-        pts.push(portals[portals.length - 1].left);
-    }
-
-    this.path = pts;
-    return pts;
-};
-export default Channel;
-

package/src/generation/ZoneNode.js

@@ -1,9 +0,0 @@
-export class ZoneNode {
-    constructor() {
-
-        this.tags = [];
-        
-        this.area = 0;
-
-    }
-}