@urso/core 0.1.92 → 0.2.1-dev

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

@@ -5,8 +5,12 @@ class ModulesStatesManagerController {
         this._configStates;
         this._currentState;
         this._started = false;
-        this._guardsCounter = 0;
-        this._guards = {};
+
+        this.statesGuards = this.getInstance('FunctionsStorage');
+        this.actionsGuards = this.getInstance('FunctionsStorage');
+        this.actionsRuns = this.getInstance('FunctionsStorage');
+        this.actionsTerminations = this.getInstance('FunctionsStorage');
+
 
         this._iterator = this._iteratorConstructor();
         this._nextState = this._nextState.bind(this);
@@ -21,41 +25,6 @@ class ModulesStatesManagerController {
         this._nextState();
     }
 
-    setGuard(key, guard) {
-        if (!this._guards[key])
-            this._guards[key] = {};
-
-        const guid = this._getGuardsUid();
-        guard._guid = guid;
-        this._guards[key][guid] = guard;
-    }
-
-    checkGuard(key) {
-        if (this._guards[key]) {
-            let guardsArray = Object.values(this._guards[key]);
-
-            for (let guard of guardsArray) {   // any
-                if (!guard())
-                    return false;
-            }
-        }
-
-        return true;
-    }
-
-    removeGuard(key, guard) {
-        const guid = guard._guid;
-        delete this._guards[key][guid];
-
-        if (Urso.helper.getObjectSize(this._guards[key]) === 0)
-            delete this._guards[key];
-    }
-
-    _getGuardsUid() {
-        this._guardsCounter++;
-        return 'guard_' + this._guardsCounter;
-    }
-
     _iteratorConstructor() {
         let nextIndex = 0;
 
@@ -63,6 +32,28 @@ class ModulesStatesManagerController {
             next: (() => {
                 let statesArray = Object.keys(this._configStates);
 
+                //nextState
+                if (this._currentState) {
+                    const currentState = this._configStates[this._currentState];
+
+                    if (currentState.nextState) { //nextState: ["PICK_GAME2", "PICK_GAME1", "IDLE"]
+
+                        for (const stateKey of currentState.nextState) {
+                            if (this.checkStateGuard(stateKey)) {
+                                nextIndex = statesArray.indexOf(stateKey);
+
+                                if (nextIndex === -1) {
+                                    Urso.logger.error('ModulesStatesManagerController: nextState name error', stateKey);
+                                    continue;
+                                }
+
+                                return stateKey;
+                            }
+                        }
+                    }
+                }
+
+                //regular round logic
                 if (nextIndex === statesArray.length)
                     nextIndex = 0;
 
@@ -81,11 +72,61 @@ class ModulesStatesManagerController {
         let config = this._configStates[this._currentState];
         let classInstance = this.getInstance('Helper').getActionByConfig(config);
 
+        //state guard
+        if (!this.checkStateGuard(this._currentState))
+            return this._nextState();
+
+        //actions instances guard
         if (!classInstance.guard())
             return this._nextState();
 
         classInstance.run(this._nextState);
     }
+
+    //actions guards
+    addActionGuard(key, guard) {
+        this.actionsGuards.add(key, guard);
+    }
+
+    checkActionGuard(key) {
+        return this.actionsGuards.checkGuard(key);
+    }
+
+    removeActionGuard(key, guard) {
+        this.actionsGuards.remove(key, guard);
+    }
+
+    //actions runs
+    addActionRun(key, runFunction) {
+        this.actionsRuns.add(key, runFunction);
+    }
+
+    runAction(key, onFinishCallback) {
+        this.actionsRuns.runAndCallbackOnFinish(key, onFinishCallback);
+    }
+
+    //actions terminations
+    addActionTerminate(key, terminateFunction) {
+        this.actionsTerminations.add(key, terminateFunction);
+    }
+
+    terminateAction(key) {
+        this.actionsTerminations.run(key);
+    }
+
+    //states guards
+    setStateGuard(key, guard) {
+        this.statesGuards.add(key, guard);
+    }
+
+    checkStateGuard(key) {
+        return this.statesGuards.checkGuard(key);
+    }
+
+    removeStateGuard(key, guard) {
+        this.statesGuards.remove(key, guard);
+    }
+
 }
 
 module.exports = ModulesStatesManagerController;

package/src/js/modules/statesManager/functionsStorage.js

@@ -0,0 +1,83 @@
+
+class ModulesStatesManagerFunctionsStorage {
+    constructor() {
+        this._functionsCounter = 0;
+        this._functions = {};
+    }
+
+    //guards
+    add(key, guard) {
+        this._addToStorage(key, guard, true);
+    }
+
+    run(key) {
+        if (this._functions[key]) {
+            const functionsArray = Object.values(this._functions[key]);
+
+            for (const func of functionsArray) {
+                func();
+            }
+        }
+    }
+
+    runAndCallbackOnFinish(key, onFinishCallback) {
+        if (this._functions[key]) {
+            const functionsArray = Object.values(this._functions[key]);
+
+            const promises = [];
+
+            for (const func of functionsArray) {
+                promises.push(new Promise((resolve, reject) => { func(resolve); }));
+            }
+
+            Promise.all(promises).then(onFinishCallback);
+        } else {
+            onFinishCallback();
+        }
+    }
+
+    checkGuard(key) {
+        if (this._functions[key]) {
+            const guardsArray = Object.values(this._functions[key]);
+
+            for (const guard of guardsArray) {
+                if (!guard())
+                    return false;
+            }
+        }
+
+        return true;
+    }
+
+    remove(key, guard) {
+        this._removeFromStorage(key, guard);
+    }
+
+    _addToStorage(key, func, onlyOneFlag) {
+        if (!this._functions[key])
+            this._functions[key] = {};
+        else if (onlyOneFlag) {
+            Urso.logger.error('ModulesStatesManagerFunctionsStorage: action or state can have only one guard', key, func);
+            return;
+        }
+
+        const guid = this._getGuardsUid();
+        func._guid = guid;
+        this._functions[key][guid] = func;
+    }
+
+    _removeFromStorage(key, func) {
+        const guid = func._guid;
+        delete this._functions[key][guid];
+
+        if (Urso.helper.getObjectSize(this._functions[key]) === 0)
+            delete this._functions[key];
+    }
+
+    _getGuardsUid() {
+        this._functionsCounter++;
+        return 'guard_' + this._functionsCounter;
+    }
+}
+
+module.exports = ModulesStatesManagerFunctionsStorage;

package/src/js/modules/statesManager/helper.js

@@ -6,22 +6,12 @@ class ModulesStatesManagerHelper {
     getActionByConfig(config) {
         let actionType = Object.keys(config)[0];
         let actionParams = config[actionType];
-        let configActions = this.getInstance('ConfigActions').get();
 
         if (actionType === "action") {
             //actionParams is action name
             let actionName = actionParams;
 
-            if (configActions[actionName]) {
-                let actionParamsConfig = Urso.helper.objectClone(configActions[actionName]);
-
-                if (!actionParamsConfig.name)
-                    actionParamsConfig.name = actionName;
-
-                actionParams = this.getInstance('ActionModel', actionParamsConfig); //replace params to action model
-            }
-
-            let customActionInstance = this.getInstance('Actions.' + Urso.helper.capitaliseFirstLetter(actionName), actionParams);
+            let customActionInstance = this.getInstance('Actions.' + Urso.helper.capitaliseFirstLetter(actionName));
 
             if (customActionInstance) {
                 return customActionInstance;

package/src/js/modules/statesManager/race.js

@@ -24,11 +24,6 @@ class ModulesStatesManagerRace extends Action {
         return true;
     }
 
-    //can action be terminated ?
-    isTerminable() {
-        return true;
-    }
-
     run(onFinishCallback) {
         log(`%c action run ---> ${this.name}`, 'color: orange', this.params);
 

package/src/js/modules/statesManager/actionModel.js

@@ -1,48 +0,0 @@
-class ModulesStatesManagerActionModel {
-    constructor(params) {
-        this._eventsEndings = {
-            events: {
-                onStart: '.onStart',
-                toComplete: '.completed',
-            },
-            terminateEvents: {
-                onStart: '.onTerminate',
-                toComplete: '.terminated',
-            }
-        }
-
-        this.name = Urso.helper.recursiveGet('name', params, 'unnamedAction');;
-        this._eventBlank = Urso.helper.recursiveGet('eventBlank', params, null);
-
-        this.events = {
-            onStart: Urso.helper.recursiveGet('events.onStart', params, null),
-            toComplete: Urso.helper.recursiveGet('events.toComplete', params, null) //return boolean param
-        };
-
-        this.isTerminable = Urso.helper.recursiveGet('isTerminable', params, true);
-
-        this.terminateEvents = {
-            onStart: Urso.helper.recursiveGet('terminateEvents.onStart', params, null),
-            toComplete: Urso.helper.recursiveGet('terminateEvents.toComplete', params, null) //return boolean param
-        };
-
-        //setup defaults from _eventBlank
-        this._setupDefaults();
-    }
-
-    _setupDefaults() {
-        if (!this._eventBlank)
-            return false;
-
-        for (let eventsType in this._eventsEndings) {
-            for (let event in this._eventsEndings[eventsType]) {
-                if (!this[eventsType][event]) {
-                    this[eventsType][event] = this._eventBlank + this._eventsEndings[eventsType][event];
-                }
-            }
-        }
-    }
-
-}
-
-module.exports = ModulesStatesManagerActionModel;

package/src/js/modules/statesManager/configActions.js

@@ -1,54 +0,0 @@
-class ModulesStatesManagerConfigActions {
-    constructor() {
-        this.singleton = true;
-
-        this.contents = {
-            startSpin: {
-                name: 'startSpin',
-                /*events: {
-                    onStart: 'action.showWinPopup.start',
-                    toComplete: 'winPopup.display.finished'
-                },*/
-                isTerminable: true,
-                /*terminateEvents: {
-                    onStart: 'action.showWinPopup.terminate',
-                    toComplete: 'winPopup.display.terminated'
-                }*/
-            },
-            showWinPopup: {
-                name: 'showWinPopup',
-                /*events: {
-                    onStart: 'action.showWinPopup.start',
-                    toComplete: 'winPopup.display.finished'
-                },
-                isTerminable: true,
-                terminateEvents: {
-                    onStart: 'action.showWinPopup.terminate',
-                    toComplete: 'winPopup.display.terminated'
-                }*/
-            },
-            showWinlinesAnimationAll: {//full view ---> action model
-                events: {
-                    onStart: 'components.winlines.animateAll.start',
-                    toComplete: 'components.winlines.animateAll.finished'
-                },
-                isTerminable: true,
-                terminateEvents: {
-                    onStart: 'components.winlines.animateAll.terminate',
-                    toComplete: 'components.winlines.animateAll.terminated'
-                }
-            },
-            showWinlinesAnimationAll: { //simple view --->  action model
-                eventBlank: 'components.winlines.animateAll',
-                isTerminable: false
-            }
-        };
-    }
-
-    get() {
-        return this.contents;
-    };
-
-}
-
-module.exports = ModulesStatesManagerConfigActions;