@makefully/platypus 4.1.5 → 4.1.6

package/src/components/LogicRegionSpawner.js

@@ -0,0 +1,139 @@
+/**
+## JSON Definition
+    {
+      "type": "LogicRegionSpawner",
+      // List all additional parameters and their possible values here.
+      
+      "spawn": "teddy-bear",
+      // Required. String identifying the type of entity to spawn.
+      
+      "interval": 30000,
+      // Optional. Time in milliseconds between spawning an entity. Defaults to 1000.
+      
+      "regions": {
+      // If spawning entity covers a large area, the spawned entities can be randomly spawned over a regional grid, so that the whole area gets a somewhat uniform coverage of spawned entities
+
+        "width": 4000,
+        "height": 5000,
+        // Optional. Dimensions of a spawning region in world units. Defaults to entity's dimensions. The entity's dimensions are sliced into chunks of this size for spawn distribution.
+      }
+    }
+*/
+import Entity from '../Entity.js';
+import {arrayCache} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicRegionSpawner.prototype */{
+        
+        id: 'LogicRegionSpawner',
+        
+        /**
+         * This component spawns new entities within a given area at set intervals.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (definition) {
+            this.spawnPosition = {
+                x: 0,
+                y: 0
+            };
+            this.spawnProperties = {
+                type: definition.spawn,
+                properties: this.spawnPosition
+            };
+            
+            this.regions = null;
+            this.usedRegions = null;
+            this.regionWidth = 0;
+            this.regionHeight = 0;
+            if (definition.regions) {
+                const
+                    width = definition.regions.width || this.owner.width,
+                    height = definition.regions.height || this.owner.height,
+                    columns = Math.round(this.owner.width / width),
+                    rows = Math.round(this.owner.height / height);
+
+                this.regions = arrayCache.setUp();
+                this.usedRegions = arrayCache.setUp();
+                this.regionWidth = width;
+                this.regionHeight = height;
+
+                for (let x = 0; x < columns; x++) {
+                    for (let y = 0; y < rows; y++) {
+                        const
+                            rw = Math.min(width,  this.owner.width  - x * width),
+                            rh = Math.min(height, this.owner.height - y * height);
+
+                        this.regions.push({
+                            x: x * width,
+                            y: y * height,
+                            width: rw,
+                            height: rh
+                        });
+                    }
+                }
+            }
+            
+            this.interval = this.owner.interval || definition.interval || 1000;
+            this.time = 0;
+        },
+
+        events: {// These are messages that this component listens for
+            "handle-logic": function ({delta}) {
+                this.time += delta;
+                
+                if (this.time > this.interval) {
+                    let regions = this.regions,
+                        region  = null;
+                    
+                    this.time -= this.interval;
+                    
+                    if (regions) {
+                        if (!regions.length) {
+                            this.regions = this.usedRegions;
+                            this.usedRegions = regions;
+                            regions = this.regions;
+                        }
+                        
+                        region = regions[Math.floor(regions.length * Math.random())];
+                        
+                        this.spawnPosition.x = this.owner.x - (this.owner.regX || 0) + (region.x + (Math.random() * region.width));
+                        this.spawnPosition.y = this.owner.y - (this.owner.regY || 0) + (region.y + (Math.random() * region.height));
+                    } else {
+                        this.spawnPosition.x = this.owner.x - (this.owner.regX || 0) + (Math.random() * this.owner.width);
+                        this.spawnPosition.y = this.owner.y - (this.owner.regY || 0) + (Math.random() * this.owner.height);
+                    }
+
+                    this.owner.parent.addEntity(this.spawnProperties);
+                }
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                if (this.regions) {
+                    arrayCache.recycle(this.regions);
+                    arrayCache.recycle(this.usedRegions);
+                }
+            }
+        },
+        
+        getAssetList: function (def, props, defaultProps) {
+            const
+                spawn = def?.spawn ?? props?.spawn ?? defaultProps?.spawn;
+            
+            if (spawn) {
+                return Entity.getAssetList({
+                    type: spawn
+                });
+            }
+            
+            return arrayCache.setUp();
+        }
+    });
+}());

package/src/components/LogicRotationalMovement.js

@@ -0,0 +1,205 @@
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    const
+        cos = Math.cos,
+        sin = Math.sin,
+        polarToCartesianX = function (m, a) {
+            return m * cos(a);
+        },
+        polarToCartesianY = function (m, a) {
+            return m * sin(a);
+        };
+    
+    return createComponentClass(/** @lends platypus.components.LogicRotationalMovement.prototype */{
+        id: 'LogicRotationalMovement',
+
+        properties: {
+            /**
+             * Defines the distance in world units that the entity should be moved per millisecond.
+             *
+             * @property speed
+             * @type Number
+             * @default 0.3
+             */
+            "speed": 0.3,
+            
+            /**
+             * Radian orientation that entity should begin in. Defaults to 0 (facing right).
+             *
+             * @property angle
+             * @type Number
+             * @default 0
+             */
+            "angle": 0,
+            
+            /**
+             * Unit in radians that the angle should change per millisecond.
+             *
+             * @property degree
+             * @type Number
+             * @default 1
+             */
+            "degree": 1
+        },
+
+        /**
+         * This component changes the (x, y) position of an object according to its current speed and heading. It maintains its own heading information independent of other components allowing it to be used simultaneously with other logic components like [[Logic-Pushable]]. It accepts directional messages that can stand alone, or come from a mapped controller, in which case it checks the `pressed` value of the message before changing its course accordingly.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#stop
+         * @listens platypus.Entity#go-forward
+         * @listens platypus.Entity#go-backward
+         * @listens platypus.Entity#rotate
+         * @listens platypus.Entity#turn-right
+         * @listens platypus.Entity#turn-left
+         * @listens platypus.Entity#stop-moving
+         * @listens platypus.Entity#stop-turning
+         * @fires platypus.Entity#orientation-updated
+         */
+        initialize: function () {
+            const
+                state = this.owner.state;
+            
+            this.magnitude = 0;
+            
+            this.state = state;
+            state.set('moving', false);
+            state.set('turningRight', false);
+            state.set('turningLeft', false);
+    
+            this.owner.orientation  = 0;
+            
+            this.moving = false;
+            this.turningRight = false;
+            this.turningLeft = false;
+        },
+
+        events: {
+            "handle-logic": function (tick) {
+                const
+                    state = this.state;
+                
+                if (this.turningRight) {
+                    this.angle += this.degree * tick.delta / 15;
+                }
+        
+                if (this.turningLeft) {
+                    this.angle -= this.degree * tick.delta / 15;
+                }
+                
+                if (this.moving) {
+                    this.owner.x += (polarToCartesianX(this.magnitude, this.angle) * tick.delta);
+                    this.owner.y += (polarToCartesianY(this.magnitude, this.angle) * tick.delta);
+                }
+                
+                state.set('moving', this.moving);
+                state.set('turningLeft', this.turningLeft);
+                state.set('turningRight', this.turningRight);
+                
+                if (this.owner.orientation !== this.angle * Math.PI / 180) {
+                    this.owner.orientation = this.angle * Math.PI / 180;
+                    this.owner.triggerEvent('orientation-updated');
+                }
+            },
+
+            /**
+             * This rotates the entity by a delta in radians.
+             *
+             * @event platypus.Entity#rotate
+             * @param angleDelta {Number} The change in angle.
+             */
+            "rotate": function (angleDelta) {
+                this.angle += angleDelta;
+            },
+
+            /**
+             * On receiving this event, the entity turns right.
+             *
+             * @event platypus.Entity#turn-right
+             * @param [state.pressed] {boolean} If `state` is included, the component checks the value of `pressed`: true causes movement in the triggered direction, false turns off movement in that direction. Note that if no message is included, the only way to stop movement in a particular direction is to trigger `stop` on the entity before progressing in a new orientation.
+             */
+            "turn-right": function (state) {
+                if (state) {
+                    this.turningRight = state.pressed;
+                } else {
+                    this.turningRight = true;
+                }
+            },
+
+            /**
+             * On receiving this event, the entity turns left.
+             *
+             * @event platypus.Entity#turn-left
+             * @param [state.pressed] {boolean} If `state` is included, the component checks the value of `pressed`: true causes movement in the triggered direction, false turns off movement in that direction. Note that if no message is included, the only way to stop movement in a particular direction is to trigger `stop` on the entity before progressing in a new orientation.
+             */
+            "turn-left": function (state) {
+                if (state) {
+                    this.turningLeft = state.pressed;
+                } else {
+                    this.turningLeft = true;
+                }
+            },
+
+            "go-forward": function (state) {
+                if (!state || state.pressed) {
+                    this.moving = true;
+                    this.magnitude = this.speed;
+                } else {
+                    this.moving = false;
+                }
+            },
+
+            "go-backward": function (state) {
+                if (!state || state.pressed) {
+                    this.moving = true;
+                    this.magnitude = -this.speed;
+                } else {
+                    this.moving = false;
+                }
+            },
+
+            "stop": function (state) {
+                if (!state || state.pressed) {
+                    this.moving = false;
+                    this.turningLeft = false;
+                    this.turningRight = false;
+                }
+            },
+
+            /**
+             * Stops linear motion until movement messages are again received.
+             *
+             * @event platypus.Entity#stop-moving
+             * @param [state.pressed] {Boolean} If `state` is included, the component checks the value of `pressed`: a value of false will not stop the entity.
+             */
+            "stop-moving": function (state) {
+                if (!state || state.pressed) {
+                    this.moving = false;
+                }
+            },
+
+            /**
+             * Stops rotational motion until movement messages are again received.
+             *
+             * @event platypus.Entity#stop-turning
+             * @param [state.pressed] {Boolean} If `state` is included, the component checks the value of `pressed`: a value of false will not stop the entity.
+             */
+            "stop-turning": function (state) {
+                if (!state || state.pressed) {
+                    this.turningLeft = false;
+                    this.turningRight = false;
+                }
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.state = null;
+            }
+        }
+    });
+}());

package/src/components/LogicSpawner.js

@@ -0,0 +1,159 @@
+/**
+## JSON Definition
+    {
+      "type": "LogicSpawner"
+      // List all additional parameters and their possible values here.
+
+      "spawneeClass": "wet-noodle",
+      // Required: string identifying the type of entity to create.
+      
+      "state": "tossing",
+      // Optional. The entity state that should be true while entities are being created. Defaults to "firing".
+      
+      "speed": 4,
+      // Optional. The velocity with which the entity should start. Initial direction is determined by this entity's facing states ("top", "right", etc).
+      
+      "offsetX": 45,
+      "offsetY": -20,
+      // Optional. Location relative to the entity where the should be located once created. Defaults to (0, 0).
+    }
+*/
+/* global platypus */
+import Entity from '../Entity.js';
+import {arrayCache} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicSpawner.prototype */{
+        
+        id: 'LogicSpawner',
+        
+        /**
+         * This component creates an entity and propels it away. This is useful for casting, firing, tossing, and related behaviors.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @param {*} definition 
+         * @listens platypus.Entity#handle-logic
+         */
+        initialize: function (definition) {
+            const
+                className = this.owner.spawneeClass || definition.spawneeClass;
+
+            this.state = this.owner.state;
+            this.stateName = definition.state || 'spawning';
+            this.originalZ = (platypus.game.settings.entities[className] && platypus.game.settings.entities[className].properties && platypus.game.settings.entities[className].properties.z) || 0;
+            this.speed = definition.speed || this.owner.speed || 0;
+
+            this.state.set(this.stateName, false);
+            
+            this.spawneeProperties = {
+                x: 0,
+                y: 0,
+                z: 0,
+                dx: 0,
+                dy: 0,
+                spawner: this.owner
+            };
+            
+            if (definition.passOnProperties) {
+                for (let x = 0; x < definition.passOnProperties.length; x++) {
+                    const
+                        prop = definition.passOnProperties[x];
+
+                    if (this.owner[prop]) {
+                        this.spawneeProperties[prop] = this.owner[prop];
+                    }
+                }
+            }
+            
+            this.propertiesContainer = {
+                type: className,
+                properties: this.spawneeProperties
+            };
+            
+            this.offsetX = this.owner.offsetX || definition.offsetX || 0;
+            this.offsetY = this.owner.offsetY || definition.offsetY || 0;
+            
+            this.firing = false;
+        },
+
+        events: {// These are messages that this component listens for
+            "handle-logic": function () {
+                const
+                    state = this.state;
+                
+                if (this.firing) {
+                    let offset = 0;
+
+                    this.spawneeProperties.x = this.owner.x;
+                    this.spawneeProperties.y = this.owner.y;
+                    this.spawneeProperties.z = this.owner.z + this.originalZ;
+                    
+                    offset = this.offsetX;
+                    if (state.get('left')) {
+                        offset *= -1;
+                    }
+                    this.spawneeProperties.x += offset;
+                    
+                    offset = this.offsetY;
+                    if (state.get('top')) {
+                        offset *= -1;
+                    }
+                    this.spawneeProperties.y += offset;
+                    
+                    if (this.speed) {
+                        if (state.get('top')) {
+                            this.spawneeProperties.dy = -this.speed;
+                        } else if (state.get('bottom')) {
+                            this.spawneeProperties.dy = this.speed;
+                        } else {
+                            delete this.spawneeProperties.dy;
+                        }
+                        if (state.get('left')) {
+                            this.spawneeProperties.dx = -this.speed;
+                        } else if (state.get('right')) {
+                            this.spawneeProperties.dx = this.speed;
+                        } else {
+                            delete this.spawneeProperties.dx;
+                        }
+                    } else {
+                        delete this.spawneeProperties.dx;
+                        delete this.spawneeProperties.dy;
+                    }
+                    
+                    this.parent.addEntity(this.propertiesContainer);
+                }
+                
+                state.set(this.stateName, this.firing);
+
+                this.firing = false;
+            },
+            "spawn": function (value) {
+                this.firing = !value || (value.pressed !== false);
+                
+                this.parent = this.owner.parent; //proofing against this entity being destroyed prior to spawned entity. For example, when a destroyed entity spawns a drop.
+            }
+        },
+        
+        methods: {
+            destroy: function () {
+                this.state = null;
+            }
+        },
+        
+        getAssetList: function (def, props, defaultProps) {
+            const
+                spawn = def?.spawneeClass ?? props?.spawneeClass ?? defaultProps?.spawneeClass;
+            
+            if (spawn) {
+                return Entity.getAssetList({
+                    type: spawn
+                });
+            }
+            
+            return arrayCache.setUp();
+        }
+    });
+}());