@makefully/platypus 4.1.4 → 4.1.6

package/src/components/LogicStateMachine.js

@@ -0,0 +1,382 @@
+/**
+### Local Broadcasts:
+- **[output messages]** - This component triggers output messages as determined by the JSON settings.
+
+## JSON Definition
+    {
+      "type": "LogicStateMachine",
+      
+      "inputs":{
+      // This is a list of messages that this component should listen for to change states.
+      
+        "smell-toast":{
+        // If the entity triggers "smell-toast", this component will change the state of the entity as follows:
+        
+          "smelling-food": true,
+          "smelling-nothing": false
+        },
+        
+        "go-to-store":{
+          "at-store": true
+        }
+      },
+      
+      "sustained-inputs":{
+      // These are messages that must be triggered every tick for the state to remain true: if not, they become false.
+        "near-grover": "smelling-trash"
+      }
+    }
+*/
+import {arrayCache, greenSplice} from '../utils/array.js';
+import DataMap from '../DataMap.js';
+import StateMap from '../StateMap.js';
+import createComponentClass from '../factory.js';
+
+const
+    setUpOutputs = function (outs) {
+        if (!outs || (typeof outs !== 'object') || Array.isArray(outs) || outs.event) {
+            return outs;
+        } else {
+            const
+                data = DataMap.setUp(),
+                keys = Object.keys(outs),
+                {length} = keys;
+    
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                data.set(key, setUpOutputs(outs[key]));
+            }
+            return data;
+        }
+    },
+    recycleOutputs = function (outs) {
+        if (outs instanceof DataMap) {
+            const
+                keys = outs.keys;
+            let i = keys.length;
+
+            while (i--) {
+                recycleOutputs(outs[keys[i]]);
+            }
+            outs.recycle();
+        }
+    },
+    handleResult = function ({title, state, last, checks, changed, self, queue, appendDetails}) {
+        const
+            keys = checks.keys,
+            message = checks.message ?? (checks.message === 0) ?? (checks.message === false);
+
+        if (changed) {
+            if (typeof checks === 'string') {
+                if (appendDetails) {
+                    const
+                        stateCopy = StateMap.setUp(state);
+
+                    self.triggerEvent(checks, {
+                        entity: self,
+                        state: stateCopy
+                    });
+
+                    stateCopy.recycle();
+                } else {
+                    self.triggerEvent(checks);
+                }
+                return;
+            } else if (Array.isArray(checks)) {
+                for (let i = 0; i < checks.length; i++) {
+                    handleResult({title, state, last, checks: checks[i], changed, self, queue, appendDetails});
+                }
+                return;
+            } else if (checks.event && (message || checks.delay)) {
+                if (checks.delay) {
+                    queue.push(checks);
+                } else if (appendDetails) {
+                    const
+                        stateCopy = StateMap.setUp(state);
+
+                    self.trigger(checks.event, {
+                        ...checks.message ?? {},
+                        entity: self,
+                        state: stateCopy
+                    });
+
+                    stateCopy.recycle();
+                } else {
+                    self.trigger(checks.event, checks.message);
+                }
+                return;
+            } else if (checks.get) {
+                const
+                    value = checks.get('true');
+
+                if (value) {
+                    handleResult({title, state, last, checks: value, changed, self, queue, appendDetails});
+                }
+            }
+        }
+
+        if (keys) {
+            let i = keys.length;
+
+            while (i--) {
+                const
+                    key = keys[i];
+
+                if (key !== 'true') {
+                    handleOutput({title: key, state, last, checks: checks.get(key), changed, self, queue, appendDetails});
+                }
+            }
+        }
+    },
+    handleOutput = function ({title, state, last, checks, changed, self, queue, appendDetails}) {
+        let c = changed,
+            value = false;
+
+        if (title.charAt(0) === '!') {
+            const
+                st = title.substring(1),
+                stateValue = state.get(st);
+
+            value = (stateValue === false);
+            if ((title !== 'outputs') && (last.get(st) !== stateValue)) {
+                c = true;
+            }
+        } else {
+            const
+                stateValue = state.get(title);
+
+            value = (stateValue === true);
+            if ((title !== 'outputs') && (last.get(title) !== stateValue)) {
+                c = true;
+            }
+        }
+
+        if (value || (title === 'outputs')) {
+            handleResult({title, state, last, checks, changed: c, self, queue, appendDetails});
+        }
+    };
+
+export default createComponentClass(/** @lends platypus.components.LogicStateMachine.prototype */{
+    id: 'LogicStateMachine',
+    
+    properties: {
+        /**
+         * Whether `entity` and `state` values should be appended to output messages on events.
+         * 
+         * @property appendDetails
+         * @type Boolean
+         * @default false
+         */
+        appendDetails: false,
+
+        /**
+         * This is the list of events containing key/value pairs that describe state changes to make for the given event.
+         *
+         *     {
+         *         "smell-toast": {
+         *             "smelling-food": true,
+         *             "smelling-nothing": false
+         *         },
+         *         "go-to-store": {
+         *             "at-store": true
+         *         }
+         *     }
+         *
+         * @property inputs
+         * @type Object
+         * @default null
+         */
+        inputs: null,
+        
+        /**
+         * These are messages that should be triggered when certain conditions are met. The messages are only triggered the instant the condition is met, until the conditions are no longer met and then once again met. Example:
+         *
+         *     {
+         *         "smelling-food": { // Keys map to states, and if true, the value of the key is processed. In this case, the value of the "smelling-food" key is another object of key/value pairs, giving us another layer of checks.
+         *             "!smelling-trash": "time-to-eat", // This key is an inverse check, meaning that the "smelling-trash" state of the entity must be false to continue along this path. This time the value is a string, so the string "time-to-eat" is treated as a message to be broadcast if the entity is both "smelling-food" and not "smelling-trash".
+         *             "true": "belly-rumble" // In some cases, a message should be triggered for a set of states, while still doing deeper state checks like above. "true" will always handle the next layer of values if the parent key was true.
+         *         },
+         *         "smelling-trash": "feeling-sick" // Multiple states can be handled to multiple depths, like a list of if () statements
+         *         "!smelling-nothing": {
+         *             "!smelling-trash":{
+         *                 "!at-store": "go-to-store", // Note that the "go-to-store" message will change this entity's state to "at-store" according to "inputs" above, but LogicStateMachine uses a cache of states when broadcasting output messages, so the next section will not be processed until the next state check.
+         *                 "at-store":{
+         *                     "have-money": "buy-more-food",
+         *                     "!have-money": "buy-less-food"
+         *                 }
+         *             }
+         *         }
+         *     }
+         *
+         * @property outputs
+         * @type Object
+         * @default null
+         */
+        outputs: null
+    },
+    
+    /**
+     * This component is a general purpose state-machine for an entity, taking in various message inputs to determine the entity's state and triggering messages as necessary when a certain state occurs or several state combinations are in place.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @param {*} definition 
+     * @listens platypus.Entity#handle-logic
+     * @listens platypus.Entity#state-changed
+     */
+    initialize: function (definition) {
+        const
+            inputDefinition = this.inputs,
+            susDef = definition["sustained-inputs"],
+            thisState = this.owner.state;
+        
+        this.state = thisState;
+        
+        if (inputDefinition) {
+            const
+                stateObjects = arrayCache.setUp(),
+                keys = Object.keys(inputDefinition),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i],
+                    state = StateMap.setUp(inputDefinition[key]),
+                    stateKeys = state.keys;
+                let j = stateKeys.length;
+                
+                stateObjects.push(state);
+                this.addEventListener(key, () => {
+                    thisState.update(state);
+                });
+
+                while (j--) {
+                    if (!thisState.has(stateKeys[j])) { // set initial value to false if it's currently undefined.
+                        thisState.set(stateKeys[j], false);
+                    }
+                }
+            }
+            this.stateObjects = stateObjects;
+        }
+
+        this.sustainedState = StateMap.setUp();
+        if (susDef) {
+            const
+                keys = Object.keys(susDef),
+                {length} = keys,
+                {sustainedState} = this;
+    
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i],
+                    definition = susDef[key];
+
+                this.addEventListener(key, () => {
+                    sustainedState.set(definition, true);
+                });
+                sustainedState.set(susDef[key], false);
+                thisState.set(susDef[key], false);
+            }
+        }
+
+        this.snapshot = StateMap.setUp();
+        this.last = StateMap.setUp();
+        this.queueTimes = arrayCache.setUp();
+        this.queue = arrayCache.setUp();
+        this.outputs = setUpOutputs(this.outputs);
+    },
+
+    events: {
+        "handle-logic": function (resp) {
+            const
+                {state, sustainedState} = this,
+                keys = sustainedState.keys;
+            let i = keys.length;
+            
+            while (i--) {
+                const
+                    key = keys[i];
+
+                state.set(key, sustainedState.get(key));
+                sustainedState.set(key, false);
+            }
+            
+            i = this.queue.length;
+            while (i--) {
+                this.queueTimes[i] -= resp.delta;
+                
+                if (this.queueTimes[i] <= 0) {
+                    this.owner.trigger(this.queue[i].event, this.queue[i].message);
+                    greenSplice(this.queueTimes, i);
+                    greenSplice(this.queue, i);
+                }
+            }
+        },
+        
+        "update-state": function (state) {
+            this.state.update(state);
+        },
+        
+        "state-changed": function (state) {
+            const
+                ss = this.snapshot;
+            
+            if (this.outputs) {
+                const
+                    queue = arrayCache.setUp();
+
+                ss.update(state);
+                handleOutput({
+                    title: 'outputs',
+                    state: ss,
+                    last: this.last,
+                    checks: this.outputs,
+                    changed: false,
+                    self: this.owner,
+                    queue,
+                    appendDetails: this.appendDetails
+                });
+                
+                let i = queue.length;
+                
+                while (i--) {
+                    this.queue.push(queue[i]);
+                    this.queueTimes.push(queue[i].delay);
+                }
+                arrayCache.recycle(queue);
+                
+                this.last.update(ss);
+            }
+        }
+    },
+    
+    methods: {
+        destroy: function () {
+            const
+                so = this.stateObjects;
+            
+            arrayCache.recycle(this.queueTimes);
+            arrayCache.recycle(this.queue);
+            
+            if (so) {
+                let i = so.length;
+
+                while (i--) {
+                    so[i].recycle();
+                }
+                arrayCache.recycle(so);
+                this.stateObjects = null;
+            }
+
+            this.sustainedState.recycle();
+            this.snapshot.recycle();
+            this.last.recycle();
+            
+            this.state = null;
+            this.inputs = null;
+        }
+    }
+});

package/src/components/LogicSwitch.js

@@ -0,0 +1,77 @@
+/**
+### Local Broadcasts:
+- **switch-on** - This message is triggered when the switch has just been pressed.
+- **switch-off** - This message is triggered when the switch has just been released.
+- **initial-press** - This message is triggered the first time the switch is pressed. This occurs before the "switch-on" message is triggered.
+
+## JSON Definition:
+    {
+      "type": "LogicSwitch",
+      
+      "sticky": true
+      // Optional. Whether a pressed switch should stay pressed once collision messages cease. Defaults to `false`.
+    }
+*/
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicSwitch.prototype */{
+        
+        id: 'LogicSwitch',
+        
+        /**
+         * This component serves as a switch in the game world, typically tied to collision events such that this entity changes state when another entity collides or passed over.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (definition) {
+            this.state = this.owner.state;
+            this.pressed = false;
+            this.wasPressed = this.pressed;
+            this.sticky = definition.sticky || false;
+            this.state.set('pressed', false);
+            this.initialPress = true;
+        },
+
+        events: {// These are messages that this component listens for
+            "handle-logic": function () {
+                if (this.sticky) {
+                    if (this.pressed && !this.wasPressed) {
+                        this.state.set('pressed', true);
+                        this.wasPressed = true;
+                        this.owner.triggerEvent('switch-on');
+                    }
+                } else {
+                    if (this.pressed !== this.wasPressed) {
+                        if (this.pressed) {
+                            this.state.set('pressed', true);
+                            this.owner.triggerEvent('switch-on');
+                        } else {
+                            this.state.set('pressed', false);
+                            this.owner.triggerEvent('switch-off');
+                        }
+                    }
+                    this.wasPressed = this.pressed;
+                    this.pressed = false;
+                }
+            },
+            'switch-pressed': function () {
+                this.pressed = true;
+                if (this.initialPress) {
+                    this.owner.triggerEvent('initial-press');
+                    this.initialPress = false;
+                }
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.state = null;
+            }
+        }
+    });
+}());

package/src/components/LogicTeleportee.js

@@ -0,0 +1,68 @@
+/**
+### Local Broadcasts:
+- **teleport-complete** - Triggered once the entity has been moved to the new location.
+
+## JSON Definition
+    {
+      "type": "LogicTeleportee"
+    }
+*/
+import Vector from '../Vector.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicTeleportee.prototype */{
+        id: 'LogicTeleportee',
+        
+        /**
+         * This component causes an entity to teleport when receiving a teleport message.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         * @fires platypus.Entity#relocate-entity
+         */
+        initialize: function () {
+            this.teleportDestination = Vector.setUp();
+            this.teleportNow = false;
+            this.DestinationSet = false;
+            this.message = {
+                position: this.teleportDestination
+            };
+        },
+
+        events: {// These are messages that this component listens for
+            "handle-logic": function () {
+                if (this.teleportNow) {
+                    this.owner.triggerEvent('relocate-entity', this.message);
+                    this.teleportNow = false;
+                    this.owner.triggerEvent('teleport-complete');
+                }
+            },
+            "teleport": function () {
+                if (this.destinationSet) {
+                    this.teleportNow = true;
+                }
+            },
+            "set-destination": function (position) {
+                this.setDestination(position);
+            },
+            "hit-telepoint": function (collisionInfo) {
+                this.setDestination(collisionInfo.entity);
+            }
+        },
+        
+        methods: {
+            setDestination: function (position) {
+                this.teleportDestination.setXYZ(position.x, position.y, this.owner.z);
+                this.destinationSet = true;
+            },
+            
+            destroy: function () {
+                this.teleportDestination.recycle();
+            }
+        }
+    });
+}());

package/src/components/LogicTeleporter.js

@@ -0,0 +1,93 @@
+/**
+### Listens for:
+- **teleport-entity** - On receiving this message, the component will fire `teleport` on the colliding entity, sending this.destination. The colliding entity must handle the `teleport` message and relocate itself.
+  - @param message.x (integer) - uses `x` to determine if collision occurred on the left (-1) or right (1) of this entity.
+  - @param message.y (integer) - uses `y` to determine if collision occurred on the top (-1) or bottom (1) of this entity.
+  - @param message.entity (object) - triggers a `teleport` message on `entity`.
+
+### Peer Broadcasts:
+- **teleport** - On receiving a `teleport-entity` message, if the colliding entity is colliding on the teleporter's facing side, this message is triggered on the colliding entity.
+  - @param message (object) - sends the destination entity as the message object, the x and y coordinates being the most important information for the listening entity.
+
+## JSON Definition:
+    {
+      "type": "LogicTeleporter",
+      
+      "facing": "up",
+      // Optional: "up", "down", "left", or "right". Will only trigger "teleport" if colliding entity collides on the facing side of this entity. If nothing is specified, all collisions fire a "teleport" message on the colliding entity.
+      
+      "teleportId": "Destination entity's linkId property"
+      // Required: String that matches the "linkId" property of the destination entity. This destination entity is passed on a "teleport" message so teleporting entity knows where to relocate.
+    }
+
+*/
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicTeleporter.prototype */{
+        id: 'LogicTeleporter',
+
+        /**
+         * This component listens for redirected collision messages and fires a message on the colliding entity to specify where the colliding entity should relocate itself.
+         * 
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition
+         * @listens platypus.Entity#peer-entity-added
+         */
+        initialize: function (definition) {
+            
+            this.destination = null;
+            this.linkId = this.owner.teleportId || definition.teleportId;
+            this.facing = this.owner.facing || definition.facing || false; //TODO: Should probably deprecate this in favor of orientation. - DDD 3/2/2016
+        
+            if (this.facing) {
+                this.owner.state.set('facing-' + this.facing, true);
+            }
+        },
+
+        events: {// These are messages that this component listens for
+            "peer-entity-added": function (entity) {
+                if (!this.destination && (entity.linkId === this.linkId)) {
+                    this.destination = entity;
+                }
+            },
+    
+            "teleport-entity": function (collisionInfo) {
+                switch (this.facing) {
+                case 'up':
+                    if (collisionInfo.y < 0) {
+                        collisionInfo.entity.triggerEvent('teleport', this.destination);
+                    }
+                    break;
+                case 'right':
+                    if (collisionInfo.x > 0) {
+                        collisionInfo.entity.triggerEvent('teleport', this.destination);
+                    }
+                    break;
+                case 'down':
+                    if (collisionInfo.y > 0) {
+                        collisionInfo.entity.triggerEvent('teleport', this.destination);
+                    }
+                    break;
+                case 'left':
+                    if (collisionInfo.x < 0) {
+                        collisionInfo.entity.triggerEvent('teleport', this.destination);
+                    }
+                    break;
+                default:
+                    collisionInfo.entity.triggerEvent('teleport', this.destination);
+                    break;
+                }
+            }
+        },
+        
+        methods: {// These are methods that are called on the component
+            "destroy": function () {
+                this.destination = null;
+            }
+        }
+        
+    });
+}());