@urso/core 0.4.34 → 0.4.37

package/package.json

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

package/src/js/modules/logic/sounds.js

@@ -19,19 +19,26 @@ class ModulesLogicSounds {
             const cfg = this._cfg[configName];
 
             cfg.forEach(obj => {
-                const params = {
-                    action: obj.action || 'play',
-                    relaunch: obj.relaunch || false,
-                    loop: obj.loop || false,
-                    volume: obj.volume || 1
-                };
+                const {
+                    action = 'play',
+                    relaunch = false,
+                    loop = false,
+                    volume = 1,
+                    ...otherParams
+                } = obj;
 
                 if (!mappedCfg[obj.soundKey])
                     mappedCfg[obj.soundKey] = {
                         events: {}
                     };
 
-                mappedCfg[obj.soundKey].events[obj.event] = params;
+                mappedCfg[obj.soundKey].events[obj.event] = {
+                    ...otherParams,
+                    action,
+                    relaunch,
+                    loop,
+                    volume,
+                };;
             });
         });
 

package/src/js/modules/objects/baseModel.js

@@ -13,6 +13,7 @@ class ModulesObjectsBaseModel {
         this._uid = Urso.helper.recursiveGet('_uid', params, false); //will setup on create
         this._templatePath = false;
         this._parsed = false;
+        this._transitions = { tweens: {} };
     }
 
     /**
@@ -44,6 +45,11 @@ class ModulesObjectsBaseModel {
         this.visible = Urso.helper.recursiveGet('visible', params, true);
         this.alpha = Urso.helper.recursiveGet('alpha', params, 1);
         this.blendMode = Urso.helper.recursiveGet('blendMode', params, 1);
+
+        this.transitionDelay = Urso.helper.recursiveGet('transitionDelay', params, false); //time in ms
+        this.transitionDuration = Urso.helper.recursiveGet('transitionDuration', params, false); //time in ms
+        this.transitionProperty = Urso.helper.recursiveGet('transitionProperty', params, false); //props list ex: 'x', 'x y', 'x y alpha'
+
         this.append = Urso.helper.recursiveGet('append', params, true); //if false - object will not created  //TODO
         this.custom = Urso.helper.recursiveGet('custom', params, {}); //custom params
     }

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

@@ -35,6 +35,21 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
         this._baseObject.state.setAnimation(track, animationName, loopFlag);
     }
 
+    /**
+     * set skin by name
+     * @param {String} skinName 
+     */
+    setSkinByName(skinName) {
+        this._baseObject.skeleton.setSkinByName(skinName);
+    }
+
+    /**
+     * reset animation to first frame
+     */
+    setToSetupPose() {
+        this._baseObject.skeleton.setToSetupPose();
+    }
+
     /**
      * play spine animation and execute function after animation completes
      * @param {String} animation - name of the animation to be played
@@ -50,8 +65,24 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
      */
     playInSequence(animations) {
         this.stop();
-        const defaultTrack = 0;
-        animations.forEach(e => this._baseObject.state.addAnimation(defaultTrack, e));
+        let removeSelf = () => { };
+        let animationCount = 0;
+
+        const completer = {
+            complete: () => {
+                animationCount++;
+
+                if (animations[animationCount])
+                    this.play(animations[animationCount])
+                else {
+                    removeSelf();
+                }
+            }
+        }
+
+        removeSelf = () => this._baseObject.state.removeListener(completer);
+        this._baseObject.state.addListener(completer);
+        this.play(animations[0]);
     }
 
     /**
@@ -62,14 +93,16 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
     playInSequenceAndThen(animations, func) {
         let animationsLeft = animations.length;
         let removeSelf = () => { };
+
         let completer = {
             complete: () => {
                 if (--animationsLeft === 0) {
-                    func();
+                    func && func();
                     removeSelf();
                 }
             }
         };
+
         removeSelf = () => this._baseObject.state.removeListener(completer);
         this._baseObject.state.addListener(completer);
         this.playInSequence(animations);

package/src/js/modules/objects/proxy.js

@@ -19,8 +19,9 @@ class ModulesObjectsProxy {
             },
 
             set(target, key, value, receiver) {
+                const oldValue = target._baseObject[key];
                 const rv = Reflect.set(target, key, value, receiver);
-                _this._customSetLogic(target, key, value, proxy);
+                _this._customSetLogic(target, key, value, proxy, oldValue);
                 return rv;
             }
         });
@@ -32,13 +33,15 @@ class ModulesObjectsProxy {
      * propertyName - property to adapt for PIXI object 
      * value - value to set
      */
-    _setProperty(target, propertyName, value) {
+    _setProperty(target, propertyName, value, oldValue) {
         const isAdaptiveProperty = this._propertyAdapter.isAdaptiveProperty(propertyName);
 
         if (isAdaptiveProperty)
             this._propertyAdapter.propertyChangeHandler(target, propertyName);
         else
             Urso.helper.recursiveSet(propertyName, value, target._baseObject);
+
+        this._checkNeedTransitions(target, propertyName, value, oldValue);
     }
 
     safeSetValueToTarget(target, key, value) {
@@ -66,7 +69,7 @@ class ModulesObjectsProxy {
         return Urso.helper.recursiveGet(wrapKey, target._baseObject, reflectValue);
     }
 
-    _customSetLogic(target, key, value, proxy) {
+    _customSetLogic(target, key, value, proxy, oldValue) {
         if (!this._getOriginalModelExceptions().includes(key))
             target._originalModel[key] = value;
 
@@ -83,7 +86,7 @@ class ModulesObjectsProxy {
 
         this._checkSelectorProperties(key);
 
-        this._setProperty(target, propertyName, value);
+        this._setProperty(target, propertyName, value, oldValue);
 
         this._checkMaxSize(target);
 
@@ -131,6 +134,48 @@ class ModulesObjectsProxy {
         }
     }
 
+    /**
+     * transitions tweens creation
+     * @param {Object} target - ObjectsModel
+     * @param {String} propertyName
+     * @param {Number} value
+     * @param {Number} oldValue
+     */
+    _checkNeedTransitions(target, propertyName, value, oldValue) {
+        if (
+            typeof oldValue === 'undefined' ||
+            !target.transitionProperty ||
+            !target.transitionDuration ||
+            !target.transitionProperty.split(' ').includes(propertyName)
+        )
+            return;
+
+        const baseNewValue = target._baseObject[propertyName];
+
+        //remove old active tween
+        const currentTween = target._transitions.tweens[propertyName];
+
+        if (currentTween)
+            currentTween.kill();
+
+        //set base value
+        target._baseObject[propertyName] = oldValue;
+
+        //create new tween
+        const tweenParams = { duration: target.transitionDuration / 1000, ease: "none" };
+        tweenParams[propertyName] = baseNewValue;
+
+        if (target.transitionDelay)
+            tweenParams.delay = target.transitionDelay / 1000;
+
+        const newTween = gsap.to(target._baseObject, tweenParams);
+        target._transitions.tweens[propertyName] = newTween;
+
+        newTween.eventCallback("onComplete", () => {
+            target._transitions.tweens[propertyName] = null;
+        });
+    }
+
     _getSelectorProperties() {
         return [
             'id', 'name', 'class'

package/src/js/modules/soundManager/controller.js

@@ -82,6 +82,7 @@ class SoundManagerController {
         this._systemVolume = ~~(state === 'visible');
         this._updateSoundVolume();
     }
+
     _updateSoundVolume() {
         const totalVolume = this._globalVolume * this._systemVolume;
         for (const key in this._sounds)

package/src/js/modules/soundManager/soundSprite.js

@@ -10,6 +10,7 @@ class SoundSprite {
         this._soundsState = this._initSoundsState();
 
         this._eventsCfg = {};
+        this._fadeTweens = {};
         this._eventsQueue = [];
         this._isAudioUnlocked = false;
 
@@ -97,10 +98,12 @@ class SoundSprite {
         this._player.loop(loop, this._soundsState[soundKey].id);
     };
 
-    setVolume(soundKey, volume = 1) {
-        this._soundsState[soundKey].volume = volume;
-
+    setVolume(soundKey, volume = 1, saveVolumeState = true) {
         this._player.volume(volume, this._soundsState[soundKey].id);
+
+        if(saveVolumeState) {
+            this._soundsState[soundKey].volume = volume;
+        }
     };
 
     setAllVolume(volume) {
@@ -113,9 +116,12 @@ class SoundSprite {
     }
 
     _updateVolume() {
-        const keys = Object.keys(this._soundsState);
+        const soundKeys = Object.keys(this._soundsState);
         this._player._volume = this._totalVolume;
-        keys.forEach(key => this.setVolume(key, this._totalVolume));
+        soundKeys.forEach(soundKey => {
+            const soundVolume = this._soundsState[soundKey].volume * this._totalVolume;
+            this.setVolume(soundKey, soundVolume, false);
+        });
     }
 
     setRelaunch(soundKey, needRelaunch = false) {
@@ -146,6 +152,38 @@ class SoundSprite {
         this._customSubscribe();
     };
 
+    _stopPrevFade(soundKey) {
+        if(this._fadeTweens[soundKey]) {
+            this._fadeTweens[soundKey].kill();
+        }
+
+        delete this._fadeTweens[soundKey];
+    }
+
+    _startFade({ fadeTo, fadeDuration, soundKey }) {
+        const fadeFrom = this._soundsState[soundKey].volume;
+        const delta = fadeTo - fadeFrom;
+
+        const onUpdate = () => {
+            const volume  = fadeFrom + (delta * this._fadeTweens[soundKey].ratio);
+            this.setVolume(soundKey, volume);
+        };
+
+        this._fadeTweens[soundKey] = gsap.to({}, fadeDuration / 1000, { onUpdate });
+    }
+
+    fade({ fadeTo = 1, fadeDuration = 200, startSound = false, soundKey, ...others }) {
+        if(startSound) {
+            this.play({ ...others, soundKey });
+        }
+        if(this._soundsState[soundKey].id === null) {
+            return;
+        }
+
+        this._stopPrevFade(soundKey);
+        this._startFade({ fadeTo, fadeDuration, soundKey });
+    }
+
     _saveEvents(eventsCfg) {
         this._eventsCfg = eventsCfg;
     }
@@ -172,10 +210,10 @@ class SoundSprite {
         this._eventsQueue.push(data);
     };
 
-    _reactToEvent(soundKey, { action, loop, relaunch, volume = 0 }) {
+    _reactToEvent(soundKey, { action, volume, ...otherParams }) {
         volume *= this._totalVolume;
         const self = this;
-        const params = { loop, relaunch, volume, soundKey };
+        const params = { ...otherParams, action, soundKey, volume };
 
         if (!self[action])
             return Urso.logger.error(`SoundSprite error: Sound action '${action}' not found!`);

package/src/js/modules/template/service.js

@@ -79,7 +79,7 @@ class ModulesTemplateService {
         this._mergeStylesAndAssets({ styles: groupTemplate.styles, assets: groupTemplate.assets })
 
         //objects
-        obj.contents = groupTemplate.objects;
+        obj.contents = groupTemplate.objects || [];
     }
 
     _processComponent(obj) {