@urso/core 0.7.46 → 0.7.48

package/package.json

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

package/src/js/modules/observer/controller.js

@@ -11,56 +11,107 @@ class ModulesObserverController {
         this._getUid = this._getUid.bind(this);
     }
 
+    /**
+     * fire event
+     * @param {String} eventName
+     * @param {Mixed} params
+     * @param {Number} delay
+     */
     fire(eventName, params, delay) {
-        if (!eventName)
-            return Urso.logger.error('ModulesObserverController fire error:', eventName);
+        if (!eventName) {
+            Urso.logger.error('ModulesObserverController fire error:', eventName);
+            return;
+        }
 
-        if (delay)
-            return setTimeout((() => { this.fire(eventName, params); }).bind(this), delay)
+        if (delay) {
+            setTimeout((() => { this.fire(eventName, params); }).bind(this), delay);
+            return;
+        }
 
         this._fireLocal(eventName, params);
-        this._fireLocal(eventName + this._getCurPrefix(), params);
+        this._fireLocal(eventName + this._getLocalSuffix(), params);
     };
 
+    /**
+     * add listener
+     * @param {String} eventName
+     * @param {Function} callback
+     * @param {Boolean} global
+     */
     add(eventName, callback, global) {
-        if (!eventName || !callback)
-            return Urso.logger.error('ModulesObserverController add error:', eventName, callback);
+        if (!eventName || !callback) {
+            Urso.logger.error('ModulesObserverController add error:', eventName, callback);
+            return
+        }
 
         if (global)
             this._addLocal(eventName, callback);
         else
-            this._addLocal(eventName + this._getCurPrefix(), callback);
+            this._addLocal(eventName + this._getLocalSuffix(), callback);
     }
 
+    /**
+     * remove listener
+     * @param {String} eventName
+     * @param {Function} callback
+     * @param {Boolean} global
+     */
     remove(eventName, callback, global) {
         if (global)
             this._removeLocal(eventName, callback);
         else
-            this._removeLocal(eventName + this._getCurPrefix(), callback);
+            this._removeLocal(eventName + this._getLocalSuffix(), callback);
     }
 
+    /**
+     * set local events prefix
+     * @param {String} p
+     */
     setPrefix(p) {
         this._prefix = p;
     };
 
-    _getUid() {
+    /**
+     * get callback uid
+     * @param {Function} callback
+     * @returns {String}
+     */
+    _getUid(callback) {
+        if (callback._ouid) //observer callback uid alredy exists
+            return callback._ouid;
+
         this._counter++;
         return 'observer_' + this._counter;
     }
 
+    /**
+     * add local listener
+     * @param {String} name
+     * @param {Function} callback
+     */
     _addLocal(name, callback) {
         if (!this._observers[name])
             this._observers[name] = {};
 
-        const uid = this._getUid();
-        callback._ouid = uid;
+        const uid = this._getUid(callback);
+
+        if (!callback._ouid) {
+            callback._ouid = uid;
+        }
 
         this._observers[name][uid] = callback;
     }
 
+    /**
+     * remove local listener
+     * @param {String} name
+     * @param {Function} callback
+     */
     _removeLocal(name, callback) {
-        if (!this._observers[name] || !callback._ouid)
-            return Urso.logger.error('ModulesObserverController remove error, no observer with', name, callback);
+        if (!this._observers[name] || !callback._ouid) {
+            Urso.logger.error('ModulesObserverController remove error, no observer with', name, callback);
+            return;
+        }
 
         const uid = callback._ouid;
         delete this._observers[name][uid];
@@ -69,6 +120,12 @@ class ModulesObserverController {
             delete this._observers[name];
     }
 
+    /**
+     * fire local event
+     * @param {String} name
+     * @param {Mixed} params
+     * @returns {Boolean}
+     */
     _fireLocal(name, params) {
         if (!this._observers[name])
             return false;
@@ -79,20 +136,31 @@ class ModulesObserverController {
         return true;
     }
 
+    /**
+     * clear all local listeners (can be used on scene switch)
+     */
     clearAllLocal() {
         for (let name in this._observers) {
-            if (name.endsWith(this._getCurPrefix()))
+            if (name.endsWith(this._getLocalSuffix()))
                 delete this._observers[name];
         }
     }
 
+    /**
+     * clear all listeners
+     * @returns {Boolean}
+     */
     clear() {
         this._observers = {};
 
         return true;
     }
 
-    _getCurPrefix() {
+    /**
+     * get local events suffix
+     * @returns {String}
+     */
+    _getLocalSuffix() {
         return this._prefixDelimiter + this._prefix;
     };
 };

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

@@ -3,6 +3,12 @@ class ModulesStatesManagerConfigStates {
         this.singleton = true;
 
         this.contents = {
+            START_GAME: {
+                action: 'gameInit',
+                nextState: ["IDLE"], //next state to go after finish this state
+                callLimit: 1 //auto guard will return false, if limit is reached
+            },
+
             IDLE: { action: 'startSpin' },
 
             SPIN_START: {

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

@@ -18,6 +18,7 @@ class ModulesStatesManagerController {
 
         this._iterator; //will be defined after start
         this._nextState = this._nextState.bind(this);
+        this._statesCallStatistic = {};
     }
 
     start() {
@@ -117,6 +118,10 @@ class ModulesStatesManagerController {
 
         this._currentState = this._iterator.next();
 
+        //fill states call statistic
+        if (!this._statesCallStatistic[this._currentState]) this._statesCallStatistic[this._currentState] = 0;
+        this._statesCallStatistic[this._currentState]++;
+
         this.emit(Urso.events.MODULES_STATES_MANAGER_STATE_CHANGE, this._currentState);
 
         log('%c State ' + this._currentState, 'background: #bada55; color: #000')
@@ -176,6 +181,14 @@ class ModulesStatesManagerController {
     }
 
     checkStateGuard = (key) => {
+        //auto guard will check callLimit and return false, if limit is reached
+        const callLimit = this._configStates[this._currentState].callLimit;
+
+        if (
+            callLimit &&
+            callLimit >= (this._statesCallStatistic[this._currentState] || 0)
+        ) { return false; }
+
         const guardResult = this.statesGuards.checkGuard(key);
         log('%c State guard ' + key + ' is ' + guardResult, 'background: #DA55C4; color: #000')
         return guardResult;