@urso/core 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urso/core",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "HTML5 game engine",
   "main": "build/js/index.js",
   "author": "Megbrimef",

package/src/js/modules/objects/models/spine.js

@@ -36,49 +36,83 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
     }
 
     /**
-     * stop track animation or all animations
-     * @param {Number} [track] - you can define track number to stop
+     * play spine animation and execute function after animation completes
+     * @param {String} animation - name of the animation to be played
+     * @param {Function} func - function to be executed
      */
-    stop(track) {
-        if (typeof track !== 'undefined')
-            this._baseObject.state.clearTrack(track);
-        else
-            this._baseObject.state.clearTracks();
+    playAndThen(animation, func) {
+        this.playInSequenceAndThen([animation], func);
     }
 
     /**
-     * add object to spine slot
-     * @param {Object} object - created by engine object
-     * @param {String} slotName
-     * @param {Boolean} replaceSlotContent - will replace other slot content
+     * play spine animations in sequence
+     * @param {String[]} animations - names of the animations to be played
      */
-    addToSlot(object, slotName, replaceSlotContent) {
-        const spine = this._baseObject;
-        const slotIndex = spine.spineData.slots.findIndex(({ name }) => name === slotName);
-        const currentSlot = spine.slotContainers[slotIndex];
+    playInSequence(animations) {
+        this.stop();
+        const defaultTrack = 0;
+        animations.forEach(e => this._baseObject.state.addAnimation(defaultTrack, e));
+    }
 
-        if (currentSlot) {
-            object._baseObject.scale.y = -1;
+    /**
+     * play spine animations in sequence and execute function after last animation completes
+     * @param {String[]} animations - names of the animations to be played
+     * @param {Function} func - function to be executed
+     */
+    playInSequenceAndThen(animations, func) {
+        let animationsLeft = animations.length;
+        let removeSelf = () => { };
+        let completer = {
+            complete: () => {
+                if (--animationsLeft === 0) {
+                    func();
+                    removeSelf();
+                }
+            }
+        };
+        removeSelf = () => this._baseObject.state.removeListener(completer);
+        this._baseObject.state.addListener(completer);
+        this.playInSequence(animations);
+    }
 
-            Urso.objects.removeChild(object.parent, object);
+    /**
+     * stop track animation
+     * @param {Number} [track] - you can define track number to stop
+     */
+    stopTrack(track) {
+        this._baseObject.state.clearTrack(track);
+    }
 
-            if (replaceSlotContent)
-                currentSlot.removeChildren(); //todo check if its proxy and reset parent
+    /**
+     * stop all animations
+     */
+    stop() {
+        this._baseObject.state.clearTracks();
+    }
 
-            //object.parent = this; //todo && make removeChild
-            currentSlot.addChild(object._baseObject);
-        } else {
-            Urso.logger.warn('ModulesObjectsModelsSpine addToSlot error: no spine slot ' + slotName);
-        }
+    /**
+     * reset all animations
+     */
+    reset() {
+        this._baseObject.state.setEmptyAnimations();
     }
 
     /**
-     * replace spine slot with new object
+     * add object to spine slot
+     * @param {String} slotName
      * @param {Object} object - created by engine object
+     */
+    addToSlot(slotName, object) {
+        this._addToSlot(slotName, object, false);
+    }
+
+    /**
+     * replace spine slot with new object
      * @param {String} slotName
+     * @param {Object} object - created by engine object
      */
-    replaceSlotWith(object, slotName) {
-        this.addToSlot(object, slotName, true);
+    replaceSlotWith(slotName, object) {
+        this._addToSlot(slotName, object, true);
     }
 
     /**
@@ -100,6 +134,9 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             this._baseObject.state.timeScale = config.timeScale;*/ //deprecated - now we use getTimeScale getter
 
         if (config.onComplete) {
+            if (this._baseObject.state.listeners.length !== 0) {
+                Urso.logger.warn('ModulesObjectsModelsSpine setAnimationConfig warning: animation state listeners will be cleared');
+            }
             this._baseObject.state.clearListeners();
             this._baseObject.state.addListener({ complete: this.animation.onComplete });
         }
@@ -126,6 +163,26 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             this.play(this.animation.name, this.animation.loop);
     };
 
+    _addToSlot(slotName, object, replaceSlotContents) {
+        const spine = this._baseObject;
+        const slotIndex = spine.spineData.slots.findIndex(({ name }) => name === slotName);
+        const currentSlot = spine.slotContainers[slotIndex];
+
+        if (currentSlot) {
+            object._baseObject.scale.y = -1;
+
+            Urso.objects.removeChild(object.parent, object);
+
+            if (replaceSlotContents)
+                currentSlot.removeChildren(); //todo check if its proxy and reset parent
+
+            //object.parent = this; //todo && make removeChild
+            currentSlot.addChild(object._baseObject);
+        } else {
+            Urso.logger.warn('ModulesObjectsModelsSpine _addToSlot error: no spine slot ' + slotName);
+        }
+    }
+
     /**
      * get animation timeScale
      * @returns Number