@makefully/platypus 4.1.5 → 4.1.8

package/src/RandomSet.js

@@ -0,0 +1,140 @@
+import recycle from 'recycle';
+
+export default (function () {
+
+    /**
+     * This class defines a set that is populated and then pulled from at random. When pulled from, the set will return copies of the contents
+     * such that all the contents in the set are used once before there are repeats. Repeats may still occur when the set has been used
+     * up or when the number of items requested is greater than the size of the set.
+     *
+     * @memberof platypus
+     * @class RandomSet
+     * @param contents {array} The contents that will populate the set.
+     * @return {platypus.RandomSet} Returns the new RandomSet object.
+     */
+    const RandomSet = function (contents) {
+            let x = 0;
+
+            if (contents) {
+                this.contents = [];
+                for (x = 0; x < contents.length; x++) {
+                    this.contents.push(contents[x]);
+                }
+            } else {
+                this.contents = [];
+            }
+            this.availableIndexes = [];
+
+            this.refill();
+        },
+        proto = RandomSet.prototype;
+
+
+    proto.refill = function () {
+        let x = 0;
+        
+        for (x = 0; x < this.contents.length; x++) {
+            this.availableIndexes.push(x);
+        }
+    };
+
+    /**
+     * Add single element to the content set. Includes the new content in the current set, which means it be returned quickly depending on the remaining set size. 
+     *
+     * @method platypus.RandomSet#add
+     * @param toAdd {primitive|Object} Content to add to the set.
+     */
+    proto.add = function (toAdd) {
+        this.contents.push(toAdd);
+        this.availableIndexes.push(this.contents.length - 1);
+    };
+
+    /**
+     * Remove from the content set. Use removeAll if you want to remove all instances, otherwise only removes the first instance found.
+     * 
+     * @method platypus.RandomSet#remove
+     * @param toRemove {primitive|Object} Content to remove from the set.
+     * @param removeAll {boolean} Remove all instances of the primitive/object.
+     */
+    proto.remove = function (toRemove, removeAll) {
+        let index = -1,
+            indexesIndex = -1;
+
+        do {
+            index = this.contents.indexOf(toRemove);
+            if (index !== -1) {
+                this.contents.splice(index, 1);
+            
+                indexesIndex = this.availableIndexes.indexOf(index);
+                this.availableIndexes.splice(indexesIndex, 1);
+
+                // Now we need to re-index entries above index...
+                for (let i = 0; i < this.availableIndexes; i++) {
+                    if (this.availableIndexes[i] > index) {
+                        this.availableIndexes[i] -= 1;
+                    }
+                }
+            }
+        } while (index !== -1 && removeAll);
+
+    };
+
+    /**
+     * Get a random member of the set.
+     *
+     * @method platypus.RandomSet#get
+     * @return {primitive|Object} A random member of the set
+     */
+    proto.get = function () {
+        let index = 0;
+
+        if (this.availableIndexes.length === 0) {
+            this.refill();
+        }
+
+        index = this.availableIndexes.splice(Math.floor(Math.random() * this.availableIndexes.length), 1)[0];
+
+        return this.contents[index];
+    };
+
+    /**
+     * Get an array of random set members. There may be multiple of the same member in the set if the quantity requested is greater
+     * than the set size, or the set is exhausted and replenished while retrieving members.
+     *
+     * @method platypus.RandomSet#getMultiple
+     * @param numberToGet {integer} Number of set members to retrieve
+     * @return {primitive|Object} A random member of the set
+     */
+    proto.getMultiple = function (numberToGet) {
+        const toReturn = [];
+        let x = 0;
+        
+        for (x = 0; x < numberToGet; x++) {
+            toReturn.push(this.get());
+        }
+
+        return toReturn;
+    };
+
+
+    /**
+     * Returns an RandomSet from cache or creates a new one if none are available.
+     *
+     * @method platypus.RandomSet.setUp
+     * @return {platypus.RandomSet} The instantiated RandomSet.
+     */
+    /**
+     * Returns a RandomSet back to the cache.
+     *
+     * @method platypus.RandomSet.recycle
+     * @param {platypus.RandomSet} randomSet The RandomSet to be recycled.
+     */
+    /**
+     * Relinquishes properties of the RandomSet and recycles it.
+     *
+     * @method platypus.RandomSet#recycle
+     */
+    recycle.add(RandomSet, 'RandomSet', RandomSet, null, true);
+
+    return RandomSet;
+}());

package/src/SFXPlayer.js

@@ -0,0 +1,120 @@
+/* global platypus */
+import {arrayCache, greenSplice} from './utils/array.js';
+import TweenJS from '@tweenjs/tween.js';
+
+const
+    {Tween} = TweenJS;
+
+/**
+ * This class plays sfx audio and manages Springroll volume changes.
+ *
+ * @memberof platypus
+ * @class SFXPlayer
+ */
+ export default class SFXPlayer {
+    constructor () {
+        this.masterVolume = 1;
+        this.volume = 1;
+        this.playingAudio = arrayCache.setUp();
+    }
+
+    /**
+     * Plays a sound.
+     *
+     * @method platypus.SFXPlayer#play
+     * @param {String} sound Sound Id to play.
+     * @param {Object} data PixiSound data to inform sound playback.
+     * @return {pixiSound.MediaInstance} The media instance of the playing sound.
+     * @public
+     */
+    play (sound, data) {
+        const
+            sfx = typeof sound === 'string' ? platypus.assetCache.get(platypus.assetCache.getFileId(sound)) : sound,
+            audio = sfx.play(data);
+
+        audio.initialVolume = (typeof data.initialVolume === 'number' ? data.initialVolume : audio.volume);
+        audio.set('volume', audio.volume * this.volume * this.masterVolume);
+        this.playingAudio.push(audio);
+        audio.on('end', () => {
+            const index = this.playingAudio.indexOf(audio);
+
+            greenSplice(this.playingAudio, index);
+        });
+
+        return audio;
+    }
+
+    /**
+     * Plays a sound.
+     *
+     * @method platypus.SFXPlayer#stop
+     * @param {pixiSound.MediaInstance} audio Audio to stop.
+     * @public
+     */
+    stop (audio) {
+        const index = this.playingAudio.indexOf(audio);
+
+        audio.stop();
+        if (index >= 0) {
+            greenSplice(this.playingAudio, index);
+        } else {
+            platypus.debug.warn('SFXPlayer: Did not find "' + audio.soundId + '"');
+        }
+    }
+
+    fade (audio, volume, time, onComplete = () => {}) {
+        const
+            tween = new Tween(audio);
+
+        tween.to({
+            initialVolume: volume
+        }, time);
+        tween.onUpdate(() => {
+            audio.set('volume', audio.initialVolume * this.volume * this.masterVolume);
+        });
+        tween.onComplete(onComplete);
+        tween.start();
+    }
+
+    /**
+     * Sets volume on all playing sound effects.
+     *
+     * @method platypus.SFXPlayer#setVolume
+     * @param {Number} volume A value between 0-1 to set volume on all playing sound effects.
+     * @public
+     */
+    setVolume (volume) {
+        const
+            playingAudio = this.playingAudio;
+
+        this.volume = volume;
+        for (let i = 0; i < playingAudio.length; i++) {
+            const
+                audio = playingAudio[i];
+
+            audio.set('volume', audio.initialVolume * this.volume * this.masterVolume);
+        }
+    }
+
+    /**
+     * Sets master volume on all playing sound effects.
+     *
+     * @method platypus.SFXPlayer#setMasterVolume
+     * @param {Number} volume A value between 0-1 to set volume on all playing sound effects.
+     * @public
+     */
+    setMasterVolume (volume) {
+        this.masterVolume = volume;
+        this.setVolume(this.volume);
+    }
+
+    /**
+     * Cleans up this SFXPlayer.
+     * @method platypus.SFXPlayer#destroy
+     * @public
+     */
+    destroy () {
+        arrayCache.recycle(this.playingAudio);
+        this.playingAudio = null;
+    }
+};

package/src/StateMap.js

@@ -0,0 +1,252 @@
+import DataMap from './DataMap.js';
+import {arrayCache} from './utils/array.js';
+import {greenSplit} from './utils/string.js';
+import recycle from 'recycle';
+
+/**
+ * This class defines a state object to use for entity states with helper methods. It includes recycle methods to encourage reuse.
+ *
+ * @memberof platypus
+ * @class StateMap
+ * @extends platypus.DataMap
+ * @return stateMap {platypus.StateMap} Returns the new StateMap object.
+ */
+const
+    clean = function (arr) {
+        const
+            cleaned = arrayCache.setUp();
+
+        if (typeof arr[0] === 'string') {
+            for (let i = 0; i < arr.length; i++) {
+                cleaned.push((i % 2) ? !!arr[i] : arr[i]);
+            }
+        } else if (typeof arr[0] === 'object') {
+            const
+                obj = arr[0];
+
+            if (obj.keys && obj.get) {
+                const
+                    {keys} = obj;
+                let i = keys.length;
+
+                while (i--) {
+                    cleaned.push(keys[i], !!obj.get(keys[i]));
+                }
+            } else {
+                const
+                    keys = Object.keys(obj);
+                let i = keys.length;
+
+                while (i--) {
+                    cleaned.push(keys[i], !!obj[keys[i]]);
+                }
+            }
+        }
+
+        return cleaned;
+    },
+    StateMap = function (first) {
+        const
+            l = arguments.length;
+        
+        if (l) {
+            if ((l === 1) && (typeof first === 'string')) {
+                DataMap.call(this);
+                this.updateFromString(first);
+            } else {
+                const
+                    cleanedArgs = clean(arguments);
+
+                DataMap.apply(this, cleanedArgs);
+                arrayCache.recycle(cleanedArgs);
+            }
+        } else {
+            DataMap.call(this);
+        }
+    },
+    parent = DataMap.prototype,
+    proto = StateMap.prototype = Object.create(parent);
+
+Object.defineProperty(proto, 'constructor', {
+    configurable: true,
+    writable: true,
+    value: StateMap
+});
+    
+/**
+ * Returns a JSON object of state keys and boolean values.
+ *
+ * @method platypus.StateMap#toJSON
+ * @return {Object} State keys mapped to `true` or `false`.
+ */
+
+/**
+ * Returns a comma-delimited list of state keys compatible with `updateFromString`. False values are prefixed with `"!"`.
+ *
+ * @method platypus.StateMap#toString
+ * @return {String} The serialized state string.
+ */
+Object.defineProperty(proto, 'toString', {
+    value: function () {
+        const
+            {keys} = this;
+        let i = keys.length,
+            parts = arrayCache.setUp();
+
+        while (i--) {
+            const
+                key = keys[i];
+
+            parts.push(this.get(key) ? key : `!${key}`);
+        }
+
+        const
+            string = parts.join(',');
+
+        arrayCache.recycle(parts);
+
+        return string;
+    }
+});
+
+/**
+ * Sets the state using the provided string value which is a comma-delimited list such that `"blue,red,!green"` sets the following state values:
+ *
+ *      {
+ *          red: true,
+ *          blue: true,
+ *          green: false
+ *      }
+ *
+ * @method platypus.StateMap#updateFromString
+ * @param states {String} A comma-delimited list of true/false state values.
+ * @chainable
+ */
+Object.defineProperty(proto, 'updateFromString', {
+    value: function (states) {
+        const
+            arr = greenSplit(states, ',');
+        let i = arr.length;
+        
+        while (i--) {
+            const
+                str = arr[i];
+
+            if (str) {
+                if (str.substr(0, 1) === '!') {
+                    this.set(str.substr(1), false);
+                } else {
+                    this.set(str, true);
+                }
+            }
+        }
+        
+        arrayCache.recycle(arr);
+        
+        return this;
+    }
+});
+
+/**
+ * Checks whether the provided state matches this state and updates this state to match.
+ *
+ * @method platypus.StateMap#update
+ * @param state {platypus.StateMap} The state that this state should match.
+ * @return {Boolean} Whether this state already matches the provided state.
+ */
+Object.defineProperty(proto, 'update', {
+    value: function (newState) {
+        const
+            {keys} = newState;
+        let i = keys.length,
+            changed = false;
+        
+        while (i--) {
+            const
+                state = keys[i],
+                value = newState.get(state);
+
+            if (this.get(state) !== value) {
+                this.set(state, value);
+                changed = true;
+            }
+        }
+        
+        return changed;
+    }
+});
+
+/**
+ * Checks whether the provided state matches all equivalent keys on this state.
+ *
+ * @method platypus.StateMap#includes
+ * @param state {platypus.StateMap} The state that this state should match.
+ * @return {Boolean} Whether this state matches the provided state.
+ */
+Object.defineProperty(proto, 'includes', {
+    value: function (otherState) {
+        const
+            {keys} = otherState;
+        let i = keys.length;
+        
+        while (i--) {
+            const
+                state = keys[i];
+
+            if (this.get(state) !== otherState.get(state)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+});
+
+/**
+ * Checks whether the provided state matches any equivalent keys on this state.
+ *
+ * @method platypus.StateMap#intersects
+ * @param state {platypus.StateMap} The state that this state should intersect.
+ * @return {Boolean} Whether this state intersects the provided state.
+ */
+Object.defineProperty(proto, 'intersects', {
+    value: function (otherState) {
+        const
+            {keys} = otherState;
+        let i = keys.length;
+        
+        while (i--) {
+            const
+                state = keys[i];
+
+            if (this.get(state) === otherState.get(state)) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+});
+
+/**
+ * Returns StateMap from cache or creates a new one if none are available.
+ *
+ * @method platypus.StateMap.setUp
+ * @return {platypus.StateMap} The instantiated StateMap.
+ */
+/**
+ * Returns StateMap back to the cache. Prefer the StateMap's recycle method since it recycles property objects as well.
+ *
+ * @method platypus.StateMap.recycle
+ * @param {platypus.StateMap} stateMap The StateMap to be recycled.
+ */
+/**
+ * Relinquishes StateMap properties and recycles it.
+ *
+ * @method platypus.StateMap#recycle
+ */
+recycle.add(StateMap, 'StateMap', StateMap, function () {
+    this.clear();
+}, true);
+
+export default StateMap;

package/src/Storage.js

@@ -0,0 +1,152 @@
+/* global platypus, window */
+import DataMap from './DataMap.js';
+import {UserData} from 'springroll';
+
+/**
+ * This class is used to create the Platypus storage system accessible at `platypus.storage`. It uses Springroll UserData if available, with a fallback to local storage if not.
+ *
+ * @memberof platypus
+ * @class Storage
+ * @param {*} springroll 
+ * @param {*} options 
+ * @return {Data} Returns the new Storage object.
+ */
+class Storage {
+    constructor (springroll, {name: gameId, storageKeys: keys = null}) {
+        const
+            storageKey = `${gameId}-data`,
+            unconnectedData = window.localStorage.getItem(storageKey),
+            handleData = (resp) => {
+                const
+                    data = resp?.data ?? resp;
+
+                if (data) {
+                    const
+                        keys = Object.keys(data),
+                        {length} = keys;
+            
+                    for (let i = 0; i < length; i++) {
+                        const
+                            key = keys[i];
+            
+                        if (this.map.has(key)) {
+                            this.map.set(key, data[key]);
+                        } else {
+                            this.addKey(key, data[key]);
+                        }
+                    }
+                }
+            };
+
+        this.map = DataMap.setUp();
+
+        /**
+         * The storage key being used to store data.
+         *
+         * @property storageKey
+         * @type String
+         * @default options.name+'-data'
+         */
+        this.storageKey = storageKey;
+
+        /**
+         * Whether Springroll is connected to a hosting page.
+         *
+         * @property connected
+         * @type Boolean
+         * @default false
+         */
+        this.connected = false;
+
+        if (keys) {
+            for (let i = 0; i < keys.length; i++) {
+                this.addKey(keys[i], null);
+            }
+        }
+
+        try { // May throw if data is not parseable. If so, we'll just ignore it.
+            handleData(JSON.parse(unconnectedData));
+        } catch (e) {}
+
+        // Using Bellhop's "connected" event because springroll.state.ready doesn't ensure that Bellhop is also ready.
+        springroll.container.on('connected', async () => {
+            this.connected = true;
+            try {
+                handleData(await UserData.read(this.storageKey));
+            } catch (e) {
+                platypus.debug.warn('Storage: connected but received an error', e);
+            }
+        });
+    }
+
+    /**
+     * Adds a storage key to the game's storage.
+     *
+     * @param {String} key The key to add.
+     * @param {*} value The data to store at this defined key.
+     */
+    addKey (key, value) {
+        this.map.set(key, value);
+        Object.defineProperty(this, key, {
+            get: function () {
+                return this.map.get(key);
+            },
+            set: function (value) {
+                this.map.set(key, value);
+
+                this.save();
+            },
+            configurable: true,
+            enumerable: true
+        });
+    }
+
+    /**
+     * Gets a value from storage for the provided storage key.
+     *
+     * @param {String} key The key for the data to return
+     * @return {*}
+     */
+    get (key) {
+        if (!this.map.has(key)) {
+            this.addKey(key, null);
+        }
+
+        return this[key];
+    }
+
+    /**
+     * Takes the current game storage and saves it to local storage or Springroll UserData
+     *
+     */
+    async save () {
+        const save = this.map.toJSON();
+        
+        if (this.connected) {
+            try {
+                await UserData.write(this.storageKey, save);
+            } catch (e) {
+                platypus.debug.warn('Storage: tried to save but received an error', e);
+            }
+        } else {
+            window.localStorage.setItem(this.storageKey, JSON.stringify(save));
+        }
+    }
+
+    /**
+     * Updates a storage key's data. Creates the key if it does not exist.
+     *
+     * @param {String} key The key to update.
+     * @param {*} value The data to store at this key.
+     */
+    set (key, value) {
+        if (!this.map.has(key)) {
+            this.addKey(key, value);
+            this.save();
+        } else {
+            this[key] = value;
+        }
+    }
+};
+
+export default Storage;

package/src/TickerClient.js

@@ -0,0 +1,48 @@
+export default class {
+    constructor (targetFPS = 60) {
+        const
+            listeners = this.listeners = [],
+            worker = this.worker = new Worker(new URL('./TickerServer.js', import.meta.url));
+
+        this.deltaMS = 1000 / targetFPS;
+        this.elapsedMS = this.deltaMS;
+        
+        worker.onmessage = ({data}) => {
+            this.elapsedMS = data.deltaTime;
+            listeners.forEach((listener) => listener(data));
+        };
+
+        this.start();
+    }
+
+    add (listener) {
+        this.listeners.push(listener);
+    }
+
+    remove (listener) {
+        const
+            i = this.listeners.indexOf(listener);
+
+        if (i >= 0) {
+            this.listeners.splice(i, 1);
+        }
+    }
+
+    start () {
+        this.worker.postMessage({
+            begin: {
+                delta: this.deltaMS
+            }
+        });
+    }
+
+    stop () {
+        this.worker.postMessage({
+            stop: true
+        });
+    }
+
+    get FPS () {
+        return 1000 / this.elapsedMS;
+    }
+}