@makefully/platypus 4.1.5 → 4.1.6

package/src/components/ComponentSwitcher.js

@@ -0,0 +1,173 @@
+/* global platypus */
+import {arrayCache, union} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+export default createComponentClass(/** @lends platypus.components.ComponentSwitcher.prototype */{
+    id: 'ComponentSwitcher',
+    
+    properties: {
+        /**
+         * This is the list of messages to listen for (as the keys) with the settings as two arrays of components to add and components to remove.
+         *
+            {
+                "found-pogostick":{
+                    "add":[
+                    // This is a list of components to add when "found-pogostick" is triggered on the entity. If it's adding a single component, "add" can be a reference to the component definition itself rather than an array of one object.
+                    {"type": "Mover"},
+                    {"type": "HeadGear"}
+                    ]
+                    
+                    "remove": ["CarSeat"]
+                    // This is a string list of component ids to remove when "found-pogostick" is triggered on the entity. It will ignore listed components that are not connected to the entity.
+                },
+                
+                // Multiple events can cause unique components to be added or removed
+                "walking-indoors":{
+                    "remove": ["HeadGear"]
+                },
+                
+                "contemplate":{
+                    "add": {"type": "AIPacer"}
+                }
+                }
+            }
+            *
+            * @property componentMap
+            * @type Object
+            * @default null
+            */
+        componentMap: null
+    },
+    
+    /**
+     * This component listens for messages and, according to its preset settings, will remove and add components to the entity. This is useful if certain events should modify the behavior of the entity in some way: for example, acquiring a pogo-stick might add a jumping component so the hero can jump.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @listens platypus.Entity#prepare-logic
+     * @fires platypus.Entity#child-entity-updated
+     * @fires platypus.Entity#add-remove-component-complete
+     */
+    initialize: function () {
+        const
+            {componentMap} = this,
+            switches = this.switches = arrayCache.setUp(); // The list of switches to make.
+        
+        if (componentMap) {
+            const
+                keys = Object.keys(componentMap),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    key = keys[i];
+
+                // Message(s) listed by `componentMap` will add or remove components.
+                this.addEventListener(key, (event) => {
+                    switches.push(event);
+                });
+            }
+        }
+    },
+    
+    events: {
+        "prepare-logic": function () {
+            if (this.switches.length) {
+                for (let i = 0; i < this.switches.length; i++) {
+                    this.switchComponents(this.componentMap[this.switches[i]]);
+                }
+                this.switches.length = 0;
+            }
+        }
+    },
+    
+    methods: {
+        switchComponents: function (definition) {
+            const
+                owner = this.owner,
+                components = owner.components,
+                remove = definition.remove,
+                add = definition.add;
+                
+            if (remove) {
+                if (!Array.isArray(remove)) {
+                    for (let i = components.length - 1; i > -1; i--) {
+                        if (components[i].type === remove) {
+                            owner.removeComponent(components[i]);
+                        }
+                    }
+                } else {
+                    for (let i = 0; i < remove.length; i++) {
+                        for (let j = components.length - 1; j > -1; j--) {
+                            if (components[j].type === remove[i]) {
+                                owner.removeComponent(components[j]);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (add) {
+                if (!Array.isArray(add)) {
+                    owner.addComponent(new platypus.components[add.type](owner, add));
+                } else {
+                    for (let i = 0; i < add.length; i++) {
+                        owner.addComponent(new platypus.components[add[i].type](owner, add[i]));
+                    }
+                }
+            }
+            
+            /**
+            * This message is triggered on the parent when the entity's components change.
+            *
+            * @event platypus.Entity#child-entity-updated
+            * @param entity {platypus.Entity} This is the entity itself.
+            */
+            owner.parent.triggerEvent('child-entity-updated', owner);
+
+            /**
+            * This message is triggered on the entity itself when its components change.
+            *
+            * @event platypus.Entity#add-remove-component-complete
+            */
+            owner.triggerEvent('add-remove-component-complete');
+        },
+        
+        destroy: function () {
+            arrayCache.recycle(this.switches);
+        }
+    },
+    
+    getAssetList: function (def, props, defaultProps) {
+        const
+            componentMap = def?.componentMap ?? props?.componentMap ?? defaultProps?.componentMap,
+            assets = arrayCache.setUp();
+        
+        if (componentMap) {
+            const
+                keys = Object.keys(componentMap),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    adds = map[keys[i]].add;
+
+                for (let j = 0; j < adds.length; j++) {
+                    const
+                        component = platypus.components[adds[j].type];
+
+                    if (component) {
+                        const
+                            arr = component.getAssetList(adds[j], props, defaultProps);
+                            
+                        union(assets, arr);
+                        arrayCache.recycle(arr);
+                    }
+                }
+            }
+        }
+        
+        return assets;
+    }
+});

package/src/components/ControllerInput.js

@@ -0,0 +1,65 @@
+/**
+ * Maps pointer presses on this entity to game-wide controller events consumed by {@link platypus.components.HandlerController}.
+ * Add {@link platypus.components.Interactive} (or another source of pointer events) on the same entity so presses hit the control.
+ *
+ * @memberof platypus.components
+ * @class ControllerInput
+ * @uses platypus.Component
+ */
+/* global platypus */
+import createComponentClass from '../factory.js';
+
+export default createComponentClass(/** @lends platypus.components.ControllerInput.prototype */{
+    id: 'ControllerInput',
+
+    properties: {
+        /**
+         * Control code passed to `HandlerController` (for example `jump` or `menu-select`).
+         * Defaults to the entity's `type` when unset.
+         *
+         * @property code
+         * @type String
+         * @default null
+         */
+        code: null,
+
+        /**
+         * Input device style. Only `button` is supported: `pointerdown` / `pointerup` (and cancel/outside) map to controller down/up.
+         *
+         * @property controllerType
+         * @type String
+         * @default button
+         */
+        controllerType: 'button'
+    },
+
+    initialize () {
+        const
+            {code, controllerType, owner: entity} = this,
+            onUp = () => platypus.game.triggerOnChildren('controller-input-up', {
+                code: code ?? entity.type,
+                entity
+            }),
+            onDown = () => platypus.game.triggerOnChildren('controller-input-down', {
+                code: code ?? entity.type,
+                entity
+            });
+
+        switch (controllerType) {
+            default: {
+                const
+                    down = this.addEventListener('pointerdown', onDown),
+                    up = this.addEventListener('pointerup', onUp),
+                    upOutside = this.addEventListener('pointerupoutside', onUp),
+                    cancel = this.addEventListener('pointercancel', onUp);
+
+                this.unattachControls = () => {
+                    this.removeEventListener('pointerdown', down);
+                    this.removeEventListener('pointerup', up);
+                    this.removeEventListener('pointerupoutside', upOutside);
+                    this.removeEventListener('pointercancel', cancel);
+                };
+            }
+        }
+    }
+});

package/src/components/Counter.js

@@ -0,0 +1,165 @@
+import Data from '../Data.js';
+import createComponentClass from '../factory.js';
+
+/* global platypus */
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.Counter.prototype */{
+
+        id: 'Counter',
+
+        properties: {
+            /**
+             * Sets whether count is stored permanently. Can be set to a storage key or if `true` will use entity's type.
+             * 
+             * @property persistentStorage
+             * @type Boolean|String
+             * @default false
+             */
+            persistentStorage: false
+        },
+
+        publicProperties: {
+            /**
+             * Specifies the current count.
+             *
+             * @property count
+             * @type number
+             * @default 0
+             */
+            count: 0,
+
+            /**
+             * If total is supplied, progress reports part complete, 0-1.
+             *
+             * @property progress
+             * @type number
+             * @default 0
+             */
+            progress: 0,
+
+            /**
+             * A total the counter is incrementing toward.
+             *
+             * @property total
+             * @type number
+             * @default 0
+             */
+            total: 0
+        },
+
+        /**
+         * A simple component that keeps count of something and sends messages each time the count changes. Can also have a total. When it does it will display 'count / total'.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#change-total
+         * @listens platypus.Entity#change-count
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#increment-count
+         * @fires platypus.Entity#update-content
+         */
+        initialize: function () {
+            this.lastTotal = -1;
+            this.lastCount = -1;
+            this.message = Data.setUp(
+                "text", ""
+            );
+            if (this.persistentStorage) {
+                const
+                    storage = this.storage = platypus.game.storage;
+
+                if (this.persistentStorage === true) {
+                    this.persistentStorage = this.owner.type;
+                }
+
+                this.count = storage.get(this.persistentStorage) || 0;
+            }
+        },
+
+        events: {
+            "handle-logic": function () {
+                const
+                    msg = this.message;
+                let update = false;
+                
+                if (this.total !== this.lastTotal) {
+                    this.lastTotal = this.total;
+                    update = true;
+                }
+                
+                if (this.count !== this.lastCount) {
+                    this.lastCount = this.count;
+                    if (this.persistentStorage) {
+                        this.storage.set(this.persistentStorage, this.count);
+                    }
+                    update = true;
+                }
+                
+                if (update) {
+                    if (this.total) {
+                        msg.text = String(this.count) + "/" + String(this.total);
+                    } else {
+                        msg.text = String(this.count);
+                    }
+                    
+                    /**
+                     * A call used to notify other components that the count or total has changed.
+                     *
+                     * @event platypus.Entity#update-content
+                     * @param update.text {string} String describing the current count.
+                     */
+                    this.owner.triggerEvent('update-content', msg);
+
+                    if (this.total) {
+                        this.progress = this.count / this.total;
+                    }
+                }
+            },
+
+            /**
+             * Changes the total to the given value.
+             *
+             * @event platypus.Entity#change-total
+             * @param data.total {number} The new total value.
+             */
+            "change-total": function (total) {
+                this.total = total;
+            },
+
+            /**
+             * Changes the count to the given value.
+             *
+             * @event platypus.Entity#change-count
+             * @param data.count {number} The new count value.
+             */
+            "change-count": function (count) {
+                this.count = count;
+            },
+
+            /**
+             * Increments the count by 1.
+             *
+             * @event platypus.Entity#increment-count
+             */
+            "increment-count": function () {
+                this.count += 1;
+            },
+
+            /**
+             * Decrements the count by 1.
+             *
+             * @event platypus.Entity#decrement-count
+             */
+            "decrement-count": function () {
+                this.count -= 1;
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.message.recycle();
+            }
+        }
+    });
+}());

package/src/components/EntityCamera.js

@@ -0,0 +1,215 @@
+import AABB from '../AABB.js';
+import Data from '../Data.js';
+import createComponentClass from '../factory.js';
+import Vector from '../Vector.js';
+
+const
+    DEFAULT_SIZE = 100;
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.CameraFollowMe.prototype */{
+        id: 'EntityCamera',
+        
+        properties: {
+            /**
+             * Sets initial camera settings when the entity is being followed. This can be over-written by the "follow-me" call itself. If any of these attributes are not provided, the following are used by default:
+             *
+                  {
+                      "time": 500,
+                      // Optional. Time in milliseconds that the camera should focus before returning to the original focus.
+                      
+                      "mode": "forward",
+                      // Optional. Camera mode that the camera should use.
+                      
+                      "top": 100,
+                      // Optional number specifying top of viewport in world coordinates
+                      
+                      "left": 100,
+                      // Optional number specifying left of viewport in world coordinates
+                      
+                      "width": 100,
+                      // Optional number specifying width of viewport in world coordinates
+                      
+                      "height": 100,
+                      // Optional number specifying height of viewport in world coordinates
+                      
+                      "offsetX": 20,
+                      // Optional number setting how far to offset the camera from the entity horizontally.
+                      
+                      "offsetY": 40
+                      // Optional number setting how far to offset the camera from the entity vertically.
+                  }
+             *
+             * @property camera
+             * @type Object
+             * @default {}
+             */
+            camera: {},
+            
+            /**
+             * Camera mode that the camera should use.
+             *
+             * @property mode
+             * @type String
+             * @default "forward"
+             */
+            mode: "forward",
+
+            /**
+             * Whether to pause the game while the camera is focused.
+             *
+             * @property pause
+             * @type boolean
+             * @default false
+             */
+            pause: false
+        },
+
+        publicProperties: {
+            cameraBounds: null,
+            cameraFocus: 1,
+            cameraOffset: null,
+            cameraOffsetX: 0,
+            cameraOffsetY: 0,
+            cameraSize: null,
+            cameraWidth: 0,
+            cameraHeight: 0,
+            x: 0,
+            y: 0
+        },
+        
+        /**
+         * This component can request that the camera focus on this entity.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#follow-me
+         * @fires platypus.Entity#follow
+         * @fires platypus.Entity#pause-logic
+         * @fires platypus.Entity#pause-render
+         */
+        initialize: function () {
+            const
+                {cameraOffsetX, cameraOffsetY, cameraHeight, cameraWidth, x, y} = this;
+
+            this.pauseGame = (this.pause && this.camera.time) ? {
+                time: this.camera.time
+            } : null;
+            
+            Vector.assign(this.owner, 'cameraOffset', 'cameraOffsetX', 'cameraOffsetY');
+            Vector.assign(this.owner, 'cameraSize', 'cameraWidth', 'cameraHeight');
+            this.cameraBounds = AABB.setUp(x + cameraOffsetX, y + cameraOffsetY, cameraWidth, cameraHeight);
+
+            if (!this.cameraWidth) {
+                this.cameraWidth = this.owner.width || DEFAULT_SIZE;
+            }
+            if (!this.cameraHeight) {
+                this.cameraHeight = this.owner.height || DEFAULT_SIZE;
+            }
+
+            this.camera = Data.setUp(
+                "entity", this.owner,
+                "mode", this.camera.mode || this.mode,
+                "top", this.camera.top,
+                "left", this.camera.left,
+                "offsetX", this.camera.offsetX,
+                "offsetY", this.camera.offsetY,
+                "width", this.camera.width,
+                "height", this.camera.height,
+                "time", this.camera.time
+            );
+        },
+        
+        events: {
+            'handle-movement': function () {
+                const
+                    {cameraBounds, cameraOffsetX, cameraOffsetY, cameraHeight, cameraWidth, x, y} = this;
+
+                cameraBounds.setAll(x + cameraOffsetX, y + cameraOffsetY, cameraWidth, cameraHeight);
+            },
+
+            /**
+             * On receiving this message, the component will trigger a message requesting that the parent camera begin following this entity.
+             *
+             * @event platypus.Entity#follow-me
+             * @param {Object} [options] A list of key/value paris describing camera options to set.
+             * @param {String} [options.mode] Camera following mode.
+             * @param {number} [options.top] The top of a bounding box.
+             * @param {number} [options.left] The left of a bounding box.
+             * @param {number} [options.width] The width of a bounding box.
+             * @param {number} [options.height] The height of a bounding box.
+             * @param {number} [options.offsetX] How far to offset the camera from the entity horizontally.
+             * @param {number} [options.offsetY] How far to offset the camera from the entity vertically.
+             * @param {number} [options.time] How many milliseconds to follow the entity.
+             */
+            "follow-me": function (options) {
+                let msg = null;
+                
+                if (options) {
+                    msg = Data.setUp(
+                        "entity",  this.owner,
+                        "mode",    options.mode    || this.camera.mode,
+                        "top",     options.top     || this.camera.top,
+                        "left",    options.left    || this.camera.left,
+                        "offsetX", options.offsetX || this.camera.offsetX,
+                        "offsetY", options.offsetY || this.camera.offsetY,
+                        "width",   options.width   || this.camera.width,
+                        "height",  options.height  || this.camera.height,
+                        "time",    options.time    || this.camera.time
+                    );
+                } else {
+                    msg = Data.setUp(this.camera);
+                }
+
+                if (this.pauseGame) {
+
+                    /**
+                     * This component fires this message on the parent entity to pause logic if required.
+                     *
+                     * @event platypus.Entity#pause-logic
+                     * @param options {Object}
+                     * @param options.time {number} The amount of time to pause before re-enabling logic.
+                     */
+                    this.owner.parent.triggerEvent('pause-logic',  this.pauseGame);
+                    
+                    /**
+                     * This component fires this message on the parent entity to pause rendering if required.
+                     *
+                     * @event platypus.Entity#pause-render
+                     * @param options {Object}
+                     * @param options.time {number} The amount of time to pause before re-enabling render updates.
+                     */
+                    this.owner.parent.triggerEvent('pause-render', this.pauseGame);
+                }
+                
+                /**
+                 * This component fires this message on this entity's parent so the camera will begin following this entity.
+                 *
+                 * @event platypus.Entity#follow
+                 * @param {Object} message
+                 * @param {String} message.mode Can be "locked", "forward", "bounding", "anchor-bound", or "static". "static" suspends following, but the other three settings require that the entity parameter be defined. Also set the bounding area parameters if sending "bounding" as the following method and the movement parameters if sending "forward" as the following method.
+                 * @param {platypus.Entity} [message.entity] The entity that the camera should commence following.
+                 * @param {number} [message.top] The top of a bounding box following an entity.
+                 * @param {number} [message.left] The left of a bounding box following an entity.
+                 * @param {number} [message.width] The width of a bounding box following an entity.
+                 * @param {number} [message.height] The height of a bounding box following an entity.
+                 * @param {number} [message.movementX] Movement multiplier for focusing the camera ahead of a moving entity in the horizontal direction.
+                 * @param {number} [message.movementY] Movement multiplier for focusing the camera ahead of a moving entity in the vertical direction.
+                 * @param {number} [message.offsetX] How far to offset the camera from the entity horizontally.
+                 * @param {number} [message.offsetY] How far to offset the camera from the entity vertically.
+                 * @param {number} [message.time] How many milliseconds to follow the entity.
+                 */
+                this.owner.parent.triggerEvent('follow', msg);
+                
+                msg.recycle();
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.camera.recycle();
+            }
+        }
+    });
+}());