@makefully/platypus 4.1.4 → 4.1.6

package/src/components/RandomEvents.js

@@ -0,0 +1,73 @@
+/**
+ * This component listens for certain messages, picks a message from a related list of events, and triggers it. This is useful for adding random behaviors to an entity, such as having an entity say one thing from a list of audio clips. For example, defining this component on an Entity may look like this:
+ * 
+ *     {
+ *       "type": "RandomEvents",
+ *       "trueRandom": "true",
+ *       //If true, events will play completely randomly, otherwise all events in the set will fire before repeating.
+ *       
+ *       "events": {
+ *       // This is a key/value list of events to listen for, with each event mapping to an array of events to pick from.
+ *       
+ *         "make-sound": ["scream", "whisper", "talk"]
+ *         //on the component receiving the "make-sound" message, it will trigger one of the three possible messages listed here.
+ *       }
+ *     }
+ *     
+ * @memberof platypus.components
+ * @class RandomEvents
+ * @uses platypus.Component
+*/
+import RandomSet from '../RandomSet.js';
+import createComponentClass from '../factory.js';
+
+const
+    createTrigger = function (eventSet) {
+        return function (value, debug) {
+            this.owner.trigger(eventSet.get(), value, debug);
+        };
+    },
+    createTrueRandomTrigger = function (eventList) {
+        return function (value, debug) {
+            this.owner.trigger(eventList[Math.floor(Math.random() * eventList.length)], value, debug);
+        };
+    };
+
+export default createComponentClass(/** @lends platypus.components.RandomEvents.prototype */{
+    id: 'RandomEvents',
+
+    properties: {
+        events: null,
+
+        /**
+         * Whether to cycle through all options (default) or just trigger any option.
+         * 
+         * @property trueRandom
+         * @type boolean
+         * @default false
+         */
+        trueRandom: false
+    },
+    
+    initialize: function () {
+        const
+            events = this.events;
+
+        if (events) {
+            const
+                keys = Object.keys(events),
+                {length} = keys;
+    
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                if (this.trueRandom) {
+                    this.addEventListener(key, createTrueRandomTrigger(events[key]));
+                } else {
+                    this.addEventListener(key, createTrigger(RandomSet.setUp(events[key])));
+                }
+            }
+        }
+    }
+});

package/src/components/RelativePosition.js

@@ -0,0 +1,204 @@
+import AABB from '../AABB.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.RelativePosition.prototype */{
+        
+        id: 'RelativePosition',
+
+        properties: {
+            /**
+             * This optional array sets varying properties depending on the aspect ratio of the camera. This is useful if the camera aspect ratio varies greatly and entities must be repositioned accordingly.
+             *
+             * In this example, the entity maintains a particular horizontal location until the camera viewport becomes narrower than 2:1, at which point it maintains a particular `left` value:
+             *
+             *      "cameraSizes": [{
+             *          "minRatio": 2, // This block applies for wide aspect ratios until 2:1 is reached.
+             *          "x": -1226
+             *      }, {
+             *          "minRatio": 0, // This block applies for everything else.
+             *          "left": 130
+             *      }]
+             *
+             * @property cameraSizes
+             * @type Array
+             * @default null
+             */
+            cameraSizes: null
+        },
+        
+        publicProperties: {
+            /**
+             * This sets the distance in world units from the bottom of the camera's world viewport. If set, it will override the entity's y coordinate. This property is accessible on the entity as `entity.bottom`.
+             *
+             * @property bottom
+             * @type Number
+             * @default null
+             */
+            bottom: null,
+
+            /**
+             * This sets the distance in world units from the left of the camera's world viewport. If set, it will override the entity's x coordinate. This property is accessible on the entity as `entity.left`.
+             *
+             * @property left
+             * @type Number
+             * @default null
+             */
+            left: null,
+
+            /**
+             * This sets the distance in world units from the right of the camera's world viewport. If set, it will override the entity's x coordinate. This property is accessible on the entity as `entity.right`.
+             *
+             * @property right
+             * @type Number
+             * @default null
+             */
+            right: null,
+
+            /**
+             * This sets the distance in world units from the top of the camera's world viewport. If set, it will override the entity's y coordinate. This property is accessible on the entity as `entity.top`.
+             *
+             * @property top
+             * @type Number
+             * @default null
+             */
+            top: null,
+
+            /**
+             * This sets the scale in X of the entity.
+             *
+             * @property scaleX
+             * @type Number
+             * @default 1
+             */
+            scaleX: 1,
+
+            /**
+             * This sets the scale in Y of the entity.
+             *
+             * @property scaleY
+             * @type Number
+             * @default 1
+             */
+            scaleY: 1,
+
+            /**
+             * This sets the `x` coordinate for the entity. It is overridden by `left` and `right` properties if supplied.
+             *
+             * @property x
+             * @type Number
+             * @default 0
+             */
+            x: 0,
+
+            /**
+             * This sets the `y` coordinate for the entity. It is overridden by `top` and `bottom` properties if supplied.
+             *
+             * @property y
+             * @type Number
+             * @default 0
+             */
+            y: 0
+        },
+        
+        /**
+         * This component positions an entity relative to the camera viewport, according to `left`, `top`, `right`, and `left` properties.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#camera-update
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (/*definition, callback*/) {
+            this.aabb = AABB.setUp();
+            this.lastBottom = null;
+            this.lastLeft = null;
+            this.lastRight = null;
+            this.lastTop = null;
+            this.cameraSizesIndex = -1;
+        },
+
+        events: {
+            "handle-logic": function () {
+                const
+                    {bottom, left, right, top} = this;
+
+                if ((this.lastBottom !== bottom) || (this.lastLeft !== left) || (this.lastRight !== right) || (this.lastTop !== top)) {
+                    this.updatePosition(this.aabb);
+                    this.lastBottom = bottom;
+                    this.lastLeft = left;
+                    this.lastRight = right;
+                    this.lastTop = top;
+                }
+            },
+
+            "camera-update": function (camera) {
+                this.aabb.set(camera.viewport);
+                if (this.cameraSizes) {
+                    this.checkCamera(this.aabb);
+                }
+                this.updatePosition(this.aabb);
+            }
+        },
+        
+        methods: {// These are internal methods that are invoked by this component.
+            checkCamera: function (aabb) {
+                const
+                    arr = this.cameraSizes,
+                    ratio = aabb.width / aabb.height;
+
+                for (let i = 0; i < arr.length; i++) {
+                    if (ratio > arr[i].minRatio) {
+                        if (i !== this.cameraSizesIndex) {
+                            this.updateProperties(arr[i]);
+                            this.cameraSizesIndex = i;
+                        }
+                        break;
+                    }
+                }
+            },
+
+            updateProperties: function (props) {
+                this.right = (typeof props.right === 'number') ? props.right : null;
+                this.left = (typeof props.left === 'number') ? props.left : null;
+                this.top = (typeof props.top === 'number') ? props.top : null;
+                this.bottom = (typeof props.bottom === 'number') ? props.bottom : null;
+                if (typeof props.x === 'number') {
+                    this.x = props.x;
+                }
+                if (typeof props.y === 'number') {
+                    this.y = props.y;
+                }
+                if (typeof props.scaleX === 'number') {
+                    this.scaleX = props.scaleX;
+                }
+                if (typeof props.scaleY === 'number') {
+                    this.scaleY = props.scaleY;
+                }
+            },
+
+            updatePosition: function (vp) {
+                const
+                    {bottom, left, owner, right, top} = this;
+
+                if (typeof left === 'number') {
+                    owner.x = vp.left + left;
+                } else if (typeof right === 'number') {
+                    owner.x = vp.right - right;
+                }
+
+                if (typeof top === 'number') {
+                    owner.y = vp.top + top;
+                } else if (typeof bottom === 'number') {
+                    owner.y = vp.bottom - bottom;
+                }
+            },
+
+            destroy: function () {
+                this.aabb.recycle();
+                this.aabb = null;
+            }
+        }
+    });
+}());

package/src/components/RelayFamily.js

@@ -0,0 +1,106 @@
+/* global platypus */
+import {arrayCache, greenSlice, greenSplice, union} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.RelayFamily.prototype */{
+        id: 'RelayFamily',
+        
+        properties: {
+            /**
+             * This is an object of key/value pairs. The keys are events this component is listening for locally, the value is the event that will be broadcast to its linked entities. The value can also be an array of events to be fired on linked entities.
+             *
+             *      "events": {
+             *          "sleeping": "good-night",
+             *          "awake": ["alarm", "get-up"]
+             *      }
+             *
+             * @property events
+             * @type Object
+             * @default null
+             */
+            events: null
+        },
+
+        /**
+         * This component allows an entity to communicate directly with one or more entities via the message model, by passing local messages directly to entities in the same family as new triggered events. This component is placed on a single entity and all entities created by this entity become part of its "family".
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#entity-created
+         * @listens platypus.Entity#link-family
+         * @fires platypus.Entity#link-family
+         */
+        initialize: function () {
+            const
+                events = this.events;
+            
+            if (events) {
+                const
+                    keys = Object.keys(events),
+                    {length} = keys;
+
+                for (let i = 0; i < length; i++) {
+                    const
+                        key = keys[i];
+
+                    this.addEventListener(key, this.broadcast.bind(this, null, events[key]));
+                }
+            }
+    
+            this.owner.familyLinks = arrayCache.setUp(this.owner);
+        },
+        
+        events: {
+            "link-family": function (links) {
+                const
+                    oldList = this.owner.familyLinks,
+                    newList = union(union(arrayCache.setUp(), links), oldList);
+
+                for (let i = 0; i < newList.length; i++) {
+                    newList[i].familyLinks = newList;
+                }
+                this.broadcast(links,   'family-members-added', oldList);
+                this.broadcast(oldList, 'family-members-added', links);
+                arrayCache.recycle(oldList);
+            },
+            
+            "entity-created": function (entity) {
+                /**
+                 * Called when linking a new member to the family, this event accepts a list of family members from the new member and uses it to link all the family members together.
+                 *
+                 * @event platypus.Entity#link-family
+                 * @param links {Array|Entities} An array of entities.
+                 */
+                if (!entity.triggerEvent('link-family', this.owner.familyLinks)) {
+                    entity.addComponent(new platypus.components.RelayFamily(entity, {}));
+                    entity.triggerEvent('link-family', this.owner.familyLinks);
+                }
+            }
+        },
+        
+        methods: {
+            broadcast: function (links, ...args) {
+                const
+                    entities = links || this.owner.familyLinks;
+
+                for (let i = 0; i < entities.length; i++) {
+                    entities[i].trigger.apply(entities[i], args);
+                }
+            },
+            
+            destroy: function () {
+                const
+                    {familyLinks} = this.owner,
+                    i = familyLinks.indexOf(this.owner);
+                
+                if (i >= 0) {
+                    greenSplice(familyLinks, i);
+                }
+                this.broadcast(familyLinks, 'family-member-removed', this.owner);
+                this.events = null;
+            }
+        }
+    });
+}());

package/src/components/RelayGame.js

@@ -0,0 +1,53 @@
+/**
+ * This component listens for specified local entity messages and re-broadcasts them at the scene level.
+ *
+ * @memberof platypus.components
+ * @class RelayGame
+ * @uses platypus.Component
+ */
+/* global platypus */
+import createComponentClass from '../factory.js';
+
+const
+    broadcast = function () {
+        platypus.game.triggerOnChildren.apply(platypus.game, arguments);
+    };
+
+export default createComponentClass(/** @lends platypus.components.RelayGame.prototype */{
+    id: 'RelayGame',
+    
+    properties: {
+        /**
+         * This is an object of key/value pairs. The keys are events this component is listening for locally, and the value is the event to be broadcast to the scene. The value can also be an array of events to be fired on the scene.
+         *
+         *      "events": {
+         *          "sleeping": "good-night",
+         *          "awake": ["alarm", "get-up"]
+         *      }
+         *
+         * @property events
+         * @type Object
+         * @default null
+         */
+        events: null
+    },
+
+    initialize: function () {
+        const
+            events = this.events;
+        
+        // Messages that this component listens for and then broadcasts to all layers.
+        if (events) {
+            const
+                keys = Object.keys(events),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                this.addEventListener(key, broadcast.bind(this, events[key]));
+            }
+        }
+    }
+});

package/src/components/RelayLinker.js

@@ -0,0 +1,94 @@
+/* global platypus */
+import createComponentClass from '../factory.js';
+import {greenSplice} from '../utils/array.js';
+
+const
+    channels = {},
+    broadcast = function (...args) {
+        const channel = this.channel;
+
+        for (let i = 0; i < channel.length; i++) {
+            channel[i].trigger(...args);
+        }
+    };
+
+export default createComponentClass(/** @lends platypus.components.RelayLinker.prototype */{
+    id: 'RelayLinker',
+
+    properties: {
+        /**
+         * The id that defines the 'channel' the linkers are talking on. This should be matched on the entity/entities you want to talk between.
+         *
+         * @property linkId
+         * @type String
+         * @default 'linked'
+         */
+        linkId: 'linked',
+        
+        /**
+         * This is an object of key/value pairs. The keys are events this component is listening for locally, the value is the event to be broadcast to its linked entities. The value can also be an array of events to be fired on linked entities.
+         *
+         *      "events": {
+         *          "sleeping": "good-night",
+         *          "awake": ["alarm", "get-up"]
+         *      }
+         *
+         * @property events
+         * @type Object
+         * @default null
+         */
+        events: null
+    },
+
+    /**
+     * Allows an entity to communicate directly with one or more entities via the message model by passing local events directly to the linked entities as new triggered events.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @listens platypus.Entity#load
+     */
+    initialize: function () {
+        const
+            {events, linkId} = this;
+
+        if (events) {
+            const
+                keys = Object.keys(events),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                this.addEventListener(key, broadcast.bind(this, events[key]));
+            }
+        }
+        
+        if (!this.owner.linkId) {
+            this.owner.linkId = linkId;
+        }
+        
+        // Connect channel, or create if it doesn't exist.
+        this.channel = channels[linkId] = channels[linkId] ?? [];
+    },
+    
+    events: {
+        "load": function () {
+            this.channel.push(this.owner);
+        }
+    },
+    
+    methods: {
+        destroy: function () {
+            const index = this.channel.indexOf(this.owner);
+
+            if (index >= 0) {
+                greenSplice(this.channel, index);
+            } else {
+                platypus.debug.warn('RelayLinker: Component destroyed, but entity not found on channel.');
+            }
+            this.events = null;
+        }
+    }
+});

package/src/components/RelayParent.js

@@ -0,0 +1,57 @@
+/**
+ * This component listens for specified local entity messages and re-broadcasts them on its parent entity.
+ *
+ * @memberof platypus.components
+ * @class RelayParent
+ * @uses platypus.Component
+ */
+import createComponentClass from '../factory.js';
+
+const
+    broadcast = function () {
+        const
+            {parent} = this.owner;
+        
+        if (parent) {
+            parent.trigger.apply(parent, arguments);
+        }
+    };
+
+export default createComponentClass(/** @lends platypus.components.RelayParent.prototype */{
+    id: 'RelayParent',
+    
+    properties: {
+        /**
+         * This is an object of key/value pairs. The keys are events this component is listening for locally, and the value is the event to be broadcast on the parent. The value can also be an array of events to be triggered on the parent.
+         *
+         *      "events": {
+         *          "sleeping": "good-night",
+         *          "awake": ["alarm", "get-up"]
+         *      }
+         *
+         * @property events
+         * @type Object
+         * @default null
+         */
+        events: null
+    },
+
+    initialize: function () {
+        const
+            events = this.events;
+        
+        // Messages that this component listens for and then broadcasts to parent.
+        if (events) {
+            const
+                keys = Object.keys(events),
+                {length} = keys;
+    
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                this.addEventListener(key, broadcast.bind(this, events[key]));
+            }
+        }
+    }
+});

package/src/components/RelaySelf.js

@@ -0,0 +1,55 @@
+/**
+ * This component listens for specified local entity messages and re-broadcasts them on itself as other messages.
+ *
+ * @memberof platypus.components
+ * @class RelaySelf
+ * @uses platypus.Component
+ */
+import createComponentClass from '../factory.js';
+
+const
+    trigger = function () {
+        const
+            {owner} = this;
+        
+        owner.trigger.apply(owner, arguments);
+    };
+
+export default createComponentClass(/** @lends platypus.components.RelaySelf.prototype */{
+    id: 'RelaySelf',
+    
+    properties: {
+        /**
+         * This is an object of key/value pairs. The keys are events this component is listening for locally, the value is the new event to be broadcast on this entity. The value can also be an array of events to be fired.
+         *
+         *      "events": {
+         *          "sleeping": "good-night",
+         *          "awake": ["alarm", "get-up"]
+         *      }
+         *
+         * @property events
+         * @type Object
+         * @default null
+         */
+        events: null
+    },
+
+    initialize: function () {
+        const
+            events = this.events;
+        
+        // Messages that this component listens for and then triggers on itself as a renamed message - useful as a logic place-holder for simple entities.
+        if (events) {
+            const
+                keys = Object.keys(events),
+                {length} = keys;
+    
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+                    
+                this.addEventListener(key, trigger.bind(this, events[key]));
+            }
+        }
+    }
+});