@urso/core 0.3.5 → 0.3.9

package/package.json

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

package/src/js/components/debug/_info.js

@@ -2,5 +2,6 @@ Urso.Core.Components.Debug = {
     Controller: require('./controller.js'),
     Coords: require('./coords.js'),
     Fps: require('./fps.js'),
-    Template: require('./template.js')
+    Template: require('./template.js'),
+    Timescale: require('./timescale.js')
 };

package/src/js/components/debug/controller.js

@@ -5,7 +5,7 @@ class ComponentsDebugController extends ComponentsBaseController {
         super(params);
 
         this._logicBlocks = [
-            'coords', 'fps', /*'renderStats', 'resolution'*/ //TODO
+            'coords', 'fps', 'timescale' /*'renderStats', 'resolution'*/ //TODO
         ];
 
         this._visible = true;

package/src/js/components/debug/template.js

@@ -22,6 +22,28 @@ class ComponentsDebugTemplate {
                         fontFamily: 'Helvetica',
                         fontSize: 15,
                         fill: '#00FF00'
+                    },
+                    {
+                        type: Urso.types.objects.TEXT,
+                        name: 'debugTimescaleValue',
+                        text: '1',
+                        x: '50%',
+                        y: '30%',
+                        visible: false,
+                        anchorX: 0.5,
+                        anchorY: 0.5,
+                        fontFamily: 'Verdana',
+                        fontSize: 100,
+                        fontStyle: 'italic',
+                        fontWeight: 'bold',
+                        fill: ['#ffffff', '#00ff99'], // gradient
+                        stroke: '#4a1850',
+                        strokeThickness: 5,
+                        dropShadow: true,
+                        dropShadowColor: '#000000',
+                        dropShadowBlur: 4,
+                        dropShadowAngle: Math.PI / 6,
+                        dropShadowDistance: 6,
                     }
                 ]
             }

package/src/js/components/debug/timescale.js

@@ -0,0 +1,60 @@
+class ComponentsDebugTimescale {
+
+    constructor() {
+        this._timescaleText;
+
+        this.create = this.create.bind(this);
+
+        this.scaleStep = 0.5;
+        this.scaleInfoDuration = 2000;
+
+        this._minusButtonsCodes = [109, 189];
+        this._plusButtonsCodes = [107, 187];
+        this._hideId;
+    }
+
+    create() {
+        document.addEventListener('keydown', this.keyPressTest.bind(this));
+        this._timescaleText = this.common.findOne('^debugTimescaleValue');
+        return true;
+    };
+
+    keyPressTest(e) {
+        const evtobj = window.event ? event : e;
+
+        if (!evtobj.altKey) //alt and +/-
+            return;
+
+        let factor = 0;
+
+        if (this._minusButtonsCodes.includes(evtobj.keyCode)) {
+            factor = -1;
+        }
+
+        if (this._plusButtonsCodes.includes(evtobj.keyCode)) {
+            factor = 1;
+        }
+
+        if (!factor)
+            return;
+
+        const timescaleDiff = Urso.scenes.timeScale >= 1 ? this.scaleStep * factor : (this.scaleStep * factor) * 0.1;
+        let timescaleNewValue = Urso.scenes.timeScale + timescaleDiff;
+
+        if (timescaleNewValue < 0.1)
+            timescaleNewValue = 0.1;
+
+        Urso.scenes.timeScale = Urso.math.roundToDigits(timescaleNewValue, 2);
+
+        this._timescaleText.text = Urso.scenes.timeScale;
+        this._timescaleText.visible = true;
+
+        if (this._hideId)
+            clearTimeout(this._hideId);
+
+        this._hideId = setTimeout(() => this._timescaleText.visible = false, this.scaleInfoDuration);
+    }
+
+}
+
+module.exports = ComponentsDebugTimescale;

package/src/js/components/stateDriven/controller.js

@@ -23,6 +23,13 @@ class ComponentsStateDrivenController extends ComponentsBaseController {
     //system callbacks storage
     _finishCallbacks = {};
 
+    _callbacksCache = {
+        stateGuards: {},
+        actionTerminates: {},
+        actionGuards: {},
+        actionRuns: {}
+    };
+
 
     /**
      * caller for delayed finish callback
@@ -40,7 +47,8 @@ class ComponentsStateDrivenController extends ComponentsBaseController {
 
     _processStates() {
         for (const stateKey in this.configStates) {
-            Urso.statesManager.setStateGuard(stateKey, this.configStates[stateKey].guard.bind(this));
+            this._callbacksCache.stateGuards[stateKey] = this.configStates[stateKey].guard.bind(this);
+            Urso.statesManager.setStateGuard(stateKey, this._callbacksCache.stateGuards[stateKey]);
         }
     }
 
@@ -50,21 +58,27 @@ class ComponentsStateDrivenController extends ComponentsBaseController {
             //const actionCfg = this.getInstance('ActionConfig', this.configActions[actionKey]);
             const actionCfg = this.configActions[actionKey];
 
-            if (actionCfg.run)
-                Urso.statesManager.addActionRun(actionKey, (finish) => {
+            if (actionCfg.run) {
+                this._callbacksCache.actionRuns[actionKey] = (finish) => {
                     this._saveFinish(actionKey, finish);
                     actionCfg.run(() => this.callFinish(actionKey));
-                });
-            else {
+                };
+
+                Urso.statesManager.addActionRun(actionKey, this._callbacksCache.actionRuns[actionKey]);
+            } else {
                 Urso.logger.error('ComponentsStateDrivenController: no run function in config', actionKey, this);
                 continue;
             }
 
-            if (actionCfg.terminate)
-                Urso.statesManager.addActionTerminate(actionKey, actionCfg.terminate.bind(this));
+            if (actionCfg.terminate) {
+                this._callbacksCache.actionTerminates[actionKey] = actionCfg.terminate.bind(this);
+                Urso.statesManager.addActionTerminate(actionKey, this._callbacksCache.actionTerminates[actionKey]);
+            }
 
-            if (actionCfg.guard)
-                Urso.statesManager.addActionGuard(actionKey, actionCfg.guard.bind(this));
+            if (actionCfg.guard) {
+                this._callbacksCache.actionGuards[actionKey] = actionCfg.guard.bind(this);
+                Urso.statesManager.addActionGuard(actionKey, this._callbacksCache.actionGuards[actionKey]);
+            }
         }
     }
 
@@ -86,9 +100,17 @@ class ComponentsStateDrivenController extends ComponentsBaseController {
         this._processActions();
     }
 
-    //todo
     destroy() {
-        Urso.logger.error('ComponentsStateDrivenController will remove States and Actions by configs');
+        this._removeCallback(Urso.statesManager.removeStateGuard, this._callbacksCache.stateGuards);
+        this._removeCallback(Urso.statesManager.removeActionGuard, this._callbacksCache.actionGuards);
+        this._removeCallback(Urso.statesManager.removeActionTerminate, this._callbacksCache.actionTerminates);
+        this._removeCallback(Urso.statesManager.removeActionRun, this._callbacksCache.actionRuns);
+    }
+
+    _removeCallback(remover, cacheObject) {
+        for (let cacheKey in cacheObject) {
+            remover(cacheKey, cacheObject[cacheKey]);
+        }
     }
 
 }

package/src/js/extra/_info.js

@@ -12,6 +12,7 @@ require("pixi-text-input");
 
 import { gsap } from 'gsap';
 window.gsap = gsap;
+require('./setTimeout');
 
 import Howler from 'howler';
 window.Howler = Howler;

package/src/js/extra/browserEvents.js

@@ -7,6 +7,8 @@ class ExtraBrowserEvents {
         this.resizeHandler = this.resizeHandler.bind(this);
         this.visibilitychangeHandler = this.visibilitychangeHandler.bind(this);
 
+        this._resizeTimeoutId;
+
         this.init();
     }
 
@@ -25,7 +27,11 @@ class ExtraBrowserEvents {
     }
 
     resizeHandler() {
-        this.emit(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_RESIZE, false, this.RESIZE_DELAY);
+        if (this._resizeTimeoutId)
+            Urso.clearTimeout(this._resizeTimeoutId)
+
+        this.emit(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_PRE_RESIZE);
+        this._resizeTimeoutId = Urso.setTimeout(() => this.emit(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_RESIZE), this.RESIZE_DELAY);
     }
 }
 

package/src/js/extra/setTimeout.js

@@ -0,0 +1,7 @@
+Urso.setTimeout = (callback, delay) => {
+    return gsap.delayedCall(delay / 1000, callback);
+}
+
+Urso.clearTimeout = (tween) => {
+    tween.kill();
+}

package/src/js/lib/cache.js

@@ -11,6 +11,8 @@ class LibCache {
             texture: {},
             file: {}
         };
+
+        this.globalAtlas = new PIXI.spine.TextureAtlas();
     };
 
     addFile(key, someData) {
@@ -47,6 +49,7 @@ class LibCache {
 
     addTexture(key, someData) {
         this.assetsList.texture[key] = someData;
+        this.globalAtlas.addTexture(key, someData);
     };
 
     addSpine(key, someData) {
@@ -93,6 +96,10 @@ class LibCache {
         return this.assetsList.texture[key];
     };
 
+    getGlobalAtlas() {
+        return this.globalAtlas;
+    }
+
 };
 
 module.exports = LibCache;

package/src/js/lib/loader.js

@@ -2,7 +2,7 @@ class LibLoader {
     constructor() {
         this._isRunning = false;
         this._assetsQuery = [];
-        this._onLoadUpdate = () => {};
+        this._onLoadUpdate = () => { };
     };
 
     isRunning() {
@@ -20,10 +20,10 @@ class LibLoader {
     /**
      * gets part of loading path
      */
-    _getLoadPath(asset){
+    _getLoadPath(asset) {
         const { path } = asset;
 
-        if(!Urso.config.useBinPath) {
+        if (!Urso.config.useBinPath) {
             return `assets/${path}`;
         }
 
@@ -33,7 +33,7 @@ class LibLoader {
         if (splitted[0] === 'images') {
             splitted.splice(1, 0, quality);
         }
-        
+
         return `bin/${splitted.join('/')}`;
     };
 
@@ -79,8 +79,8 @@ class LibLoader {
      * setup onload callback
      * @param {Function} onLoad
      */
-    setOnLoadUpdate(onLoadUpdate){
-        if(onLoadUpdate)
+    setOnLoadUpdate(onLoadUpdate) {
+        if (onLoadUpdate)
             this._onLoadUpdate = onLoadUpdate;
     }
 
@@ -98,21 +98,27 @@ class LibLoader {
         this._assetsQuery.forEach(asset => {
             // TODO: check to load
 
-            const params = asset.params || false; // TODO: Set params field in base mode
+            let params = asset.params || false; // TODO: Set params field in base mode
+
+            if (asset.type === Urso.types.assets.SPINE && asset.noAtlas) {
+                if (!params)
+                    params = {};
+
+                params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
+            }
+
             const loadPath = this._getLoadPath(asset);
             loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource))  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
         });
 
-        this._onLoadUpdate({progress: 0});
+        this._onLoadUpdate({ progress: 0 });
         loader.onProgress.add(this._onLoadUpdate);
 
         loader.load(function (loader, resources) {
-            this._onLoadUpdate({progress: 100});
-
-            callback();
-
+            this._onLoadUpdate({ progress: 100 });
             this._assetsQuery = [];
             this._isRunning = false;
+            callback();
         }.bind(this));
     };
 

package/src/js/lib/math.js

@@ -16,6 +16,21 @@ class LibMath {
     getRandomIntBetween(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
+
+    /**
+     * round float number to digits count
+     * @param {Number} num
+     * @param {Number} digits - rounding digits count
+     * @returns {Number}
+     */
+    roundToDigits(num, digits) {
+        if (isNaN(num) || isNaN(digits))
+            return false;
+
+        const pow = Math.pow(10, digits);
+        return Math.round(num * pow) / pow;
+    }
+
 }
 
 module.exports = LibMath;

package/src/js/modules/assets/models/image.js

@@ -2,7 +2,6 @@ class ModulesAssetsModelsImage extends Urso.Core.Modules.Assets.BaseModel {
     constructor(params) {
         super(params);
         this.type = Urso.types.assets.IMAGE;
-
     }
 
     setupParams(params) {

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

@@ -4,6 +4,12 @@ class ModulesAssetsModelsSpine extends Urso.Core.Modules.Assets.BaseModel {
 
         this.type = Urso.types.assets.SPINE;
     }
+
+    setupParams(params) {
+        super.setupParams(params);
+
+        this.noAtlas = Urso.helper.recursiveGet('noAtlas', params, false);
+    }
 }
 
 module.exports = ModulesAssetsModelsSpine;

package/src/js/modules/assets/service.js

@@ -63,13 +63,39 @@ class ModulesAssetsService {
     _loadGroupRestAssets(group, callback) {
         let loader = Urso.getInstance('Lib.Loader');
         loader.setOnLoadUpdate(this.loadUpdate.bind(this));
+        const noAtlasSpines = [];
 
         for (let assetModel of this.assets[group])
             if (assetModel.type !== Urso.types.assets.ATLAS)
-                if (!Urso.cache.getFile(assetModel.path))
-                    this._addAssetToLoader(assetModel, loader);
+                if (!Urso.cache.getFile(assetModel.path)) {
+                    //filter noAtlas Spine files
+                    if (assetModel.type === Urso.types.assets.SPINE && assetModel.noAtlas) {
+                        noAtlasSpines.push(assetModel);
+                    } else
+                        this._addAssetToLoader(assetModel, loader);
+                }
+
+        loader.start(
+            () => {
+                this._processLoadedAssets(group);
+                this._loadNoAtlasSpines(noAtlasSpines, () => {
+                    this.emit(Urso.events.MODULES_ASSETS_GROUP_LOADED, group);
+                    callback();
+                });
+            }
+        );
+    }
+
+    _loadNoAtlasSpines(noAtlasSpines, callback) {
+        if (!noAtlasSpines.length)
+            return callback();
+
+        let loader = Urso.getInstance('Lib.Loader');
+
+        for (let assetModel of noAtlasSpines)
+            this._addAssetToLoader(assetModel, loader);
 
-        loader.start(() => { this._processLoadedAssets(group); this.emit(Urso.events.MODULES_ASSETS_GROUP_LOADED, group); callback(); });
+        loader.start(callback);
     }
 
     _processLoadedAtlases(group) {

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

@@ -8,6 +8,7 @@ class ModulesObjectsModelsSlider extends Urso.Core.Modules.Objects.BaseModel {
         this._baseObject = null;
         this._handleIsPulling = false;
 
+        this._setVariables();
         this._addBaseObject();
         this._createSliderTextures();
         this._createValueText();
@@ -25,6 +26,17 @@ class ModulesObjectsModelsSlider extends Urso.Core.Modules.Objects.BaseModel {
         this.minValueTextModel = Urso.helper.recursiveGet('minValueTextModel', params, false);
         this.maxValueTextModel = Urso.helper.recursiveGet('maxValueTextModel', params, false);
         this.currentValueTextModel = Urso.helper.recursiveGet('currentValueTextModel', params, false);
+        this.isVertical = Urso.helper.recursiveGet('isVertical', params, false);
+    }
+
+    _setVariables() {
+        if(this.isVertical) {
+            this.positionKey = 'y';
+            this.targetObjParam = 'height';
+        }else {
+            this.positionKey = 'x';
+            this.targetObjParam = 'width';
+        }
     }
 
     _createSliderTextures() {
@@ -113,82 +125,94 @@ class ModulesObjectsModelsSlider extends Urso.Core.Modules.Objects.BaseModel {
             this._handleIsDragging = true;
     }
 
-    _onPointerMove({ x }) {
+    _onPointerMove({ x, y }) {
         if (!this._handleIsDragging)
             return
 
-        if (x < this.x)
-            this._sliderHandle.x = 0;
-        else if (x > this.x + this._sliderBg._baseObject.width)
-            this._sliderHandle.x = this._sliderBg._baseObject.width;
+        const value = this.isVertical ? y : x;
+
+        if (value < this[this.positionKey])
+            this._sliderHandle[this.positionKey] = 0;
+        else if (value >= this[this.positionKey] + this._sliderBg._baseObject[this.targetObjParam])
+            this._sliderHandle[this.positionKey] = this._sliderBg._baseObject[this.targetObjParam];
         else
-            this._sliderHandle.x = x - this.x;
+            this._sliderHandle[this.positionKey] = value - this[this.positionKey];
 
         this._setFillMask();
+
+        const data = { class: this.class, name: this.name, position: this._sliderHandle[this.positionKey] };
+        this.emit(Urso.events.MODULES_OBJECTS_SLIDER_HANDLE_MOVE, data)
     }
 
     _onPointerUp(obj) {
         this._handleIsDragging = false;
-        let x;
+        let targetObj;
 
-        if (obj.target === this._sliderBg._baseObject) {
-            x = obj.data.getLocalPosition(obj.target).x;
-        } else
-            x = this._sliderHandle.x;
+        if (obj.target === this._sliderBg._baseObject)
+            targetObj = obj.data.getLocalPosition(obj.target)
+        else
+            targetObj = this._sliderHandle;
 
-        this._dropHandle(x);
+        const {x, y} = targetObj;
+        const value = this.isVertical ? y : x;
+        this._dropHandle(value);
     }
 
     _setDefaultValue(){
         if(!this.points.includes(this.defaultValue))
             this.defaultValue = this.points[0];
 
-        let x = this.points.indexOf(this.defaultValue) * this._sliderBg._baseObject.width / (this.points.length - 1);
+        let value = this.points.indexOf(this.defaultValue) * 
+                    this._sliderBg._baseObject[this.targetObjParam] / (this.points.length - 1);
 
-        this._setNewValue(x, this.defaultValue);
+        this._setNewValue(value, this.defaultValue);
     }
 
-    _dropHandle(x) {
+    _dropHandle(givenValue) {
         let value;
-        let handleX;
+        let coord;
 
         if(this.points.length <= 2){
-            handleX = x;
-            value = ~~(100 / this._sliderBg._baseObject.width * x);
+            coord = givenValue;
+            value = ~~(100 / this._sliderBg._baseObject[this.targetObjParam] * givenValue);
         }
         // calculate closest point
         else{
             for (let i = 0; i < this.points.length; i++) {
-                let pointX = i * this._sliderBg._baseObject.width / (this.points.length - 1);
+                let pointCoord = i * this._sliderBg._baseObject[this.targetObjParam] / (this.points.length - 1);
     
-                if (typeof (handleX) === 'number' && x - pointX < handleX - x) {
-                    handleX = handleX;
+                if (typeof (coord) === 'number' && givenValue - pointCoord < coord - givenValue) {
+                    coord = coord;
                 } else {
-                    handleX = pointX;
+                    coord = pointCoord;
                     value = this.points[i];
                 }
             }
         }
+        const data = { class: this.class, name: this.name, position: coord, value: value };
 
-        this._setNewValue(handleX, value);
+        this.emit(Urso.events.MODULES_OBJECTS_SLIDER_HANDLE_DROP, data);
+        this._setNewValue(coord, value);
     }
 
     _setFillMask(){
         if(!this._fillMask)
             return
 
-        const progress = (this._sliderHandle.x - this._sliderBg.x) * 100 / this._fillTexture._baseObject.width * 0.01;
-        this._fillMask.scaleX = progress;
+        const progress = (this._sliderHandle[this.positionKey] - this._sliderBg[this.positionKey]) * 
+                        100 / this._fillTexture._baseObject[this.targetObjParam] * 0.01;
+        
+        const scaleKey = this.isVertical ? 'scaleY' : 'scaleX';
+        this._fillMask[scaleKey] = progress;
     }
 
-    _setNewValue(x, value){
-        this._sliderHandle.x = x;
+    _setNewValue(coord, value){
+        this._sliderHandle[this.positionKey] = coord;
             
         if (this.currentValueText)
             this.currentValueText.text = value;
 
         this._setFillMask();
-        this.emit(Urso.events.MODULES_OBJECTS_SLIDER_SET_NEW_VALUE, { name: this.name, value: value, class: this.class });
     }
 
     _subscribeOnce() {

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

@@ -17,6 +17,8 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             loop: Urso.helper.recursiveGet('animation.loop', params, false),
             onComplete: Urso.helper.recursiveGet('animation.onComplete', params, false)
         };
+
+        params.animation = this.animation; //we redefine original property here
     }
 
     play(animationName, loopFlag = false, track = 0) {
@@ -53,8 +55,8 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             ...config
         };
 
-        if (config.timeScale)
-            this._baseObject.state.timeScale = config.timeScale;
+        /*if (config.timeScale)
+            this._baseObject.state.timeScale = config.timeScale;*/ //deprecated - now we use getTimeScale getter
 
         if (config.onComplete) {
             this._baseObject.state.clearListeners();
@@ -69,7 +71,8 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             Urso.logger.error('ModulesObjectsModelsSpine assets error: no spine object ' + this.assetKey);
 
         this._baseObject = new PIXI.spine.Spine(spineAsset.spineData);
-        this._baseObject.state.timeScale = this.animation.timeScale;
+        //this._baseObject.state.timeScale = this.animation.timeScale;
+        Object.defineProperty(this._baseObject.state, 'timeScale', { get: this.getTimeScale.bind(this) });
 
         if (this.animation.onComplete)
             this._baseObject.state.addListener({ complete: this.animation.onComplete });
@@ -77,6 +80,10 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
         if (this.animation.name)
             this.play(this.animation.name, this.animation.loop);
     };
+
+    getTimeScale() {
+        return Urso.scenes.timeScale * this.animation.timeScale;
+    }
 }
 
 module.exports = ModulesObjectsModelsSpine;

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

@@ -44,8 +44,11 @@ class ModulesObjectsProxy {
     safeSetValueToTarget(target, key, value) {
         this._safeFlag = true;
 
-        const originalValue = target._originalModel[key];
+        const originalValue = target._originalModel[key]; // we need to save original value in the end
+
+        //setting value
         target[key] = value;
+
         target._originalModel[key] = originalValue;
 
         this._safeFlag = false;

package/src/js/modules/observer/events.js

@@ -9,7 +9,8 @@ class ModulesObserverConfig {
             MODULES_INSTANCES_MODES_CHANGED: 'modules.instances.modes.changed',
             MODULES_OBJECTS_BUTTON_PRESS: 'modules.objects.button.press',
             MODULES_OBJECTS_HIT_AREA_PRESS: 'modules.objects.hitArea.press',
-            MODULES_OBJECTS_SLIDER_SET_NEW_VALUE: 'modules.objects.slider.setNewValue',
+            MODULES_OBJECTS_SLIDER_HANDLE_MOVE: 'modules.objects.slider.handleMove',
+            MODULES_OBJECTS_SLIDER_HANDLE_DROP: 'modules.objects.slider.handleDrop',
             MODULES_OBJECTS_TOGGLE_PRESS: 'modules.objects.toggle.press',
             MODULES_OBJECTS_TEXTINPUT_BLUR: 'modules.objects.textinput.blur',
             MODULES_OBJECTS_TEXTINPUT_INPUT: 'modules.objects.textinput.input',
@@ -27,6 +28,7 @@ class ModulesObserverConfig {
             MODULES_SCENES_DISPLAY_FINISHED: 'modules.scenes.display.finished',
             MODULES_SCENES_MOUSE_NEW_POSITION: 'modules.scenes.mouse.newPosition',
             MODULES_SCENES_UPDATE: 'modules.scenes.update',
+            EXTRA_BROWSEREVENTS_WINDOW_PRE_RESIZE: 'extra.browserEvents.window.pre.resize',
             EXTRA_BROWSEREVENTS_WINDOW_RESIZE: 'extra.browserEvents.window.resize',
             EXTRA_BROWSEREVENTS_WINDOW_VISIBILITYCHANGE: 'extra.browserEvents.window.visibilitychange'
         }

package/src/js/modules/scenes/controller.js

@@ -29,6 +29,14 @@ class ModulesScenesController {
     getMouseCoords() {
         return this.getInstance('PixiWrapper').getCachedMouseCoords();
     }
+
+    get timeScale() {
+        return this._service.timeScale;
+    }
+
+    set timeScale(value) {
+        return this._service.setTimeScale(value);
+    }
 }
 
 module.exports = ModulesScenesController;