@makefully/platypus 4.1.5 → 4.1.6

package/src/components/LogicImpactLaunch.js

@@ -0,0 +1,144 @@
+/* global platypus */
+import Vector from '../Vector.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicImpactLaunch.prototype */{
+        id: 'LogicImpactLaunch',
+        
+        properties: {
+            /**
+             * Acceleration in X entity should have in world units while being launched.
+             *
+             * @property accelerationX
+             * @type number
+             * @default -0.3
+             */
+            accelerationX: -0.3,
+
+            /**
+             * Acceleration in Y entity should have in world units while being launched.
+             *
+             * @property accelerationY
+             * @type number
+             * @default -0.8
+             */
+            accelerationY: -0.8,
+
+            /**
+             * Whether X acceleration should flip according to the direction of the collision.
+             *
+             * @property flipX
+             * @type boolean
+             * @default true
+             */
+            flipX: true,
+
+            /**
+             * Whether Y acceleration should flip according to the direction of the collision.
+             *
+             * @property flipY
+             * @type boolean
+             * @default false
+             */
+            flipY: false,
+
+            /**
+             * This sets the state of the entity while it's being launched. Defaults to "stunned".
+             *
+             * @property state
+             * @type string
+             * @default "stunned"
+             */
+             state: "stunned"
+        },
+        
+        /**
+         * This component will cause the entity to move in a certain direction on colliding with another entity.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#component-added
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#hit-solid
+         */
+        initialize: function (definition) {
+            this.stunState = definition.state || "stunned";
+            
+            this.flipX = this.flipX ? -1 : 1;
+            this.flipY = this.flipY ? -1 : 1;
+
+            this.justJumped = false;
+            this.stunned = false;
+            
+            this.state = this.owner.state;
+            this.state.set('impact', false);
+            this.state.set(this.stunState, false);
+        },
+        
+        events: {
+            "component-added": function (component) {
+                if (component === this) {
+                    if (!this.owner.addMover) {
+                        platypus.debug.warn('The "LogicDirectionalMovement" component requires a "Mover" component to function correctly.');
+                        return;
+                    }
+
+                    this.direction = this.owner.addMover({
+                        velocity: [0, 0, 0],
+                        orient: false
+                    }).velocity;
+                    this.vector = Vector.setUp();
+                }
+            },
+
+            "handle-logic": function () {
+                this.state.set('impact', this.justJumped);
+                this.state.set(this.stunState, this.stunned);
+
+                if (this.justJumped) {
+                    this.direction.setVector(this.vector);
+                    this.justJumped = false;
+                    this.stunned = true;
+                }
+            },
+            
+            "impact-launch": function ({entity, x, y}) {
+                if (!this.stunned) {
+                    const
+                        {owner, vector} = this,
+                        dx = entity ? entity.x - owner.x : x,
+                        dy = entity ? entity.y - owner.y : y;
+
+                    this.justJumped = true;
+                    if (dx >= 0) {
+                        vector.x = this.accelerationX;
+                    } else if (dx < 0) {
+                        vector.x = this.accelerationX * this.flipX;
+                    }
+                    if (dy >= 0) {
+                        vector.y = this.accelerationY;
+                    } else if (dy < 0) {
+                        vector.y = this.accelerationY * this.flipY;
+                    }
+                }
+            },
+            
+            "hit-solid": function (collisionInfo) {
+                if (this.stunned && (collisionInfo.y > 0)) {
+                    this.direction.x = 0;
+                    this.direction.y = 0;
+                    this.stunned = false;
+                }
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.vector.recycle();
+                this.state = null;
+            }
+        }
+    });
+}());

package/src/components/LogicPacingPlatform.js

@@ -0,0 +1,64 @@
+/**
+## JSON Definition:
+    {
+      "type": "LogicDirectionalMovement",
+      
+      "angle": 3.14,
+      // Optional. Defines the angle of movement in radians. Defaults to 0 (horizontal, starts moving right).
+      
+      "distance": 440,
+      // Optional. Declares distance in world units that the entity should move back and forth across. Defaults to 128.
+      
+      "period": 6000,
+      // Optional. Sets the time in milliseconds that the entity should take to make a complete movement cycle. Defaults to 4 seconds (4000).
+      
+      "startPos": 0
+      // Optional. Position in the cycle that the movement should begin. Defaults in the middle at 0; PI/2 and -PI/2 will put you at the extremes.
+    }
+*/
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicPacingPlatform.prototype */{
+        
+        id: 'LogicPacingPlatform',
+        
+        /**
+         * This component changes the (x, y) position of an object according to its speed and heading and alternates back and forth. This is useful for in-place moving platforms.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (definition) {
+            this.ang      = this.owner.angle      || definition.angle     || 0; //PI/2 makes it go down first
+            this.dist     = this.owner.distance || definition.distance || 128; //Distance in pixels
+            this.dX       = this.dist * Math.cos(this.ang);
+            this.dY       = this.dist * Math.sin(this.ang);
+            this.period   = this.owner.period    || definition.period     || 4000;
+            this.time     = 0;
+            this.startPos = this.owner.startPos || definition.startPos || 0; //PI/2 and -PI/2 will put you at the extremes
+            this.offset   = 0;
+            this.originX  = this.owner.x;
+            this.originY  = this.owner.y;
+        },
+
+        events: {
+            "handle-logic": function ({delta}) {
+                const
+                    {period} = this;
+                
+                this.time += delta;
+                if (this.time > period) {
+                    this.time = this.time % period;
+                }
+                this.offset = (this.time / period) * (2 * Math.PI);
+                
+                this.owner.x = this.originX + Math.sin(this.offset + this.startPos) * this.dX;
+                this.owner.y = this.originY + Math.sin(this.offset + this.startPos) * this.dY;
+            }
+        }
+    });
+}());

package/src/components/LogicPortable.js

@@ -0,0 +1,112 @@
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicPortable.prototype */{
+        id: 'LogicPortable',
+        properties: {
+            /**
+             * This is an object specifying the directions that this portable entity can be carried on. Default is {down:true}, but "up", "down", "left", and/or "right" can be specified as object properties set to `true`.
+             *
+             * @property portableDirections
+             * @type Object
+             * @default {"down": true}
+             */
+            portableDirections: {
+                down: true //default is false, 'true' means as soon as carrier is connected downward
+            }
+        },
+
+        /**
+         * This component allows this entity to be carried by other entities with which it collides. Entities that should carry this entity need to have a [[Logic-Carrier]] component attached.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#force-release
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#hit-solid
+         * @fires platypus.Entity#carry-me
+         * @fires platypus.Entity#release-me
+         */
+        initialize: function () {
+            this.carrier = this.lastCarrier = null;
+            this.message = {
+                entity: this.owner
+            };
+        },
+
+        events: {
+            "handle-logic": function () {
+                const
+                    {message: msg} = this;
+                
+                if (this.carrierConnected) {
+                    if (this.carrier !== this.lastCarrier) {
+                        if (this.lastCarrier) {
+                            this.lastCarrier.triggerEvent('release-me', msg);
+                        }
+
+                        /**
+                         * This message is triggered on a potential carrying peer, notifying the peer that this entity is portable.
+                         *
+                         * @event platypus.Entity#carry-me
+                         * @param {platypus.Entity} message.entity This entity, requesting to be carried.
+                         */
+                        this.carrier.triggerEvent('carry-me', msg);
+                    }
+                    
+                    this.carrierConnected = false;
+                } else if (this.carrier) {
+
+                    /**
+                     * This message is triggered on the current carrier, notifying them to release this entity.
+                     *
+                     * @event platypus.Entity#release-me
+                     * @param {platypus.Entity} message.entity This entity, requesting to be released.
+                     */
+                    this.carrier.triggerEvent('release-me', msg);
+                    this.carrier = null;
+                }
+                this.lastCarrier = this.carrier;
+            },
+
+            "hit-solid": function (collisionInfo) {
+                if (collisionInfo.y > 0) {
+                    this.updateCarrier(collisionInfo.entity, 'down');
+                } else if (collisionInfo.y < 0) {
+                    this.updateCarrier(collisionInfo.entity, 'up');
+                } else if (collisionInfo.x < 0) {
+                    this.updateCarrier(collisionInfo.entity, 'left');
+                } else if (collisionInfo.x > 0) {
+                    this.updateCarrier(collisionInfo.entity, 'right');
+                }
+            },
+
+            /**
+             * On receiving this message, this component immediately triggers 'release-me' on its owner's carrier.
+             *
+             * @event platypus.Entity#force-release
+             */
+            "force-release": function () {
+                if (this.carrier) {
+                    this.carrier.triggerEvent('release-me', this.message);
+                }
+                this.carrier = null;
+                this.lastCarrier = this.carrier;
+                this.carrierConnected = false;
+            }
+        },
+        methods: {
+            updateCarrier: function (entity, direction) {
+                if (this.portableDirections[direction]) {
+                    if (entity) {
+                        if (entity !== this.carrier) {
+                            this.carrier = entity;
+                        }
+                        this.carrierConnected = true;
+                    }
+                }
+            }
+        }
+    });
+}());

package/src/components/LogicPortal.js

@@ -0,0 +1,115 @@
+/**
+### Peer Broadcasts:
+- **portal-waiting** - Informs another object that the portal is waiting on it to send the activate message.
+  - @param entity - This is the portal entity. To be used so that the object can communicate with it directly.
+
+## JSON Definition
+    {
+      "type": "name-of-component",
+      "destination" : "level-2"
+      //Required - The destination scene to which the portal will take us. In most cases this will come into the portal from Tiled where you'll set a property on the portal you place.
+    }
+*/
+import DataMap from '../DataMap.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicPortal.prototype */{
+        id: 'LogicPortal',
+        
+        /**
+         * A component which changes the scene when activated. When the portal receives an occupied message it sends the entity in that message notifying it. This message is meant to give the entity a chance to activate the portal in the manner it wants. The portal can also be activated by simply telling it to activate.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (definition) {
+            const
+                entrants = definition.entrants || definition.entrant || 'no one',
+                state = this.owner.state;
+             
+            this.destination = this.owner.destination || definition.destination;
+            this.used = false;
+            this.ready = false;
+            this.wasReady = false;
+
+            this.entrants = DataMap.setUp();
+            if (Array.isArray(entrants)) {
+                for (let i = 0; i < entrants.length; i++) {
+                    this.entrants.set(entrants[i], false);
+                }
+            } else {
+                this.entrants.set(entrants, false);
+            }
+            
+            this.state = state;
+
+            state.set('occupied', false);
+            state.set('ready', true);
+        },
+        events: {
+            "handle-logic": function () {
+                const
+                    {entrants, state} = this,
+                    keys = entrants.keys;
+                let i = keys.length,
+                    occupied = false,
+                    ready = true;
+                
+                if (!this.used && this.activated) {
+                    this.owner.triggerEvent("port-" + this.destination);
+                    this.used = true;
+                } else if (this.ready && !this.wasReady) {
+                    this.owner.triggerEvent('portal-waiting');
+                    this.wasReady = true;
+                } else if (this.wasReady && !this.ready) {
+                    this.owner.triggerEvent('portal-not-waiting');
+                    this.wasReady = false;
+                }
+                
+                
+                //Reset portal for next collision run.
+                while (i--) {
+                    if (entrants[keys[i]]) {
+                        occupied = true;
+                        entrants.set(keys[i], false);
+                    } else {
+                        ready = false;
+                    }
+                }
+                state.set('occupied', occupied);
+                state.set('ready', ready);
+                this.ready = false;
+            },
+            "occupied-portal": function (collision) {
+                const
+                    entrants = this.entrants,
+                    keys = entrants.keys;
+                let i = keys.length;
+                
+                entrants.set(collision.entity.type, true);
+                
+                while (i--) {
+                    if (!entrants.get(keys[i])) {
+                        return;
+                    }
+                }
+                
+                this.ready = true;
+            },
+            "activate-portal": function () {
+                this.activated = true;
+            }
+        },
+        methods: {
+            destroy: function () {
+                this.state = null;
+                this.entrants.recycle();
+                this.entrants = null;
+            }
+        }
+    });
+}());

package/src/components/LogicPushable.js

@@ -0,0 +1,98 @@
+/**
+## JSON Definition
+    {
+      "type": "LogicPushable",
+       "xPush" : .01,
+      //Optional - The distance per millisecond this object can be pushed in x. Defaults to .01.
+      "yPush" : .01,
+      //Optional - The distance per millisecond this object can be pushed in y. Defaults to .01.
+      "push" : .01
+      //Optional - The distance per millisecond this object can be pushed in x and y. Overwritten by the more specific values xPush and yPush. Defaults to .01.
+    }
+*/
+import {arrayCache} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+const
+    setMagnitude = function (direction, magnitude) {
+        return (direction / Math.abs(direction)) * magnitude;
+    };
+
+export default createComponentClass(/** @lends platypus.components.LogicPushable.prototype */{
+    id: 'LogicPushable',
+
+    /**
+     * A component that enables an entity to be pushed.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @param {*} definition 
+     * @listens platypus.Entity#handle-logic
+     * @listens platypus.Entity#hit-solid
+     */
+    initialize: function (definition) {
+        this.yPush = definition.push || definition.yPush || 0;
+        this.xPush = definition.push || definition.xPush || 0.1;
+        if (definition.roll) {
+            this.radius = definition.radius || this.owner.radius || ((this.owner.width || this.owner.height || 2) / 2);
+            this.owner.orientation = this.owner.orientation || 0;
+        } else {
+            this.radius = 0;
+        }
+        this.currentPushX = 0;
+        this.currentPushY = 0;
+        this.lastX = this.owner.x;
+        this.lastY = this.owner.y;
+        this.pushers = arrayCache.setUp();
+    },
+
+    events: {
+        "handle-logic": function ({delta}) {
+            if (this.currentPushY) {
+                this.owner.y += setMagnitude(this.currentPushY, this.yPush * delta);
+                this.currentPushY = 0;
+            }
+            if (this.currentPushX) {
+                this.owner.x += setMagnitude(this.currentPushX, this.xPush * delta);
+                this.currentPushX = 0;
+            }
+            if ((this.lastX !== this.owner.x) || (this.lastY !== this.owner.y)) {
+                if (this.radius) {
+                    this.owner.orientation += (this.owner.x + this.owner.y - this.lastX - this.lastY) / this.radius;
+                }
+                this.lastX = this.owner.x;
+                this.lastY = this.owner.y;
+            }
+            for (let i = 0; i < this.pushers.length; i++) {
+                this.pushers[i].triggerEvent('pushed', this.owner);
+            }
+            this.pushers.length = 0;
+        },
+        "push-entity": function (collisionInfo) {
+            const
+                x = (collisionInfo.x || 0),
+                y = (collisionInfo.y || 0);
+            
+            this.currentPushX -= x;
+            this.currentPushY -= y;
+            if ((this.yPush && y) || (this.xPush && x)) {
+                this.pushers.push(collisionInfo.entity);
+            }
+        },
+        "hit-solid": function (collisionInfo) {
+            if (((collisionInfo.y > 0) && (this.vY > 0)) || ((collisionInfo.y < 0) && (this.vY < 0))) {
+                this.vY = 0;
+            } else if (((collisionInfo.x < 0) && (this.vX < 0)) || ((collisionInfo.x > 0) && (this.vX > 0))) {
+                this.vX = 0;
+            }
+            return true;
+        }
+    },
+    
+    methods: {
+        destroy: function () {
+            arrayCache.recycle(this.pushers);
+        }
+    }
+});

package/src/components/LogicRebounder.js

@@ -0,0 +1,136 @@
+/**
+### Peer Broadcasts:
+- **share-velocity** - This component triggers this message to prevent double collision calls.
+  - @param entity ([[entity]]) - This entity.
+
+## JSON Definition
+    {
+      "type": "LogicRebounder",
+      
+      "mass": 12,
+      // Optional. Relative size of the entity. Defaults to 1.
+      
+      "elasticity": 0.4
+      // Optional. Bounciness of the entity. Defaults to 0.8.
+    }
+*/
+import Vector from '../Vector.js';
+import {arrayCache} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+export default createComponentClass(/** @lends platypus.components.LogicRebounder.prototype */{
+    id: 'LogicRebounder',
+    
+    /**
+     * This component works with `CollisionBasic` to cause entities to bounce away on solid collisions.
+     *
+     * @memberof platypus.components
+     * @uses platypus.Component
+     * @constructs
+     * @param {*} definition 
+     * @listens platypus.Entity#handle-logic
+     */
+    initialize: function (definition) {
+        Vector.assign(this.owner, 'velocity', 'dx', 'dy', 'dz');
+
+        this.owner.mass = this.owner.mass || definition.mass || 1;
+        this.elasticity = definition.elasticity || 0.8;
+        
+        this.v = Vector.setUp(0, 0, 0);
+        this.incidentVector = Vector.setUp(0, 0, 0);
+        
+        this.staticCollisionOccurred = false;
+        this.nonStaticCollisionOccurred = false;
+        
+        this.hitThisTick = arrayCache.setUp();
+        this.otherV = Vector.setUp(0, 0, 0);
+        this.otherVelocityData = arrayCache.setUp();
+    },
+
+    events: {// These are messages that this component listens for
+        "handle-logic": function () {
+            this.hitThisTick.length = 0;
+            for (let i = 0; i < this.otherVelocityData.length; i++) {
+                this.otherVelocityData[i].velocity.recycle();
+            }
+            this.otherVelocityData.length = 0;
+        },
+        "hit-static": function ({direction, entity: other}) {
+            let magnitude = 0;
+
+            for (let x = 0; x < this.hitThisTick.length; x++) {
+                if (other === this.hitThisTick[x]) {
+                    return;
+                }
+            }
+            this.hitThisTick.push(other);
+            
+            this.v.setVector(this.owner.velocity);
+            this.incidentVector.setVector(direction);
+            
+            magnitude = this.v.scalarProjection(this.incidentVector);
+            if (!isNaN(magnitude)) {
+                this.incidentVector.scale(magnitude * (1 + this.elasticity));
+                this.v.subtractVector(this.incidentVector);
+            }
+            
+            this.owner.velocity.setVector(this.v);
+        },
+        "hit-non-static": function ({direction, entity: other}) {
+            let otherVSet      = false,
+                relevantV      = 0,
+                otherRelevantV = 0,
+                reboundV       = 0;
+
+            if (this.hitThisTick.indexOf(other) >= 0) {
+                return;
+            }
+            this.hitThisTick.push(other);
+            
+            for (let x = 0; x < this.otherVelocityData.length; x++) {
+                if (other === this.otherVelocityData[x].entity) {
+                    this.otherV.setVector(this.otherVelocityData[x].velocity);
+                    otherVSet = true;
+                    break;
+                }
+            }
+            
+            if (!otherVSet) {
+                this.otherV.setVector(other.velocity);
+                other.triggerEvent('share-velocity', this.owner);
+            }
+            
+            this.v.setVector(this.owner.velocity);
+            this.incidentVector.setVector(direction);
+            
+            
+            relevantV = this.v.scalarProjection(this.incidentVector);
+            relevantV = (isNaN(relevantV)) ? 0 : relevantV;
+            otherRelevantV = this.otherV.scalarProjection(this.incidentVector);
+            otherRelevantV = (isNaN(otherRelevantV)) ? 0 : otherRelevantV;
+            
+            reboundV = (relevantV * (this.owner.mass - other.mass) + 2 * other.mass * otherRelevantV) / (this.owner.mass + other.mass);
+            
+            this.incidentVector.scale(reboundV - relevantV);
+            
+            this.owner.velocity.setVector(this.incidentVector);
+            
+        },
+        "share-velocity": function (other) {
+            this.otherVelocityData.push({
+                entity: other,
+                velocity: Vector.setUp(other.velocity)
+            });
+        }
+    },
+    
+    methods: {// These are methods that are called by this component.
+        destroy: function () {
+            this.v.recycle();
+            this.incidentVector.recycle();
+            this.otherV.recycle();
+            arrayCache.recycle(this.hitThisTick);
+            arrayCache.recycle(this.otherVelocityData);
+        }
+    }
+});