@urso/core 0.3.5 → 0.3.9

package/src/js/modules/scenes/pixiWrapper.js

@@ -71,7 +71,7 @@ class ModulesScenesPixiWrapper {
 
     _getDeltaTime() {
         let newTime = Date.now();
-        let deltaTime = newTime - this._loopLastCall;
+        let deltaTime = Urso.scenes.timeScale * (newTime - this._loopLastCall);
         this._loopLastCall = newTime;
 
         return Urso.math.intMakeBetween(deltaTime, 0, 1000);
@@ -114,6 +114,14 @@ class ModulesScenesPixiWrapper {
         this.renderer.resize(width, height);
     };
 
+    hideCanvas() {
+        this.renderer.view.style.display = 'none';
+    }
+
+    showCanvas() {
+        this.renderer.view.style.display = '';
+    }
+
     setWorldScale(x, y) {
         this.world.scale.x = x;
         this.world.scale.y = y;

package/src/js/modules/scenes/resolutions.js

@@ -8,6 +8,7 @@ class ModulesScenesResolutions {
         this._currentOrientation = null;
 
         this.refreshSceneSize = this.refreshSceneSize.bind(this);
+        this.preResize = this.preResize.bind(this);
         this.refreshSceneSize();
 
         //TODO optimization (performance)
@@ -16,6 +17,7 @@ class ModulesScenesResolutions {
     }
 
     _subscribeOnce() {
+        this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_PRE_RESIZE, this.preResize, true);
         this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_RESIZE, this.refreshSceneSize, true);
         this.addListener(Urso.events.MODULES_SCENES_NEW_SCENE_INIT, this.refreshSceneSize, true);
     }
@@ -24,6 +26,11 @@ class ModulesScenesResolutions {
         return this._templateSize;
     }
 
+    preResize() {
+        if (Urso.helper.mobileAndTabletCheck())
+            this.getInstance('PixiWrapper').hideCanvas();
+    }
+
     refreshSceneSize() {
         let windowSize = this._getWindowSize();
         let orientation = this._getOrientation(windowSize);
@@ -155,6 +162,7 @@ class ModulesScenesResolutions {
             height: ~~(resolution.height * maxResolutionFactor)
         };
 
+        this.getInstance('PixiWrapper').showCanvas();
         this.getInstance('PixiWrapper').resize(canvasSize.width, canvasSize.height);
         this.getInstance('PixiWrapper').setWorldScale(canvasSize.width / this._templateSize.width, canvasSize.height / this._templateSize.height);
         this.getInstance('PixiWrapper').setCanvasWidth(resolution.width / dp);

package/src/js/modules/scenes/service.js

@@ -1,11 +1,14 @@
 class ModulesScenesService {
     constructor() {
         this.singleton = true;
+
         this._displayInProgress = false;
         this._currentSceneName = false;
         this._currentSceneTemplate = false;
         this._sceneModel;
 
+        this.timeScale = 1;
+
         this._pixiWrapper;
 
         this.init();
@@ -18,6 +21,11 @@ class ModulesScenesService {
         this._pixiWrapper.init();
     }
 
+    setTimeScale(value) {
+        this.timeScale = value;
+        gsap.globalTimeline.timeScale(this.timeScale);
+    }
+
     display(name) {
         if (this._displayInProgress) {
             console.warn("Scenes.display is busy ", this._currentSceneName);
@@ -62,9 +70,9 @@ class ModulesScenesService {
         Urso.assets.preload(this._currentSceneTemplate.assets, this._assetsLoadedHandler);
 
     }
-    
-    loadUpdate(loadProgress){
-        if(!this._sceneModel)
+
+    loadUpdate(loadProgress) {
+        if (!this._sceneModel)
             return;
         this._sceneModel.loadUpdate(loadProgress);
         this.emit(Urso.events.MODULES_ASSETS_LOAD_PROGRESS, loadProgress);

package/src/js/modules/statesManager/controller.js

@@ -5,6 +5,8 @@ class ModulesStatesManagerController {
         this._configStates;
         this._currentState;
         this._started = false;
+        this._paused = false;
+        this._pauseNeedResume = false;
 
         this.statesGuards = this.getInstance('FunctionsStorage');
         this.actionsGuards = this.getInstance('FunctionsStorage');
@@ -12,7 +14,7 @@ class ModulesStatesManagerController {
         this.actionsTerminations = this.getInstance('FunctionsStorage');
 
 
-        this._iterator = this._iteratorConstructor();
+        this._iterator; //will be defined after start
         this._nextState = this._nextState.bind(this);
     }
 
@@ -20,14 +22,29 @@ class ModulesStatesManagerController {
         if (this._started)
             return;
 
+        this._currentState = null;
+        this._iterator = this._iteratorConstructor();
         this._started = true;
         this._configStates = this.getInstance('ConfigStates').get();
         this._nextState();
     }
 
+    pause() {
+        this._paused = true;
+    }
+
+    resume() {
+        this._paused = false;
+
+        if (this._pauseNeedResume) {
+            this._pauseNeedResume = false;
+            this._nextState();
+        }
+    }
+
     _iteratorConstructor() {
         let nextIndex = 0;
-    
+
 
         const getNextStateByOrder = () => {
             let statesArray = Object.keys(this._configStates);
@@ -75,6 +92,11 @@ class ModulesStatesManagerController {
     }
 
     _nextState() {
+        if (this._paused) {
+            this._pauseNeedResume = true;
+            return;
+        }
+
         this._currentState = this._iterator.next();
 
         this.emit(Urso.events.MODULES_STATES_MANAGER_STATE_CHANGE, this._currentState);
@@ -92,46 +114,54 @@ class ModulesStatesManagerController {
     }
 
     //actions guards
-    addActionGuard(key, guard) {
+    addActionGuard = (key, guard) => {
         this.actionsGuards.add(key, guard, true);
     }
 
-    checkActionGuard(key) {
+    checkActionGuard = (key) => {
         return this.actionsGuards.checkGuard(key);
     }
 
-    removeActionGuard(key, guard) {
+    removeActionGuard = (key, guard) => {
         this.actionsGuards.remove(key, guard);
     }
 
     //actions runs
-    addActionRun(key, runFunction) {
+    addActionRun = (key, runFunction) => {
         this.actionsRuns.add(key, runFunction);
     }
 
-    runAction(key, onFinishCallback) {
+    runAction = (key, onFinishCallback) => {
         this.actionsRuns.runAndCallbackOnFinish(key, onFinishCallback);
     }
 
+    removeActionRun = (key, runFunction) => {
+        this.actionsRuns.remove(key, runFunction);
+    }
+
     //actions terminations
-    addActionTerminate(key, terminateFunction) {
+    addActionTerminate = (key, terminateFunction) => {
         this.actionsTerminations.add(key, terminateFunction);
     }
 
-    terminateAction(key) {
+    terminateAction = (key) => {
         this.actionsTerminations.run(key);
     }
 
+    removeActionTerminate = (key, terminateFunction) => {
+        this.actionsTerminations.remove(key, terminateFunction);
+    }
+
     //states guards
-    setStateGuard(key, guard) {
+    setStateGuard = (key, guard) => {
         this.statesGuards.add(key, guard, true);
     }
 
-    checkStateGuard(key) {
+    checkStateGuard = (key) => {
         return this.statesGuards.checkGuard(key);
     }
 
-    removeStateGuard(key, guard) {
+    removeStateGuard = (key, guard) => {
         this.statesGuards.remove(key, guard);
     }