@urso/core 0.3.3 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urso/core",
-  "version": "0.3.3",
+  "version": "0.3.7",
   "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/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/objects/models/checkbox.js

@@ -22,7 +22,7 @@ class ModulesObjectsModelsCheckbox extends UrsoCoreModulesObjectsModelsToggle {
         this.contents = [];
 
         this.action = Urso.helper.recursiveGet('action', params, () => { 
-            this.emit(Urso.events.MODULES_OBJECTS_CHECKBOX_PRESS, { name: this.name, status: this._toggleStatus, class: this.class }) 
+            this.emit(Urso.events.MODULES_OBJECTS_CHECKBOX_PRESS, { name: this.name, status: this.status, class: this.class }) 
         });
 
         this.lable = Urso.helper.recursiveGet('lable', params, false);
@@ -31,7 +31,7 @@ class ModulesObjectsModelsCheckbox extends UrsoCoreModulesObjectsModelsToggle {
     }
 
     _createCheckbox() {
-        this._toggleStatus = this.defaultStatus;
+        this.status = this.defaultStatus;
         this._checkbox = this._createObject(this.buttonFrames[`${this.defaultStatus}Out`])
 
         if (this.lable)
@@ -77,14 +77,15 @@ class ModulesObjectsModelsCheckbox extends UrsoCoreModulesObjectsModelsToggle {
 
     _changeTexture(key) {
         if (!this.buttonFrames[key]) {
-            if (key === `${this._toggleStatus}Out`) {
+            if (key === `${this.status}Out`) {
                 Urso.logger.error('ModulesObjectsModelsButton assets error: no out image ' + this.buttonFrames.out);
                 return false;
             }
 
-            this._changeTexture(`${this._toggleStatus}Out`); // load default texture for this key
+            this._changeTexture(`${this.status}Out`); // load default texture for this key
             return false;
         }
+        
         if (this.buttonFrames[key].type === Urso.types.objects.GRAPHICS)
             this._drawGraphics(this.buttonFrames[key].figure);
         else

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,11 +55,10 @@ 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) {
-            window.asd = this._baseObject.state
             this._baseObject.state.clearListeners();
             this._baseObject.state.addListener({ complete: this.animation.onComplete });
         }
@@ -70,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 });
@@ -78,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/models/textInput.js

@@ -16,6 +16,7 @@ class ModulesObjectsModelsTextInput extends Urso.Core.Modules.Objects.BaseModel
         this.numbersOnly = Urso.helper.recursiveGet('numbersOnly', params, false);
         this.allowedSymbols = Urso.helper.recursiveGet('allowedSymbols', params, false);
         this.substituteText = Urso.helper.recursiveGet('substituteText', params, false);
+        this.maxLength = Urso.helper.recursiveGet('maxLength', params, false);
     }
 
     restrictInput(allowedSymbols) {
@@ -40,15 +41,25 @@ class ModulesObjectsModelsTextInput extends Urso.Core.Modules.Objects.BaseModel
     }
 
     _onBlur(){
-        this.text = this._baseObject.text;
         const data = {name: this.name, class: this.class, id: this.id, text: this.text};
         this.emit(Urso.events.MODULES_OBJECTS_TEXTINPUT_BLUR, data);
     }
 
+    _onInput() {
+        this.text = this._baseObject.text;
+        const data = {name: this.name, class: this.class, id: this.id, text: this.text};
+        this.emit(Urso.events.MODULES_OBJECTS_TEXTINPUT_INPUT, data);
+    }
+
     _addBaseObject() {
         this._baseObject = new PIXI.TextInput({ input: this.input, box: this.box });
         this._baseObject.substituteText = this.substituteText;
+
+        if(this.maxLength)
+            this._baseObject.maxLength = this.maxLength
+
         this._baseObject.on('blur', this._onBlur.bind(this))
+        this._baseObject.on('input', this._onInput.bind(this))
     };
 }
 

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

@@ -5,7 +5,7 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
     constructor(params) {
         super(params);
 
-        this._toggleStatus = 'unpressed';
+        this.status = 'unpressed';
 
         this.type = Urso.types.objects.TOGGLE;
         this._addBaseObject();
@@ -18,7 +18,7 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         super.setupParams(params);
 
         this.action = Urso.helper.recursiveGet('action', params, () => { 
-            this.emit(Urso.events.MODULES_OBJECTS_TOGGLE_PRESS, { name: this.name, status: this._toggleStatus, class: this.class }) 
+            this.emit(Urso.events.MODULES_OBJECTS_TOGGLE_PRESS, { name: this.name, status: this.status, class: this.class }) 
         });
 
         this.buttonFrames = {
@@ -37,13 +37,13 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         this.buttonFrames[key] = assetKey;
 
         if (this._isOver)
-            this._changeTexture(`${this._toggleStatus}Over`);
+            this._changeTexture(`${this.status}Over`);
         else if(this._isDown)
-            this._changeTexture(`${this._toggleStatus}Down`);
+            this._changeTexture(`${this.status}Down`);
         else if(this._isDisabled)
-            this._changeTexture(`${this._toggleStatus}Disabled`);
+            this._changeTexture(`${this.status}Disabled`);
         else
-            this._changeTexture(`${this._toggleStatus}Out`);
+            this._changeTexture(`${this.status}Out`);
     }
 
     enable() {
@@ -51,9 +51,9 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
             return false;
 
         if (this._isOver)
-            this._changeTexture(`${this._toggleStatus}Over`);
+            this._changeTexture(`${this.status}Over`);
         else
-            this._changeTexture(`${this._toggleStatus}Out`);
+            this._changeTexture(`${this.status}Out`);
 
         this._isDisabled = false;
     }
@@ -62,7 +62,7 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         if (this._isDisabled)
             return false;
 
-        this._changeTexture(`${this._toggleStatus}Disabled`);
+        this._changeTexture(`${this.status}Disabled`);
         this._isDisabled = true;
     }
 
@@ -101,9 +101,9 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         if (this._isDisabled) //can be disabled after keyDownAction
             return false;
 
-        this._changeTexture(`${this._toggleStatus}Down`);
+        this._changeTexture(`${this.status}Down`);
 
-        this._toggleStatus = this._toggleStatus === 'pressed' ? 'unpressed' : 'pressed';
+        this.status = this.status === 'pressed' ? 'unpressed' : 'pressed';
     }
 
     _onButtonUp() {
@@ -119,9 +119,9 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
             return false;
 
         if (this._isOver)
-            this._changeTexture(`${this._toggleStatus}Over`);
+            this._changeTexture(`${this.status}Over`);
         else
-            this._changeTexture(`${this._toggleStatus}Out`);
+            this._changeTexture(`${this.status}Out`);
     }
 
     _onButtonOver() {
@@ -133,7 +133,7 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         if (this.mouseOverAction)
             this.mouseOverAction();
 
-        this._changeTexture(`${this._toggleStatus}Over`);
+        this._changeTexture(`${this.status}Over`);
     }
 
     _onButtonOut() {
@@ -145,19 +145,28 @@ class ModulesObjectsModelsToggle extends UrsoCoreModulesObjectsModelsButton {
         if (this.mouseOutAction)
             this.mouseOutAction();
 
-        this._changeTexture(`${this._toggleStatus}Out`);
+        this._changeTexture(`${this.status}Out`);
+    }
+
+    switchStatus() {
+        this.status = this.status === 'pressed' ? 'unpressed' : 'pressed';
+        
+        if (this._isOver)
+            this._changeTexture(`${this.status}Over`);
+        else
+            this._changeTexture(`${this.status}Out`);
     }
 
     _changeTexture(key) {
         let texture = Urso.cache.getTexture(this.buttonFrames[key]);
 
         if (!texture) {
-            if (key === `${this._toggleStatus}Out`) {
+            if (key === `${this.status}Out`) {
                 Urso.logger.error('ModulesObjectsModelsButton assets error: no out image ' + this.buttonFrames.out);
                 return false;
             }
 
-            this._changeTexture(`${this._toggleStatus}Out`); // load default texture for this key
+            this._changeTexture(`${this.status}Out`); // load default texture for this key
             return false;
         }
 

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

@@ -12,6 +12,7 @@ class ModulesObserverConfig {
             MODULES_OBJECTS_SLIDER_SET_NEW_VALUE: 'modules.objects.slider.setNewValue',
             MODULES_OBJECTS_TOGGLE_PRESS: 'modules.objects.toggle.press',
             MODULES_OBJECTS_TEXTINPUT_BLUR: 'modules.objects.textinput.blur',
+            MODULES_OBJECTS_TEXTINPUT_INPUT: 'modules.objects.textinput.input',
             MODULES_OBJECTS_CHECKBOX_PRESS: 'modules.objects.checkbox.press',
             MODULES_LOGIC_SOUNDS_DO: 'modules.soundManager.do',
             MODULES_SOUND_MANAGER_UPDATE_CFG: 'modules.soundManager.updateCfg',

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;

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);

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);
     }