@makefully/platypus 4.1.5 → 4.1.8

package/src/components/NodeResident.js

@@ -0,0 +1,636 @@
+/**
+# COMPONENT **NodeResident**
+
+### Local Broadcasts:
+- **next-to-[entity-type]** - This message is triggered when the entity is placed on a node. It will trigger on all neighboring entities, as well as on itself on behalf of neighboring entities.
+  - @param entity (Entity) - The entity that is next to the listening entity.
+- **with-[entity-type]** - This message is triggered when the entity is placed on a node. It will trigger on all entities residing on the same node, as well as on itself on behalf of all resident entities.
+  - @param entity (Entity) - The entity that is with the listening entity.
+- **left-node** - Triggered when the entity leaves a node.
+  - @param node (Node) - The node that the entity just left.
+- **[Messages specified in definition]** - When the entity is placed on a node, it checks out the type of node and triggers a message on the entity if an event is listed for the current node type.
+
+## States
+- **on-node** - This state is true when the entity is on a node.
+- **moving** - This state is true when the entity is moving from one node to another.
+- **going-[direction]** - This state is true when the entity is moving (or has just moved) in a direction (determined by the NodeMap) from one node to another.
+  
+## JSON Definition
+    {
+      "type": "NodeResident",
+      
+      "nodeId": "city-hall",
+      // Optional. The id of the node that this entity should start on. Uses the entity's nodeId property if not set here.
+      
+      "friendlyNodes": {"path": "walking", "sidewalk": "walking", "road": "driving"],
+      // Optional. This is a list of node types that this entity can reside on. If not set, entity can reside on any type of node.
+      
+      "friendlyEntities": ['friends','neighbors','city-council-members'],
+      // Optional. This is a list of entities that this entity can reside with on the same node. If not set, this entity can reside with any entities on the same node.
+      
+      "speed": 5,
+      // Optional. Sets the speed with which the entity moves along an edge to an adjacent node. Default is 0 (instantaneous movement).
+      
+      "updateOrientation": true
+      // Optional. Determines whether the entity's orientation is updated by movement across the NodeMap. Default is false.
+    }
+*/
+import {arrayCache, greenSlice} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+const
+    createGateway = function (nodeDefinition, map, gateway) {
+        return function () {
+            // ensure it's a node if one is available at this gateway
+            const
+                node = map.getNode(nodeDefinition);
+
+            if (this.isPassable(node)) {
+                this.destinationNodes.length = 0;
+                this.destinationNodes.push(node);
+
+                if (this.node) {
+                    this.onEdge(node);
+                } else {
+                    this.distance = 0;
+                }
+                this.progress = 0;
+
+                this.setState('going-' + gateway);
+                return true;
+            }
+
+            return false;
+        };
+    },
+    distance = function (origin, destination) {
+        const
+            x = destination.x - origin.x,
+            y = destination.y - origin.y,
+            z = destination.z - origin.z;
+
+        return Math.sqrt(x * x + y * y + z * z);
+    },
+    angle = function (origin, destination, distance, ratio) {
+        if (origin.rotation && destination.rotation) {
+            const
+                x = (origin.rotation + 180) % 360,
+                y = (destination.rotation + 180) % 360;
+
+            return (x * (1 - ratio) + y * ratio + 180) % 360;
+        } else {
+            const
+                x = destination.x - origin.x,
+                y = destination.y - origin.y;
+            let a = 0;
+
+            if (!distance) {
+                return a;
+            }
+
+            a = Math.acos(x / distance);
+            if (y < 0) {
+                a = (Math.PI * 2) - a;
+            }
+            return a * 180 / Math.PI;
+        }
+    },
+    axisProgress = function (r, o, d, f) {
+        return o * (1 - r) + d * r + f;
+    },
+    isFriendly = function (entities, kinds) {
+
+        if (kinds !== null) {
+            let found = false;
+
+            for (let x = 0; x < entities.length; x++) {
+                for (let y = 0; y < kinds.length; y++) {
+                    if (entities[x].type === kinds[y]) {
+                        found = true;
+                    }
+                }
+                if (!found) {
+                    return false;
+                } else {
+                    found = false;
+                }
+            }
+        }
+
+        return true;
+    };
+
+export default createComponentClass(/** @lends platypus.components.NodeResident.prototype */{
+    
+    id: 'NodeResident',
+
+    properties: {
+        algorithm: distance,
+
+        /**
+         * This sets the resident's initial node.
+         *
+         * @property node
+         * @type Object
+         * @default null
+         */
+        node: null,
+
+        offset: {},
+
+        snapToNodes: false,
+
+        updateOrientation: false
+    },
+    
+    publicProperties: {
+        friendlyNodes: null,
+
+        friendlyEntities: null,
+
+        nodeId: '',
+
+        /**
+         * This describes the rate at which a node resident should progress along an edge to another node. This property is set on the entity itself and can be manipulated in real-time.
+         *
+         * @property speed
+         * @type Number
+         * @default 0
+         */
+        speed: 0
+    },
+    
+    /**
+     * This component connects an entity to its parent's [[NodeMap]]. It manages navigating the NodeMap and triggering events on the entity related to its position.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @listens platypus.Entity#handle-logic
+     * @fires platypus.Entity#in-location
+     */
+    initialize: function () {
+        const
+            offset = this.offset,
+            startingNode = this.node;
+        
+        this.neighbors = {};
+
+        this.distance = 0;
+        this.progress = 0;
+        this.offset = {
+            x: offset.x || 0,
+            y: offset.y || 0,
+            z: offset.z || 0
+        };
+        this.destinationNodes = arrayCache.setUp();
+        
+        this.state = this.owner.state;
+        this.state.set('moving', false);
+        this.state.set('on-node', false);
+        this.currentState = '';
+
+        Object.defineProperty(this.owner, 'node', {
+            get: () => this.node,
+            set: (value) => {
+                if (value) {
+                    this.getOnNode(value);
+                } else {
+                    this.getOffNode();
+                }
+            }
+        });
+        this.owner.node = startingNode;
+    },
+    
+    events: {
+        "set-algorithm": function (algorithm) {
+            this.algorithm = algorithm || distance;
+        },
+        "handle-logic": function (resp) {
+            let ratio = 0,
+                momentum = 0;
+            
+            if (!this.owner.node) {
+                const
+                    arr = arrayCache.setUp(this.owner.x, this.owner.y);
+
+                this.owner.node = this.owner.parent.getClosestNode(arr);
+                arrayCache.recycle(arr);
+                
+                /**
+                 * This event is triggered if the entity is placed on the map but not assigned a node. It is moved to the nearest node and "in-location" is triggered.
+                 *
+                 * @event platypus.Entity#in-location
+                 * @param entity {platypus.Entity} The entity that is in location.
+                 */
+                this.owner.triggerEvent('in-location', this.owner);
+            }
+
+            if (this.followEntity) {
+                const
+                    node = this.followEntity.node || this.followEntity;
+
+                if (node && node.isNode && (node !== this.node)) {
+                    this.lag = 0;
+                    this.state.set('moving', this.gotoNode());
+                    if (this.followDistance) {
+                        momentum = this.lag;
+                    }
+                } else {
+                    this.followEntity = null;
+                }
+            } else {
+                momentum = this.speed * resp.delta;
+            }
+
+            // if goto-node was blocked, try again.
+            if (this.blocked) {
+                this.blocked = false;
+                if (this.goingToNode) {
+                    this.owner.triggerEvent('goto-closest-node', this.goingToNode);
+                }
+            }
+            
+            if (this.destinationNodes.length) {
+                this.state.set('moving', (this.speed !== 0));
+                if (this.node) {
+                    this.onEdge(this.destinationNodes[0]);
+                } else if (!this.lastNode) {
+                    this.owner.node = this.destinationNodes[0];
+                    this.destinationNodes.shift();
+                    if (!this.destinationNodes.length) {
+                        this.state.set('moving', false);
+                        return;
+                    }
+                }
+                
+                if (this.snapToNodes) {
+                    for (let i = 0; i < this.destinationNodes.length; i++) {
+                        this.owner.node = this.destinationNodes[i];
+                    }
+                    this.destinationNodes.length = 0;
+                } else {
+                    while (this.destinationNodes.length && momentum) {
+                        if ((this.progress + momentum) >= this.distance) {
+                            const
+                                node = this.destinationNodes[0];
+
+                            momentum -= (this.distance - this.progress);
+                            this.progress = 0;
+                            this.destinationNodes.shift();
+                            this.owner.node = node;
+                            if (this.destinationNodes.length && momentum) {
+                                this.onEdge(this.destinationNodes[0]);
+                            }
+                        } else {
+                            this.progress += momentum;
+                            ratio = this.progress / this.distance;
+                            this.owner.x = axisProgress(ratio, this.lastNode.x, this.destinationNodes[0].x, this.offset.x);
+                            this.owner.y = axisProgress(ratio, this.lastNode.y, this.destinationNodes[0].y, this.offset.y);
+                            this.owner.z = axisProgress(ratio, this.lastNode.z, this.destinationNodes[0].z, this.offset.z);
+                            if (this.updateOrientation) {
+                                this.owner.rotation = angle(this.lastNode, this.destinationNodes[0], this.distance, ratio);
+                            }
+                            momentum = 0;
+                        }
+                    }
+                }
+            } else {
+                this.state.set('moving', false);
+            }
+        },
+        "goto-node": function (node) {
+            this.gotoNode(node);
+        },
+        "follow": function (entityOrNode) {
+            if (entityOrNode.entity) {
+                this.followDistance = entityOrNode.distance;
+                this.followEntity = entityOrNode.entity;
+            } else {
+                this.followDistance = 0;
+                this.followEntity = entityOrNode;
+            }
+        },
+        "goto-closest-node": (function () {
+            const
+                checkList = (here, list) => list.indexOf(here) >= 0,
+                checkType = (here, type) => here.type === type,
+                checkObjectType = (here, node) => here.type === node.type;
+            
+            return function (nodesOrNodeType) {
+                const
+                    origin   = this.node ?? this.lastNode,
+                    test     = (typeof nodesOrNodeType === 'string') ? checkType : (typeof nodesOrNodeType.type === 'string') ? checkObjectType : checkList,
+                    steps    = nodesOrNodeType.steps ?? 0;
+
+                this.goingToNode = nodesOrNodeType;
+                
+                if (origin && nodesOrNodeType && !test(origin, nodesOrNodeType)) {
+                    const
+                        nodes = arrayCache.setUp(),
+                        travResp = this.traverseNode({
+                            depth: 20, //arbitrary limit
+                            origin: origin,
+                            position: origin,
+                            test,
+                            destination: nodesOrNodeType,
+                            nodes: nodes,
+                            shortestPath: Infinity,
+                            distance: 0,
+                            found: false,
+                            algorithm: this.algorithm,
+                            blocked: false
+                        });
+                    
+                    travResp.distance -= this.progress;
+                    
+                    if (travResp.found) {
+                        //TODO: should probably set this up apart from this containing function
+                        if (this.followEntity) {
+                            if (!this.followDistance) {
+                                this.setPath(travResp, steps);
+                            } else if ((travResp.distance + (this.followEntity.progress || 0)) > this.followDistance) {
+                                this.lag = travResp.distance + (this.followEntity.progress || 0) - this.followDistance;
+                                this.setPath(travResp, steps);
+                            } else {
+                                this.lag = 0;
+                            }
+                        } else {
+                            this.setPath(travResp, steps);
+                        }
+                    } else if (travResp.blocked) {
+                        this.blocked = true;
+                    }
+                    
+                    arrayCache.recycle(nodes);
+                }
+            };
+        }()),
+        "set-directions": function () {
+            const
+                node = this.node,
+                nodeNeighbors = node.neighbors,
+                keys = Object.keys(nodeNeighbors),
+                {length} = keys;
+            
+            this.owner.triggerEvent('remove-directions');
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i],
+                    nodeNeighbor = nodeNeighbors[key],
+                    nextNode = node.map.getNode(nodeNeighbor),
+                    gateway = this.neighbors[key] = createGateway(nodeNeighbor, node.map, i);
+
+                this.addEventListener(key, gateway);
+
+                //trigger "next-to" events
+                if (nextNode) {
+                    const
+                        entities = nextNode.contains;
+
+                    for (let j = 0; j < entities.length; j++) {
+                        entities[j].triggerEvent("next-to-" + this.owner.type, this.owner);
+                        this.owner.triggerEvent("next-to-" + entities[j].type, entities[j]);
+                    }
+                }
+            }
+        },
+        "remove-directions": function () {
+            const
+                neighbors = this.neighbors,
+                keys = Object.keys(neighbors),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                this.removeEventListener(key, neighbors[key]);
+                delete neighbors[key];
+            }
+        }
+    },
+    
+    methods: {
+        gotoNode (node) {
+            const
+                origin = this.node ?? this.lastNode;
+            let moving = false;
+            
+            if (!node && this.followEntity) {
+                node = this.followEntity.node ?? this.followEntity.lastNode ?? this.followEntity;
+            }
+            
+            if (origin && node && (this.node !== node)) {
+                const
+                    nodes = arrayCache.setUp(),
+                    travResp = this.traverseNode({
+                        depth: 20, //arbitrary limit
+                        origin,
+                        position: origin,
+                        test: (here, there) => here === there,
+                        destination: node,
+                        nodes,
+                        shortestPath: Infinity,
+                        distance: 0,
+                        found: false,
+                        algorithm: this.algorithm,
+                        blocked: false
+                    });
+                
+                travResp.distance -= this.progress;
+                
+                if (travResp.found) {
+                    //TODO: should probably set this up apart from this containing function
+                    if (this.followEntity) {
+                        if (!this.followDistance) {
+                            this.setPath(travResp);
+                            moving = true;
+                        } else if ((travResp.distance + (this.followEntity.progress || 0)) > this.followDistance) {
+                            this.lag = travResp.distance + (this.followEntity.progress || 0) - this.followDistance;
+                            this.setPath(travResp);
+                            moving = true;
+                        } else {
+                            this.lag = 0;
+                        }
+                    } else {
+                        this.setPath(travResp);
+                        moving = true;
+                    }
+                } else if (travResp.blocked) {
+                    this.blocked = true;
+                }
+                
+                arrayCache.recycle(nodes);
+            }
+            
+            return moving;
+        },
+
+        getOnNode (node) {
+            const
+                entities = node.contains;
+            
+            this.getOffNode();
+            this.node = node;
+            if (this.node?.removeFromEdge) {
+                this.node.removeFromEdge(this.owner);
+            }
+            if (this.lastNode?.removeFromEdge) {
+                this.lastNode.removeFromEdge(this.owner);
+            }
+            this.node.addToNode(this.owner);
+            
+            this.setState('on-node');
+            
+            this.owner.x = this.node.x + this.offset.x;
+            this.owner.y = this.node.y + this.offset.y;
+            this.owner.z = this.node.z + this.offset.z;
+            if (this.updateOrientation && this.node.rotation) {
+                this.owner.rotation = this.node.rotation;
+            }
+            
+            //add listeners for directions
+            this.owner.triggerEvent('set-directions');
+            
+            //trigger mapped messages for node types
+            if (this.friendlyNodes && this.friendlyNodes[node.type]) {
+                this.owner.trigger(this.friendlyNodes[node.type], node);
+            }
+
+            //trigger "with" events
+            for (let j = 0; j < entities.length; j++) {
+                if (this.owner !== entities[j]) {
+                    entities[j].triggerEvent("with-" + this.owner.type, this.owner);
+                    this.owner.triggerEvent("with-" + entities[j].type, entities[j]);
+                }
+            }
+
+            this.owner.triggerEvent('on-node', node);
+        },
+
+        getOffNode: function () {
+            if (this.node) {
+                this.node.removeFromNode(this.owner);
+                this.owner.triggerEvent('left-node', this.node);
+                this.owner.triggerEvent('remove-directions');
+            }
+            this.lastNode = this.node;
+            this.node = null;
+        },
+
+        isPassable: function (node) {
+            return node && (this.node !== node) && (!this.friendlyNodes || (typeof this.friendlyNodes[node.type] !== 'undefined')) && (!node.contains.length || isFriendly(node.contains, this.friendlyEntities));
+        },
+        traverseNode: function (record) {
+            //TODO: may want to make this use A*. Currently node traversal order is arbitrary and essentially searches entire graph, but does clip out paths that are too long.
+            const
+                {position, test} = record;
+
+            if ((record.depth === 0) || (record.distance > record.shortestPath)) {
+                // if we've reached our search depth or are following a path longer than our recorded successful distance, bail
+                return record;
+            } else if (test(position, record.destination)) {
+                // if we've reached our destination, set shortest path information and bail.
+                record.found = true;
+                record.shortestPath = record.distance;
+                return record;
+            } else if (record.nodes.includes(position, 1)) { //Make sure we do not trace an infinite node loop.
+                return record;
+            } else {
+                const
+                    algorithm = record.algorithm || distance,
+                    map       = position.map,
+                    neighbors = position.neighbors,
+                    keys = Object.keys(neighbors),
+                    {length} = keys,
+                    savedResp = {
+                        shortestPath: Infinity,
+                        found: false,
+                        blocked: false
+                    };
+                let blocked   = true,
+                    hasNeighbor = false;
+            
+                for (let i = 0; i < length; i++) {
+                    const
+                        key = keys[i],
+                        node = map.getNode(neighbors[key]);
+
+                    hasNeighbor = true;
+
+                    if (this.isPassable(node)) {
+                        const
+                            nodeList = [
+                                ...record.nodes,
+                                node
+                            ],
+                            resp = this.traverseNode({
+                                depth: record.depth - 1,
+                                origin: record.origin,
+                                position: node,
+                                destination: record.destination,
+                                test,
+                                algorithm: algorithm,
+                                nodes: nodeList,
+                                shortestPath: record.shortestPath,
+                                distance: record.distance + algorithm(position, node),
+                                gateway: record.gateway || key,
+                                found: false,
+                                blocked: false
+                            });
+
+                        if (resp.found && (savedResp.shortestPath > resp.shortestPath)) {
+                            savedResp = resp;
+                        }
+                        blocked = false;
+                    }
+                }
+                savedResp.blocked = (hasNeighbor && blocked);
+                return savedResp;
+            }
+        },
+        setPath: function (resp, steps) {
+            if (resp.nodes[0] === this.node) {
+                resp.nodes.shift();
+            }
+            arrayCache.recycle(this.destinationNodes);
+            this.destinationNodes = greenSlice(resp.nodes);
+            if (steps) {
+                this.destinationNodes.length = Math.min(steps, this.destinationNodes.length);
+            }
+        },
+        setState: function (state) {
+            if (state === 'on-node') {
+                this.state.set('on-node', true);
+            } else {
+                this.state.set('on-node', false);
+                if (this.currentState) {
+                    this.state.set(this.currentState, false);
+                }
+                this.currentState = state;
+                this.state.set(state, true);
+            }
+        },
+        onEdge: function (toNode) {
+            this.distance = distance(this.node, toNode);
+            if (this.updateOrientation) {
+                this.owner.rotation = angle(this.node, toNode, this.distance, this.progress / this.distance);
+            }
+            if (this.node.addToEdge) {
+                this.node.addToEdge(this.owner);
+            }
+            if (toNode.addToEdge) {
+                toNode.addToEdge(this.owner);
+            }
+            this.owner.node = null;
+        },
+        destroy: function () {
+            arrayCache.recycle(this.destinationNodes);
+            this.destinationNodes = null;
+            this.state = null;
+        }
+    }
+});