@makefully/platypus 4.1.4 → 4.1.6

package/src/components/AIChaser.js

@@ -0,0 +1,161 @@
+/* global platypus */
+import Vector from '../Vector.js';
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.AIChaser.prototype */{
+        
+        id: 'AIChaser',
+        
+        properties: {
+            /**
+             * Sets whether the speed property should enact acceleration upon the entity rather than velocity.
+             *
+             * @property accelerate
+             * @type boolean
+             * @default false
+             */
+            accelerate: false,
+            
+            /**
+             * Whether the entity is in a chasing state.
+             *
+             * @property chasing
+             * @type boolean
+             * @default true
+             */
+            chasing: true
+        },
+        
+        publicProperties: {
+            /**
+             * Sets the velocity of the entity. This property is accessible on the entity as `entity.speed`.
+             *
+             * @property speed
+             * @type number
+             * @default 0.3
+             */
+            speed: 0.3
+        },
+        
+        /**
+         * This component acts as a simple AI that will chase another entity.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#load
+         * @fires platypus.Entity#chase
+         * @listens platypus.Entity#handle-ai
+         * @listens platypus.Entity#set-target
+         * @listens platypus.Entity#set-target-offset
+         * @listens platypus.Entity#start-chasing
+         * @listens platypus.Entity#stop-chasing
+         */
+        initialize: function () {
+            this.target = this.owner.target || null;
+            this.offset = Vector.setUp(0, 0);
+            this.state = this.owner.state;
+            this.state.set('chasing', false);
+        },
+
+        events: {
+            "load": function () {
+                if (!this.owner.addMover) {
+                    platypus.debug.warn('The "AIChaser" component requires a "Mover" component to function correctly.');
+                    return;
+                }
+                
+                this.direction = this.owner.addMover({
+                    vector: [this.speed, 0, 0],
+                    event: "chase",
+                    accelerator: this.accelerate
+                }).vector;
+            },
+        
+            "handle-ai": function () {
+                let c = false;
+
+                if (this.target && this.chasing) {
+                    const
+                        v = Vector.setUp(this.offset).add(this.target.position).subtractVector(this.owner.position),
+                        m = v.magnitude(2);
+
+                    if (m) {
+                        c = true;
+                        this.direction.setVector(v).normalize().multiply(this.speed);
+                    }
+
+                    v.recycle();
+                }
+                
+                if (c !== this.state.get('chasing')) {
+                    this.state.set('chasing', c);
+                    
+                    /**
+                     * This event is triggered whenever the entity begins chasing another entity or stops chasing another entity.
+                     *
+                     * @event platypus.Entity#chase
+                     * @param chasing {boolean} Whether the entity is chasing another entity.
+                     */
+                    this.owner.triggerEvent('chase', c);
+                }
+            },
+            
+            /**
+             * On receiving this message, the component will change its target and begin chasing the new entity.
+             *
+             * @event platypus.Entity#set-target
+             * @param entity {platypus.Entity} Sets this entity's target to the provided entity.
+             */
+            "set-target": function (entity) {
+                this.target = entity;
+                this.offset.x = 0;
+                this.offset.y = 0;
+            },
+            
+            /**
+             * On receiving this message, the component will change its target offset.
+             *
+             * @event platypus.Entity#set-target-offset
+             * @param offset {Object|Vector} Sets the chased entity's offset to the provided offset.
+             * @param offset.x {number} The offset along the x-axis.
+             * @param offset.y {number} The offset along the y-axis.
+             */
+            "set-target-offset": function (offset) {
+                this.offset.x = offset.x;
+                this.offset.y = offset.y;
+            },
+            
+            /**
+             * On receiving this message, the component will begin chasing the entity.
+             *
+             * @event platypus.Entity#start-chasing
+             * @param [entity] {platypus.Entity} Sets the entity if it's provided.
+             */
+            "start-chasing": function (entity) {
+                if (entity) {
+                    this.target = entity;
+                }
+                this.chasing = true;
+            },
+            
+            /**
+             * On receiving this message, the component will cease chasing the entity.
+             *
+             * @event platypus.Entity#stop-chasing
+             */
+            "stop-chasing": function () {
+                this.chasing = false;
+            }
+        },
+        
+        methods: {// These are methods that are called on the component
+            destroy: function () {
+                this.target = null;
+                this.offset.recycle();
+                this.state = null;
+            }
+        }
+    });
+}());

package/src/components/AIPacer.js

@@ -0,0 +1,107 @@
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.AIPacer.prototype */{
+        id: "AIPacer",
+        
+        properties: {
+            /**
+             * This determines the direction of movement. Can be "horizontal", "vertical", or "both".
+             *
+             * @property movement
+             * @type String
+             * @default "both"
+             */
+            movement: 'both',
+            
+            /**
+             * This sets the initial direction of movement. Defaults to "up", or "left" if movement is horizontal.
+             *
+             * @property direction
+             * @type String
+             * @default "up"
+             */
+            direction: null
+        },
+        
+        /**
+         * This component acts as a simple AI that will reverse the movement direction of an object when it collides with something.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#handle-ai
+         * @listens platypus.Entity#turn-around
+         * @fires platypus.Entity#stop
+         * @fires platypus.Entity#go-left
+         * @fires platypus.Entity#go-right
+         * @fires platypus.Entity#go-down
+         * @fires platypus.Entity#go-up
+         */
+        initialize: function () {
+            this.lastDirection    = '';
+            this.currentDirection = this.direction || ((this.movement === 'horizontal') ? 'left' : 'up');
+        },
+        
+        events: {
+            "handle-ai": function () {
+                if (this.currentDirection !== this.lastDirection) {
+                    this.lastDirection = this.currentDirection;
+                    
+                    /**
+                     * Stops motion in all directions until movement messages are again received.
+                     *
+                     * @event platypus.Entity#stop
+                     * @param {boolean} [message.pressed] If `message` is included, the component checks the value of `pressed`: a value of false will not stop the entity.
+                     */
+                    this.owner.triggerEvent('stop');
+                    
+                    /**
+                     * Triggers this event when the entity is moving right and collides with something.
+                     *
+                     * @event platypus.Entity#go-left
+                     */
+                    /**
+                     * Triggers this event when the entity is moving left and collides with something.
+                     *
+                     * @event platypus.Entity#go-right
+                     */
+                    /**
+                     * Triggers this event when the entity is moving up and collides with something.
+                     *
+                     * @event platypus.Entity#go-down
+                     */
+                    /**
+                     * Triggers this event when the entity is moving down and collides with something.
+                     *
+                     * @event platypus.Entity#go-up
+                     */
+                    this.owner.triggerEvent('go-' + this.currentDirection);
+                }
+            },
+            
+            /**
+             * On receiving this message, the component will check the collision side and re-orient itself accordingly.
+             *
+             * @event platypus.Entity#turn-around
+             * @param collisionInfo {platypus.CollisionData} Uses direction of collision to determine whether to turn around.
+             */
+            "turn-around": function (collisionInfo) {
+                if ((this.movement === 'both') || (this.movement === 'horizontal')) {
+                    if (collisionInfo.x > 0) {
+                        this.currentDirection = 'left';
+                    } else if (collisionInfo.x < 0) {
+                        this.currentDirection = 'right';
+                    }
+                }
+                if ((this.movement === 'both') || (this.movement === 'vertical')) {
+                    if (collisionInfo.y > 0) {
+                        this.currentDirection = 'up';
+                    } else if (collisionInfo.y < 0) {
+                        this.currentDirection = 'down';
+                    }
+                }
+            }
+        }
+    });
+}());

package/src/components/AudioMusic.js

@@ -0,0 +1,151 @@
+/**
+ * This component plays music or background ambiance.
+ *
+ * @memberof platypus.components
+ * @class AudioMusic
+ * @uses platypus.Component
+ */
+/* global platypus */
+import {arrayCache, greenSplice} from '../utils/array.js';
+import createComponentClass from '../factory.js';
+
+const
+    formatPath = (path) => {
+        if (path.indexOf('.mp3') === -1) {
+            return `${path}.mp3`;
+        } else {
+            return path;
+        }
+    },
+    activeTracks = {}; // List of actively-playing tracks.
+
+export default createComponentClass(/** @lends platypus.components.AudioMusic.prototype */{
+    id: 'AudioMusic',
+    
+    properties: {
+        /**
+         * Use the tracks property object to handle playing tracks or new tracks to load. Here is an example audioMap object:
+         *       {
+         *           "audio-1": "audio-id",
+         *
+         *           "audio-2": {
+         *               "sound": "another-audio-id",
+         *               // Required. This is the audio clip to loop.
+         *
+         *               "volume": 0.75,
+         *               // Optional. Used to specify how loud to play audio on a range from 0 (mute) to 1 (full volume). Default is 1.
+         *
+         *               "fade": 1000,
+         *               // Optional. How long to fade to selected volume.
+         * 
+         *               "autoStart": true
+         *               // Optional. Whether the music should play as soon as the component loads.
+         *           }
+         *       }
+         *
+         * Any tracks already playing and not defined here will fade out.
+         *
+         * @property tracks
+         * @type Object
+         * @default null
+         */
+        tracks: null,
+
+        /**
+         * The default fade for music track volume changes.
+         * 
+         * @property fade
+         * @type number
+         * @default 1000
+         */
+        fade: 1000
+    },
+        
+    initialize: function () {
+        this.player = platypus.game.musicPlayer;
+        this.changeMusicTracks(this.tracks);
+    },
+
+    events: {
+        'change-music-tracks': function (tracks) {
+            this.changeMusicTracks(tracks);
+        }
+    },
+
+    methods: {
+        changeMusicTracks (tracks) {
+            const
+                {player} = this,
+                fadeOuts = Object.keys(activeTracks),
+                {fade} = this;
+
+            if (tracks) {
+                const
+                    keys = Object.keys(tracks),
+                    {length} = keys;
+
+                for (let j = 0; j < length; j++) {
+                    const
+                        key = keys[j],
+                        fadeOut = fadeOuts.indexOf(key),
+                        trackProperties = tracks[key];
+
+                    if (trackProperties.autoStart !== false) {
+                        let sound = activeTracks[key],
+                            trackFade = trackProperties.fade ?? fade;
+
+                        if (fadeOut >= 0) {
+                            greenSplice(fadeOuts, fadeOut);
+                        } else { // gotta load it because it's not there!
+                            sound = activeTracks[key] = this.player.play(trackProperties.sound || trackProperties, {
+                                loop: Infinity,
+                                volume: trackFade ? 0 : (typeof trackProperties.volume === 'number' ? trackProperties.volume : 1)
+                            });
+                        }
+
+                        if (trackFade) {
+                            
+                            player.fade(sound, typeof trackProperties.volume === 'number' ? trackProperties.volume : 1, trackFade)
+                        }
+                    }
+                }
+            }
+
+            fadeOuts.forEach((value) => {
+                const
+                    sound = activeTracks[value];
+
+                player.fade(sound, 0, fade, () => {
+                    player.stop(sound);
+                    //sound.unload();
+                });
+
+                delete activeTracks[value];
+            });
+        }
+    },
+
+    getAssetList: function (component, props, defaultProps) {
+        const
+            preload = arrayCache.setUp(),
+            tracks = component?.tracks ?? props?.tracks ?? defaultProps?.tracks;
+        
+        if (tracks) {
+            const
+                keys = Object.keys(tracks),
+                {length} = keys;
+
+            for (let i = 0; i < length; i++) {
+                const
+                    track = tracks[keys[i]],
+                    item = formatPath(track.sound ?? track);
+
+                if (preload.indexOf(item) === -1) {
+                    preload.push(item);
+                }
+            }
+        }
+
+        return preload;
+    }
+});