@urso/core 0.1.91 → 0.2.0-dev

package/src/js/modules/statesManager/action.js

@@ -1,113 +1,55 @@
-class ModulesStatesManagerAction {
-
-    /*{
-        name: 'showWinPopup',
-        events: {
-            onStart: 'action.showWinPopup.start',
-            toComplete: 'winPopup.display.finished'
-        },
-        isTerminable: true,
-        terminateEvents:{
-            onStart: 'action.showWinPopup.terminate',
-            toComplete: 'winPopup.display.terminated'
-        }
-    }*/
-
-
-    constructor(params) {
-        this._terminating = false;
-        this.finished = false;
-        this._onFinishCallback = false;
-
-        let options = (typeof params === 'string') ? { name: params } : params;
-
-        if (options) {
-            this.options = options;
-            this.name = options.name;
-        }
-
-        this._onComplete = this._onComplete.bind(this);
-        this._onTerminate = this._onTerminate.bind(this);
-    }
-
-    //can we start this action?
-    guard() {
-        if (this.options._eventBlank)
-            return this.getInstance('Controller').checkGuard(this.options._eventBlank);
-        else
-            return true;
-    }
-
-    //can action be terminated ?
-    isTerminable() {
-        if (this.options)
-            return this.options.isTerminable;
-
-        return true;
-    }
-
-    run(onFinishCallback) {
-        log(`%c action run ---> ${this.name}`, 'color: blue', this.options);
-
-        this.finished = false;
-        this._onFinishCallback = onFinishCallback;
-        this._addListeners();
-
-        if (this.options && Urso.helper.recursiveGet('options.events.onStart', this, false))
-            this.emit(this.options.events.onStart);
-
-        //TODO remove temp for debug
-        // let timeout = Math.floor(Math.random() * 2000);
-        // setTimeout(() => { this._onFinish(); }, timeout);
-    }
-
-    terminate() {
-        if (!this.isTerminable() || this._terminating)
-            return;
-
-        log(`%c action terminate X ${this.name}`, 'color: blue');
-
-        this._terminating = true;
-
-        if (this.options && Urso.helper.recursiveGet('options.terminateEvents.onStart', this, false))
-            this.emit(this.options.terminateEvents.onStart);
-    }
-
-    _onFinish() {
-        if (this.finished)
-            return;
-
-        this._removeListeners();
-        this.finished = true;
-        log(`%c action finish <--- ${this.name}`, 'color: blue');
-        this._onFinishCallback();
-    }
-
-    _onComplete() {
-        this._onFinish();
-    }
-
-    _onTerminate() {
-        this._terminating = false;
-        this._onFinish();
-    }
-
-    _addListeners() {
-        if (this.options && Urso.helper.recursiveGet('options.events.toComplete', this, false))
-            this.addListener(this.options.events.toComplete, this._onComplete, true);
-
-        if (this.options && Urso.helper.recursiveGet('options.terminateEvents.toComplete', this, false))
-            this.addListener(this.options.terminateEvents.toComplete, this._onTerminate, true);
-    }
-
-    _removeListeners() {
-        if (this.options && Urso.helper.recursiveGet('options.events.toComplete', this, false))
-            this.removeListener(this.options.events.toComplete, this._onComplete, true);
-
-        if (this.options && Urso.helper.recursiveGet('options.terminateEvents.toComplete', this, false))
-            this.removeListener(this.options.terminateEvents.toComplete, this._onTerminate, true);
-    }
-
-}
-
-module.exports = ModulesStatesManagerAction;
+class ModulesStatesManagerAction {
+
+    constructor(name) {
+        this.name = name;
+
+        this._terminating = false;
+        this.finished = false;
+        this._onFinishCallback = false;
+
+        this._onFinish = this._onFinish.bind(this);
+    }
+
+    //can we start this action?
+    guard() {
+        return this.getInstance('Controller').checkActionGuard(this.name);
+    }
+
+    run(onFinishCallback) {
+        log(`%c action run ---> ${this.name}`, 'color: blue');
+
+        this.finished = false;
+        this._onFinishCallback = onFinishCallback;
+
+        Urso.statesManager.runAction(this.name, this._onFinish);
+
+        //TODO remove temp for debug
+        //let timeout = Math.floor(Math.random() * 2000);
+        //Urso.statesManager.runAction(this.name, () => setTimeout(() => { this._onFinish(); }, timeout));
+    }
+
+    terminate() {
+        if (this._terminating) {
+            Urso.logger.error('ModulesStatesManagerAction: action alredy terminating', this.name);
+            return;
+        }
+
+        log(`%c action terminate X ${this.name}`, 'color: blue');
+        this._terminating = true;
+        Urso.statesManager.terminateAction(this.name);
+    }
+
+    _onFinish() {
+        if (this.finished) {
+            Urso.logger.error('ModulesStatesManagerAction: action alredy finished', this.name);
+            return;
+        }
+
+        this._terminating = false;
+        this.finished = true;
+        log(`%c action finish <--- ${this.name}`, 'color: blue');
+        this._onFinishCallback();
+    }
+}
+
+module.exports = ModulesStatesManagerAction;

package/src/js/modules/statesManager/actions/_info.js

@@ -1,3 +1,3 @@
-Urso.Core.Modules.StatesManager.Actions = {
-    //todo
-};
+Urso.Core.Modules.StatesManager.Actions = {
+    //todo
+};

package/src/js/modules/statesManager/all.js

@@ -1,23 +1,23 @@
-Race = require('./race.js');
-
-class ModulesStatesManagerAll extends Race {
-    constructor(params) {
-        super(params);
-        this.name = 'All';
-    }
-
-    //can we start this action?
-    guard() {
-        for (let action of this._actions)
-            if (action.guard())
-                return true;
-
-        return false;
-    }
-
-    _actionSuccessHandler() {
-        this._checkFinish();
-    }
-}
-
-module.exports = ModulesStatesManagerAll;
+Race = require('./race.js');
+
+class ModulesStatesManagerAll extends Race {
+    constructor(params) {
+        super(params);
+        this.name = 'All';
+    }
+
+    //can we start this action?
+    guard() {
+        for (let action of this._actions)
+            if (action.guard())
+                return true;
+
+        return false;
+    }
+
+    _actionSuccessHandler() {
+        this._checkFinish();
+    }
+}
+
+module.exports = ModulesStatesManagerAll;

package/src/js/modules/statesManager/configStates.js

@@ -1,86 +1,71 @@
-class ModulesStatesManagerConfigStates {
-    constructor() {
-        this.singleton = true;
-
-        this.contents = {
-            IDLE: { action: 'startSpin' },
-
-            SPIN_START: {
-                all: [
-                    { action: 'serverSpinRequest' },
-                    { action: 'slotMachineSpinStart' }
-                ]
-            },
-
-            SPIN_FINISHING: { action: 'spin' },
-
-            WINLINES_ANIMATE_ALL: { action: 'showWinlinesAnimationAll' },
-
-            PICK_GAME1: {
-                sequence: [
-                    { action: 'someAction' },
-                    { action: 'showPickGame' },        //showPickGame --> setGuardAction, setGuardState(PICK_GAME1)
-                    { action: 'showBIGWin' }
-                ],
-                nextState: ["PICK_GAME2", "PICK_GAME1", "IDLE"]
-            },
-
-            PICK_GAME2: {
-                sequence: [
-                    { action: 'showWheel' },          //showWheel --> setGuardAction, setGuardState(PICK_GAME2)
-                    { action: 'showBIGWin' }
-                ],
-                nextState: ["PICK_GAME1", "IDLE"]
-            },
-
-            WINLINES_ANIMATE_BY_ONE: { action: 'showWinlinesAnimation' },
-
-            GAMBLE: {
-                race: [
-                    { action: 'playerLooseinGamble' },
-                    { action: 'playerCollectMoney' }
-                ]
-            },
-
-            UPDATE_BALANCE: {
-                race: [
-                    {
-                        all: [
-                            {
-                                sequence: [
-                                    { action: 'showWinPopup' },
-                                    { action: 'closeWinPopup' }
-                                ]
-                            },
-                            { action: 'counterUpdate' }
-                        ]
-                    },
-                    { action: 'playerPressSpace' },
-                    { action: 'playerPressSPIN' }
-                ]
-            }
-        };
-
-        // this.actionsParams = {
-        //     showWinPopup: {
-        //         name: 'showWinPopup',
-        //         events: {
-        //             onStart: 'action.showWinPopup.start',
-        //             toComplete: 'winPopup.display.finished'
-        //         },
-        //         isTerminable: true,
-        //         terminateEvents: {
-        //             onStart: 'action.showWinPopup.terminate',
-        //             toComplete: 'winPopup.display.terminated'
-        //         }
-        //     }
-        // };
-    }
-
-    get() {
-        return this.contents;
-    };
-
-}
-
-module.exports = ModulesStatesManagerConfigStates;
+class ModulesStatesManagerConfigStates {
+    constructor() {
+        this.singleton = true;
+
+        this.contents = {
+            IDLE: { action: 'startSpin' },
+
+            SPIN_START: {
+                all: [
+                    { action: 'serverSpinRequest' },
+                    { action: 'slotMachineSpinStart' }
+                ]
+            },
+
+            SPIN_FINISHING: { action: 'spin' },
+
+            WINLINES_ANIMATE_ALL: { action: 'showWinlinesAnimationAll' },
+
+            PICK_GAME1: {
+                sequence: [
+                    { action: 'someAction' },
+                    { action: 'showPickGame' },        //showPickGame --> addActionGuard(showPickGame, funk)
+                    { action: 'showBIGWin' }
+                ],
+                nextState: ["PICK_GAME2", "PICK_GAME1", "IDLE"]  //setGuardState(PICK_GAME2, func)
+            },
+
+            PICK_GAME2: {
+                sequence: [
+                    { action: 'showWheel' },          //showWheel --> addActionGuard(showWheel, funk)
+                    { action: 'showBIGWin' }
+                ],
+                nextState: ["PICK_GAME1", "IDLE"]
+            },
+
+            WINLINES_ANIMATE_BY_ONE: { action: 'showWinlinesAnimation' },
+
+            GAMBLE: {
+                race: [
+                    { action: 'playerLooseinGamble' },
+                    { action: 'playerCollectMoney' }
+                ]
+            },
+
+            UPDATE_BALANCE: {
+                race: [
+                    {
+                        all: [
+                            {
+                                sequence: [
+                                    { action: 'showWinPopup' },
+                                    { action: 'closeWinPopup' }
+                                ]
+                            },
+                            { action: 'counterUpdate' }
+                        ]
+                    },
+                    { action: 'playerPressSpace' },
+                    { action: 'playerPressSPIN' }
+                ]
+            }
+        };
+    }
+
+    get() {
+        return this.contents;
+    };
+
+}
+
+module.exports = ModulesStatesManagerConfigStates;

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

@@ -1,91 +1,132 @@
-class ModulesStatesManagerController {
-    constructor() {
-        this.singleton = true;
-
-        this._configStates;
-        this._currentState;
-        this._started = false;
-        this._guardsCounter = 0;
-        this._guards = {};
-
-        this._iterator = this._iteratorConstructor();
-        this._nextState = this._nextState.bind(this);
-    }
-
-    start() {
-        if (this._started)
-            return;
-
-        this._started = true;
-        this._configStates = this.getInstance('ConfigStates').get();
-        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;
-
-        return {
-            next: (() => {
-                let statesArray = Object.keys(this._configStates);
-
-                if (nextIndex === statesArray.length)
-                    nextIndex = 0;
-
-                return statesArray[nextIndex++];
-            }).bind(this)
-        }
-    }
-
-    _nextState() {
-        this._currentState = this._iterator.next();
-
-        this.emit(Urso.events.MODULES_STATES_MANAGER_STATE_CHANGE, this._currentState);
-
-        log('%c State ' + this._currentState, 'background: #bada55; color: #000')
-
-        let config = this._configStates[this._currentState];
-        let classInstance = this.getInstance('Helper').getActionByConfig(config);
-
-        if (!classInstance.guard())
-            return this._nextState();
-
-        classInstance.run(this._nextState);
-    }
-}
-
-module.exports = ModulesStatesManagerController;
+class ModulesStatesManagerController {
+    constructor() {
+        this.singleton = true;
+
+        this._configStates;
+        this._currentState;
+        this._started = false;
+
+        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);
+    }
+
+    start() {
+        if (this._started)
+            return;
+
+        this._started = true;
+        this._configStates = this.getInstance('ConfigStates').get();
+        this._nextState();
+    }
+
+    _iteratorConstructor() {
+        let nextIndex = 0;
+
+        return {
+            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;
+
+                return statesArray[nextIndex++];
+            }).bind(this)
+        }
+    }
+
+    _nextState() {
+        this._currentState = this._iterator.next();
+
+        this.emit(Urso.events.MODULES_STATES_MANAGER_STATE_CHANGE, this._currentState);
+
+        log('%c State ' + this._currentState, 'background: #bada55; color: #000')
+
+        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;