@makefully/platypus 4.1.5 → 4.1.8

package/src/components/HandlerController.js

@@ -0,0 +1,291 @@
+/* global platypus, window */
+import {arrayCache, greenSplice} from '../utils/array.js';
+import Gamepad from '../Gamepad.js';
+import createComponentClass from '../factory.js';
+
+const
+    broadcastHandleController = function (tick) {
+        if (hasGamepads) {
+            const
+                gamepads = [...window.navigator.getGamepads()],
+                standards = this.gamepads;
+
+            for (let i = 0; i < gamepads.length; i++) {
+                const gamepad = gamepads[i];
+
+                if (gamepad) {
+                    const standard = standards[gamepad.index];
+
+                    if (!standard) { // set up initial values so events can be triggered later
+                        standards[gamepad.index] = Gamepad.setUp(gamepad, onDown.bind(this, 'gamepad'), onUp.bind(this, 'gamepad'), onChange.bind(this, 'gamepad'));
+                    } else {
+                        standard.update(gamepad);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Triggered on owner and child entities on each tick to handle whatever they need to regarding controls.
+         *
+         * @event platypus.Entity#handle-controller
+         * @param tick {Object} An object containing tick data.
+         */
+        this.triggerOnAll('handle-controller', tick);
+    },
+    onDown = function (type, event) {
+        /**
+         *  Triggered on owner and child entities when a key goes from up to down.
+         *
+         * @event platypus.Entity#[event.code]:down
+         * @param event {DOMEvent} The DOM event that triggered the keydown event.
+         */
+        this.triggerControlAction(event.code, 'down', event);
+
+        updatePrecedence(type);
+
+        if (this.upOnBlur) {
+            this.upsToBlur.push(event.code);
+        }
+    },
+    onUp = function (type, event) {
+        /**
+         * Triggered on owner and child entities when a key goes from down to up.
+         *
+         * @event platypus.Entity#[event.code]:up
+         * @param event {DOMEvent} The DOM event that triggered the keyup event.
+         */
+        this.triggerControlAction(event.code, 'up', event);
+
+        updatePrecedence(type);
+
+        if (this.upOnBlur) {
+            const
+                i = this.upsToBlur.indexOf(event.code);
+            
+            if (i >= 0) {
+                this.upsToBlur.splice(i, 1);
+            }
+        }
+    },
+    onChange = function (type, event) {
+        /**
+         * Triggered on owner and child entities when an axis changes.
+         *
+         * @event platypus.Entity#[event.code]:change
+         * @param event {DOMEvent} The event that triggered the change event.
+         */
+        this.triggerControlAction(event.code, 'change', event);
+
+        updatePrecedence(type);
+    },
+    updatePrecedence = (type) => {
+        if (type !== inputs[0]) {
+            const was = inputs.indexOf(type);
+
+            if (was > 0) {
+                greenSplice(inputs, was);
+            }
+
+            inputs.unshift(type);
+
+            for (let i = 0; i < notifies.length; i++) {
+                notifies[i](inputs);
+            }
+        }
+    },
+    inputs = [],
+    notifies = [],
+    detectInvalids = {},
+    detectProcessing = {};
+let hasGamepads = false,
+    gameWideReady = false;
+
+window.addEventListener("gamepadconnected", () => {
+    hasGamepads = true;
+    updatePrecedence('gamepad');
+});
+
+window.addEventListener('touchstart', () => {
+    updatePrecedence('touch');
+});
+
+window.addEventListener('mousedown', () => {
+    updatePrecedence('mouse');
+});
+
+  
+//window.addEventListener("gamepaddisconnected", (event) => {});
+
+export default createComponentClass(/** @lends platypus.components.HandlerController.prototype */{
+    
+    id: 'HandlerController',
+    properties: {
+        /**
+         * Whether 'handle-controller' event should fire based on the 'handle-logic' event instead of the 'tick' event.
+         *
+         * @property useHandleLogic
+         * @type Boolean
+         * @default false
+         */
+        useHandleLogic: false,
+
+        /**
+         * Whether blur events should cause key release.
+         * 
+         * @property upOnBlur
+         * @type Boolean
+         * @default true
+         */
+        upOnBlur: true,
+
+        /**
+         * Which default key events should be allowed. Defaults to 'none'. May be 'none', 'all', or an array of allowed keys.
+         * 
+         * @property enableDefaultEvents
+         * @type String|Array
+         * @default 'none'
+         */
+        enableDefaultEvents: 'none'
+    },
+
+    publicProperties: {
+        inputPrecedence: inputs
+    },
+    
+    /**
+     * This component handles capturing and relaying input information to the entities that care about it. It takes mouse, keyboard, and custom input messages. State messages are sent immediately to the entities when they are received, the 'HandlerController' message is sent to demarcate ticks.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @listens platypus.Entity#handle-logic
+     * @listens platypus.Entity#tick
+     * @listens platypus.Game#tick
+     * @fires platypus.Entity#handle-controller
+     * @fires platypus.Entity#[event.code]:down
+     * @fires platypus.Entity#[event.code]:up
+     * @fires platypus.Entity#[event.code]:change
+     * @fires platypus.Entity#input-precedence-updated
+     */
+    initialize: function () {
+        const
+            {enableDefaultEvents} = this;
+
+        this.upsToBlur = [];
+
+        if (platypus.game.settings.debug || enableDefaultEvents === 'all') { // If this is a test build, leave in the browser key combinations so debug tools can be opened as expected.
+            this.callbackKeyDown = onDown.bind(this, 'keyboard');
+            this.callbackKeyUp = onUp.bind(this, 'keyboard');
+        } else { // Otherwise remove default browser behavior for key inputs so that they do not interfere with game-play.
+            const
+                preventDefault = Array.isArray(enableDefaultEvents) ? (event) => enableDefaultEvents.indexOf(event.code) === -1 ? event.preventDefault() : null : (event) => event.preventDefault();
+
+            this.callbackKeyDown = (event) => {
+                onDown.call(this, 'keyboard', event);
+                preventDefault(event); // default 'none' may be too aggressive - if problems arise, we may need to limit this to certain key combos that get in the way of game-play. Example: (event.metaKey && event.keyCode == 37) causes an accidental cmd key press to send the browser back a page while playing and hitting the left arrow button.
+            };
+            this.callbackKeyUp = (event) => {
+                onUp.call(this, 'keyboard', event);
+                preventDefault(event);
+            };
+        }
+
+        window.addEventListener('keydown', this.callbackKeyDown, true);
+        window.addEventListener('keyup',   this.callbackKeyUp,   true);
+
+        this.addEventListener('controller-input-down', (event) => this.triggerControlAction(event.code, 'down', event));
+        this.addEventListener('controller-input-up', (event) => this.triggerControlAction(event.code, 'up', event));
+
+        if (this.useHandleLogic) {
+            this.addEventListener('handle-logic', broadcastHandleController);
+        } else {
+            this.addEventListener('tick', broadcastHandleController);
+        }
+
+        this.gamepads = arrayCache.setUp();
+
+        this.notifier = (inputs) => {
+            /**
+             * Triggered on owner and child entities when player uses a new imput method. (For example, going from mouse to keyboard or keyboard to gamepad.)
+             *
+             * @event platypus.Entity#input-precedence-updated
+             * @param inputs {Array} A list of input methods, ordered by precedence with index 0 being the most recent input method.
+             */
+            this.triggerOnAll('input-precedence-updated', inputs);
+        };
+        notifies.push(this.notifier);
+
+        if (!gameWideReady) { // Need info at the game level to handle missed control input across layers
+            gameWideReady = true;
+            platypus.game.on('tick', function () {
+                const
+                    keys = Object.keys(detectInvalids),
+                    {length} = keys;
+
+                for (let i = 0; i < length; i++) {
+                    const
+                        key = keys[i];
+
+                    if (detectInvalids[key] === 0) {
+                        this.triggerOnChildren('invalid-input', key);
+                    } else {
+                        this.triggerOnChildren('valid-input', key);
+                    }
+                    delete detectInvalids[key];
+                }
+            }.bind(platypus.game));
+            window.addEventListener('blur', () => {
+                platypus.game.triggerOnChildren('blur-control');
+            });
+        }
+    },
+    events: {
+        'blur-control': function (event) {
+            if (this.upOnBlur) {
+                this.upsToBlur.forEach((upToBlur) => this.triggerControlAction(upToBlur, 'up', event));
+                this.upsToBlur.length = 0;
+            }
+        },
+        'invalid-input': function (input) {
+            this.owner.triggerEventOnChildren('invalid-input', input);
+        },
+        'valid-input': function (input) {
+            this.owner.triggerEventOnChildren('valid-input', input);
+        }
+    },
+    methods: {
+        destroy: function () {
+            window.removeEventListener('keydown', this.callbackKeyDown);
+            window.removeEventListener('keyup',   this.callbackKeyUp);
+            for (let i = 0; i < this.gamepads.length; i++) {
+                if (this.gamepads[i]) {
+                    this.gamepads[i].recycle();
+                }
+            }
+            arrayCache.recycle(this.gamepads);
+            greenSplice(notifies, notifies.indexOf(this.notifier));
+        },
+        triggerControlAction: function (control, action, ...args) {
+            const
+                event = `${control}:${action}`;
+
+            detectProcessing[control] = (detectProcessing[control] || 0) + this.triggerOnAll(event, ...args);
+            if (action === 'up') {
+                detectInvalids[control] = (detectInvalids[control] || 0) + detectProcessing[control];
+                detectProcessing[control] = 0;
+            }
+        },
+        triggerOnAll: function (event, ...args) {
+            const
+                owner = this.owner;
+            let count = owner.triggerEvent(event, ...args);
+
+            if (owner.triggerEventOnChildren) {
+                count += owner.triggerEventOnChildren(event, ...args);
+            }
+            
+            return count;
+        }
+    }
+});

package/src/components/HandlerLogic.js

@@ -0,0 +1,394 @@
+import {arrayCache, greenSplice} from '../utils/array.js';
+import AABB from '../AABB.js';
+import createComponentClass from '../factory.js';
+
+const
+    addAll = function (all, active) {
+        let j = all.length;
+        
+        active.length = 0;
+        while (j--) {
+            active.push(all[j]);
+        }
+    },
+    withinBounds = function (child, camera) {
+        return child.alwaysOn || (child.aabb && camera.collides(child.getAABB())) || (typeof child.x === 'undefined') || camera.containsPoint(child.x, child.y);
+    },
+    checkCamera = function (all, active, camera) {
+        let j = all.length;
+        
+        active.length = 0;
+        while (j--) {
+            const
+                child = all[j];
+
+            if (withinBounds(child, camera)) {
+                active.push(child);
+            }
+        }
+    },
+    hasLogic = function (item/*, index, arr*/) {
+        return (item === 'handle-logic' || item === 'handle-post-collision-logic' || item === 'prepare-logic' || item === 'state-changed' || item === 'handle-movement');
+    };
+
+export default createComponentClass(/** @lends platypus.components.HandlerLogic.prototype */{
+    id: "HandlerLogic",
+    properties: {
+        /**
+         * Whether logic should always run on all entities or only run on entities within the visible camera area (plus the buffer amount specified by the `buffer` property).
+         *
+         * @property alwaysOn
+         * @type Boolean
+         * @default false
+         */
+        alwaysOn: false
+    },
+    publicProperties: {
+        /**
+         * The buffer area around the camera in which entity logic is active. This property is available on the Entity as `entity.buffer`.
+         *
+         * @property buffer
+         * @type number
+         * @default camera width / 10
+         */
+        buffer: -1,
+        
+        /**
+         * The length in milliseconds of a single logic step. If the framerate drops too low, logic is run for each step of this many milliseconds. This property is available on the Entity as `entity.stepLength`.
+         *
+         * @property stepLength
+         * @type number
+         * @default 5
+         */
+        stepLength: 5,
+        
+        /**
+         * The maximum number of steps to take for a given tick, to prevent lag overflow.
+         *
+         * @property maxStepsPerTick
+         * @type number
+         * @default 100
+         */
+        maxStepsPerTick: 100,
+        
+        /**
+         * A multiplier that alters the speed at which the game is running. This is achieved by scaling the delta time in each tick.
+         * Defaults to 1. Values < 1 will slow down the logic, > 1 will speed it up.
+         *
+         * @property timeMultiplier
+         * @type number
+         * @default 1
+         */
+        timeMultiplier: 1
+    },
+
+    /**
+     * A component that handles updating logic components. Each tick it calls all the entities that accept 'handle-logic' messages. This component is usually used on an "action-layer".
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @param {*} definition 
+     * @listens platypus.Entity#camera-update
+     * @listens platypus.Entity#child-entity-added
+     * @listens platypus.Entity#child-entity-removed
+     * @listens platypus.Entity#child-entity-updated
+     * @listens platypus.Entity#pause-logic
+     * @listens platypus.Entity#tick
+     * @listens platypus.Entity#unpause-logic
+     * @fires platypus.Entity#handle-ai
+     * @fires platypus.Entity#handle-logic
+     * @fires platypus.Entity#logic-paused
+     * @fires platypus.Entity#logic-unpaused
+     * @fires platypus.Entity#prepare-logic
+     * @fires platypus.Entity#handle-movement
+     * @fires platypus.Entity#check-collision-group
+     * @fires platypus.Entity#handle-post-collision-logic
+     * @fires platypus.Entity#state-changed
+     */
+    initialize: function () {
+        this.entities = arrayCache.setUp();
+        this.activeEntities = arrayCache.setUp();
+        this.removals = arrayCache.setUp();
+        
+        this.inLogicLoop = false;
+
+        if (this.alwaysOn) {
+            this.updateList = addAll;
+            this.camera = null;
+        } else {
+            this.updateList = checkCamera;
+            this.camera = AABB.setUp();
+        }
+        
+        this.paused = 0;
+        this.leftoverTime = 0;
+        this.message = {
+            delta: this.stepLength,
+            tick: null,
+            camera: this.camera,
+            entities: this.activeEntities
+        };
+    },
+    
+    events: {
+        "child-entity-updated": function (entity) {
+            const
+                j = this.entities.indexOf(entity),
+                logical = entity.getMessageIds().some(hasLogic);
+
+            if (logical && (j < 0)) {
+                this.entities.push(entity);
+                
+                // Add to the active entities list so that the collision loop is aware of and can handle the addition.
+                if (this.inLogicLoop && (!this.camera || withinBounds(entity, this.camera))) {
+                    this.activeEntities.push(entity);
+                }
+            } else if (!logical && (j >= 0)) {
+                greenSplice(this.entities, j);
+                if (this.inLogicLoop) {
+                    this.removals.push(entity);
+                }
+            }
+        },
+
+        "child-entity-added": function (entity) {
+            if (entity.getMessageIds().some(hasLogic)) {
+                this.entities.push(entity);
+                
+                // Add to the active entities list so that the collision loop is aware of and can handle the addition.
+                if (this.inLogicLoop && (!this.camera || withinBounds(entity, this.camera))) {
+                    this.activeEntities.push(entity);
+                }
+            }
+        },
+
+        "child-entity-removed": function (entity) {
+            const
+                j = this.entities.indexOf(entity);
+            
+            if (j >= 0) {
+                greenSplice(this.entities, j);
+                if (this.inLogicLoop) {
+                    this.removals.push(entity);
+                }
+            }
+        },
+        
+        "pause-logic": function (resp) {
+            if (resp && resp.time) {
+                this.paused = resp.time;
+            } else {
+                this.paused = -1;
+            }
+            if (this.owner.triggerEventOnChildren) {
+                /**
+                 * Notifies children entities that logic has been paused.
+                 *
+                 * @event platypus.Entity#logic-paused
+                 */
+                this.owner.triggerEventOnChildren('logic-paused');
+            }
+        },
+        
+        "unpause-logic": function () {
+            this.paused = 0;
+            if (this.owner.triggerEventOnChildren) {
+                /**
+                 * Notifies children entities that logic has been unpaused.
+                 *
+                 * @event platypus.Entity#logic-unpaused
+                 */
+                this.owner.triggerEventOnChildren('logic-unpaused');
+            }
+        },
+        
+        "camera-update": function (camera) {
+            const
+                cam = this.camera;
+            
+            if (cam) {
+                const
+                    buffer = this.buffer === -1 ? camera.viewport.width / 10 : this.buffer, // sets a default buffer based on the size of the world units if the buffer was not explicitly set.
+                    vp = camera.viewport;
+
+                cam.setBounds(vp.left - buffer, vp.top - buffer, vp.right + buffer, vp.bottom + buffer);
+            }
+        },
+        
+        "tick": function (resp) {
+            const
+                {activeEntities: actives, message: msg, removals} = this,
+                stepLength = this.stepLength * this.timeMultiplier;
+            let cycles = 0;
+            
+            this.leftoverTime += (resp.delta * this.timeMultiplier);
+            cycles = Math.floor(this.leftoverTime / stepLength) || 1;
+    
+            // This makes the frames smoother, but adds variance into the calculations
+    //        msg.delta = this.leftoverTime / cycles;
+    //        this.leftoverTime = 0;
+            
+            // This makes the frames more exact, but varying step numbers between ticks can cause movement to be jerky
+    //        msg.delta = Math.min(this.leftoverTime, this.stepLength);
+    //        this.leftoverTime = Math.max(this.leftoverTime - (cycles * this.stepLength), 0);
+    
+            // This makes the frames exact, but varying step numbers between ticks can cause movement to be jerky
+            msg.gameDelta = this.stepLength;
+            msg.delta = stepLength;
+            this.leftoverTime = Math.max(this.leftoverTime - (cycles * stepLength), 0);
+    
+            msg.tick = resp;
+            
+            this.updateList(this.entities, actives, this.camera);
+            
+            //Prevents game lockdown when processing takes longer than time alotted.
+            cycles = Math.min(cycles, this.maxStepsPerTick);
+            
+            while (cycles--) {
+                
+                if (this.paused > 0) {
+                    this.paused -= stepLength;
+                    if (this.paused < 0) {
+                        this.paused = 0;
+                    }
+                }
+                
+                if (!this.paused) {
+                    let i = 0;
+
+                    this.inLogicLoop = true;
+                    
+                    /**
+                     * This event is triggered on the top-level layer to signify a "handle-logic" event is about to be triggered on children, and is then subsequently triggered on all of the layer's child entities. This is unique from the layer's "tick" event in that it occurs the same number of times as the "handle-logic" event and will not occur if HandlerLogic is paused.
+                     *
+                     * @event platypus.Entity#handle-logic
+                     * @param tick.delta {Number} The time that has passed since the last tick as manipulated by the timeMultiplier.
+                     * @param tick.gameDelta {Number} The time that has passed since the last tick. Unmanipulated by timeMultiplier. Use for components that need to run on actual time.
+                     * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                     * @param tick.entities {Array} This is a list of all the logically active entities.
+                     * @param tick.tick {Object} Tick object from "tick" event.
+                     */
+                    this.owner.triggerEvent('handle-logic', msg);
+                
+                    if (this.owner.triggerEventOnChildren) {
+                        /**
+                         * AI components listen in order to perform their logic on each tick.
+                         *
+                         * @event platypus.Entity#handle-ai
+                         * @param tick.delta {Number} The time that has passed since the last tick as manipulated by the timeMultiplier.
+                         * @param tick.gameDelta {Number} The time that has passed since the last tick. Unmanipulated by timeMultiplier. Use for components that need to run on actual time.
+                         * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                         * @param tick.entities {Array} This is a list of all the logically active entities.
+                         * @param tick.tick {Object} Tick object from "tick" event.
+                         */
+                        this.owner.triggerEventOnChildren('handle-ai', msg);
+                    }
+
+                    i = actives.length;
+                    while (i--) {
+                        const
+                            entity = actives[i];
+                        
+                        /**
+                         * This event is triggered on children entities to run anything that should occur before "handle-logic". For example, removing or adding components should happen here and not in "handle-logic".
+                         *
+                         * @event platypus.Entity#prepare-logic
+                         * @param tick {Object}
+                         * @param tick.delta {Number} The time that has passed since the last tick.
+                         * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                         * @param tick.entities {Array} This is a list of all the logically active entities.
+                         */
+                        entity.triggerEvent('prepare-logic', msg);
+
+                        entity.triggerEvent('handle-logic', msg);
+
+                        /**
+                         * This event is triggered on children entities to move. This happens immediately after logic so entity logic can determine movement.
+                         *
+                         * @event platypus.Entity#handle-movement
+                         * @param tick {Object}
+                         * @param tick.delta {Number} The time that has passed since the last tick.
+                         * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                         * @param tick.entities {Array} This is a list of all the logically active entities.
+                         */
+                        entity.triggerEvent('handle-movement', msg);
+                    }
+                    this.inLogicLoop = false;
+                    
+                    // This handles removing active entities from the list before collision checking, state-changing, etc.
+                    if (removals.length) {
+                        let j = removals.length;
+
+                        while (j--) {
+                            let k = actives.indexOf(removals[j]);
+
+                            if (k >= 0) {
+                                greenSplice(actives, k);
+                            }
+                        }
+                        removals.length = 0;
+                    }
+                    
+                    i = actives.length;
+                    /**
+                     * This event is triggered on the entity (layer) to test collisions once logic has been completed.
+                     *
+                     * @event platypus.Entity#check-collision-group
+                     * @param tick {Object}
+                     * @param tick.delta {Number} The time that has passed since the last tick.
+                     * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                     * @param tick.entities {Array} This is a list of all the logically active entities.
+                     */
+                    if (this.owner.triggerEvent('check-collision-group', msg)) { // If a collision group is attached, make sure collision is processed on each logic tick.
+                        /**
+                         * This event is triggered on entities to run logic that may depend upon collision responses.
+                         *
+                         * @event platypus.Entity#handle-post-collision-logic
+                         * @param tick {Object}
+                         * @param tick.delta {Number} The time that has passed since the last tick.
+                         * @param tick.camera {null|platypus.AABB} The range of the logic camera area. This is typically larger than the visible camera. This value is `null` if `alwaysOn` is set to `true` on this component.
+                         * @param tick.entities {Array} This is a list of all the logically active entities.
+                         */
+                            
+                        /**
+                         * Triggered on entities when the entity's state has been changed.
+                         *
+                         * @event platypus.Entity#state-changed
+                         * @param state {Object} A list of key/value pairs representing the owner's state (this value equals `entity.state`).
+                         */
+                        while (i--) {
+                            const
+                                entity = actives[i];
+
+                            entity.triggerEvent('handle-post-collision-logic', msg);
+                            if (entity.lastState?.update(entity.state)) {
+                                entity.triggerEvent('state-changed', entity.state);
+                            }
+                        }
+                    } else {
+                        while (i--) {
+                            const
+                                entity = actives[i];
+
+                            if (entity.lastState?.update(entity.state)) {
+                                entity.triggerEvent('state-changed', entity.state);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    
+    methods: {
+        destroy: function () {
+            arrayCache.recycle(this.entities);
+            this.entities = null;
+            arrayCache.recycle(this.activeEntities);
+            this.activeEntities = null;
+            arrayCache.recycle(this.removals);
+            this.removals = null;
+        }
+    }
+});