@urso/core 0.6.2 → 0.6.4

package/package.json

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

package/src/js/components/debug/fps.js

@@ -21,12 +21,14 @@ class ComponentsDebugFps {
         this.frames++;
 
         if (currentTime - this.lastUpdateTime < 1000)
-            return
+            return;
 
         const fps = Math.round(1000 * this.frames / (currentTime - this.lastUpdateTime));
         this.lastUpdateTime = currentTime;
         this.frames = 0;
-        this._coordsText.text = 'fps:' + fps;
+
+        const fpsData = Urso.scenes.getFpsData();
+        this._coordsText.text = `fps: ${fps}, sceneFps: ${fpsData.fps}, limit: ${fpsData.limit}`;
     };
 
 }

package/src/js/config/main.js

@@ -6,7 +6,11 @@ let ConfigMain = {
     extendingChain: ['Urso.Core'], //chain that will be set as Urso.Game
     defaultScene: 'play', //default scene to display
     useBinPath: false, // use assets from bin directory
-    useTransport: false // use transport module for connetcting with server
+    useTransport: false, // use transport module for connetcting with server
+    fps: {
+        limit: 60, //max fps limit
+        optimizeLowPerformance: true //down to 30 fps if lower 60
+    }
 };
 
 module.exports = ConfigMain;

package/src/js/modules/instances/controller.js

@@ -16,6 +16,13 @@ class ModulesInstancesController {
         this.removeMode = this.removeMode.bind(this);
     }
 
+    /**
+     * get class by Path
+     * @param {String} path
+     * @param {Boolean} [noModes]
+     * @param {String} [modeName]
+     * @returns {Class}
+     */
     getByPath(path, noModes, modeName) {
         let callback = (a) => {
             return a;
@@ -24,10 +31,19 @@ class ModulesInstancesController {
         return this._findClass({ path, callback, noModes, modeName });
     }
 
+    /**
+     * get current modes
+     * @returns {Array}
+     */
     getModes() {
         return this._modes;
     }
 
+    /**
+     * add mode to system
+     * @param {String} mode
+     * @returns {Boolean}
+     */
     addMode(mode) {
         if (this._modes.indexOf(mode) !== -1)
             return false;
@@ -40,8 +56,8 @@ class ModulesInstancesController {
     /**
      * remove mode from system
      * @param {String} mode
-     * @param {Boolean} passiveMode - do not refresh styles
-     * @returns
+     * @param {Boolean} [passiveMode] - do not refresh styles
+     * @returns {Boolean}
      */
     removeMode(mode, passiveMode) {
         let index = this._modes.indexOf(mode);
@@ -58,6 +74,14 @@ class ModulesInstancesController {
         return true;
     }
 
+    /**
+     * get class instance by path
+     * @param {String} path
+     * @param {mixed} [params]
+     * @param {Boolean} [noModes]
+     * @param {String} [modeName]
+     * @returns {Class | false}
+     */
     getInstance(path, params, noModes, modeName) {
         let callback = (classObject) => {
             if (typeof classObject !== "function") { //typeof class is a function
@@ -84,11 +108,20 @@ class ModulesInstancesController {
         return this._findClass({ path, callback, noModes, modeName });
     }
 
+    /**
+     * get uid for instance
+     * @returns {String}
+     */
     _getUid() {
         this._counter++;
         return 'instance' + this._counter;
     }
 
+    /**
+     * set common functions to instance
+     * @param {Class} classObject
+     * @param {String} path
+     */
     _setComonFunctions(classObject, path) {
         classObject.prototype.getInstance = this._entityGetInstance(path);
         classObject.prototype.addListener = this._entityAddListener;
@@ -96,6 +129,11 @@ class ModulesInstancesController {
         classObject.prototype.emit = this._entityEmit;
     }
 
+    /**
+     * set common entities functions to instance
+     * @param {Class} classObject
+     * @param {ClassInstance} callerObject
+     */
     _setComonEntityFunctions(classObject, callerObject) {
         if (callerObject.common && !classObject.common) { //components common
             classObject.common = callerObject.common;
@@ -106,6 +144,10 @@ class ModulesInstancesController {
         }
     }
 
+    /**
+     * launch default functions after creation
+     * @param {ClassInstance} instance
+     */
     _launchDefaultFunctions(instance) {
         //_subscribe
         if (instance && instance._subscribe)
@@ -118,6 +160,11 @@ class ModulesInstancesController {
         }
     }
 
+    /**
+     * entity get instance (with parent deps)
+     * @param {String} path
+     * @returns {Function}
+     */
     _entityGetInstance(path) {
         const entityPath = Urso.helper.initial(path.split('.')).join('.');
         const self = this;
@@ -138,6 +185,11 @@ class ModulesInstancesController {
         };
     }
 
+    /**
+     * add entity to caller class
+     * @param {ClassInstance} classObject
+     * @param {ClassInstance} callerObject
+     */
     _addEntityToClass(classObject, callerObject) {
         if (!callerObject.__entities)
             callerObject.__entities = [];
@@ -146,18 +198,32 @@ class ModulesInstancesController {
             callerObject.__entities.push(classObject);
     }
 
+    /**
+     * entity addListener function
+     */
     _entityAddListener() {
         Urso.observer.add.apply(Urso.observer, arguments);
     }
 
+    /**
+     * entity removeListener function
+     */
     _entityRemoveListener() {
         Urso.observer.remove.apply(Urso.observer, arguments);
     }
 
+    /**
+     * entity emit function
+     */
     _entityEmit() {
         Urso.observer.fire.apply(Urso.observer, arguments);
     }
 
+    /**
+     * find class by params
+     * @param {Object} params
+     * @returns {Class | false}
+     */
     _findClass(params) {
         //put all params exept callback in key
         let cacheKey = [
@@ -190,6 +256,12 @@ class ModulesInstancesController {
         return params.callback(this._cache[cacheKey]);
     }
 
+    /**
+     * get class by path
+     * @param {String} path
+     * @param {Boolean} [noModes]
+     * @returns {Class | false}
+     */
     _getClassByPath(path, noModes) {
         let pathArr = path.split('.');
         let entitiesArray = Urso.helper.mergeArrays(['Urso', 'Game'], pathArr);
@@ -199,7 +271,7 @@ class ModulesInstancesController {
     /**
      * check if object exist
      * @param {Object} entitiesArray like ['Urso', 'Game', 'Lib', 'Helper']
-     * @returns {mixed}
+     * @returns {Class | false}
      */
     _checkPathExist(entitiesArray, noModes) {
         let currentTestObject = window;
@@ -235,6 +307,13 @@ class ModulesInstancesController {
         return currentTestObject;
     }
 
+    /**
+     * check path for modes
+     * @param {Object} currentTestObject
+     * @param {Array} entitiesArray
+     * @param {Number} entitiesIndex
+     * @returns {Class | false}
+     */
     _checkPathWithModes(currentTestObject, entitiesArray, entitiesIndex) {
         for (let mode of this._modes) {
             const capMode = Urso.helper.capitaliseFirstLetter(mode);
@@ -253,6 +332,13 @@ class ModulesInstancesController {
         return false;
     }
 
+    /**
+     * check path for mixins
+     * @param {Object} currentTestObject
+     * @param {Array} entitiesArray
+     * @param {Number} entitiesIndex
+     * @returns {Array}
+     */
     _getMixins(currentTestObject, entitiesArray, entitiesIndex) {
         const mixins = [];
 

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

@@ -21,6 +21,22 @@ class ModulesScenesController {
         this._service.display(name);
     }
 
+    /**
+     * get fps
+     * @returns {Number}
+     */
+    getFps() {
+        return this.getInstance('PixiWrapper').getFps();
+    }
+
+    /**
+     * get fps data
+     * @returns {Object}
+     */
+    getFpsData() {
+        return this.getInstance('PixiWrapper').getFpsData();
+    }
+
     /**
      * pause scene
      */

package/src/js/modules/scenes/pixiWrapper.js

@@ -1,3 +1,6 @@
+const NORMAL_FPS_COUNT = 60;
+const LOW_PERFORMANCE_FPS_COUNT = 30;
+
 class ModulesScenesPixiWrapper {
     constructor() {
         this.singleton = true;
@@ -13,10 +16,17 @@ class ModulesScenesPixiWrapper {
         this._loopPaused = false;
         this._loopLastCall = 0;
 
-        this.loop = this.loop.bind(this);
+        this._loop = this._loop.bind(this);
         this.passiveCallIntervalId = null;
 
         this._mouseCoords = { x: 0, y: 0 };
+
+
+        this._maxFPSLimit = Urso.config.fps.limit;
+        this._lastUpdateTime = 0;
+        this._frames = 0;
+        this._currentFPS = Urso.config.fps.limit;
+        this._lastTimeCheckFPS = 0;
     }
 
     init() {
@@ -35,7 +45,7 @@ class ModulesScenesPixiWrapper {
         this.interaction = new PIXI.InteractionManager(this.renderer);
 
         this._loaderScene = this.getInstance('Model');
-        this._requestAnimFrame(this.loop);
+        this._requestAnimFrame(this._loop);
 
         this.getInstance('Resolutions');
     }
@@ -62,10 +72,112 @@ class ModulesScenesPixiWrapper {
     resume() {
         this._loopLastCall = Date.now();
         this._loopPaused = false;
-        this.update();
+        this._update();
         PIXI.spine.settings.GLOBAL_AUTO_UPDATE = true;
     }
 
+    /**
+     * resize renderer
+     * @param {Number} width
+     * @param {Number} height
+     */
+    resize(width, height) {
+        this.renderer.resize(width, height);
+    };
+
+    /**
+     * hide canvas
+     */
+    hideCanvas() {
+        this.renderer.view.style.display = 'none';
+    }
+
+    /**
+     * show canvas
+     */
+    showCanvas() {
+        this.renderer.view.style.display = '';
+    }
+
+    /**
+     * set world scale
+     * @param {Number} x
+     * @param {Number} y
+     */
+    setWorldScale(x, y) {
+        this.world.scale.x = x;
+        this.world.scale.y = y;
+    }
+
+    /**
+     * set canvas width
+     * @param {Number} val
+     */
+    setCanvasWidth(val) {
+        this.renderer.view.style.width = val + 'px';
+    };
+
+    /**
+     * set canvas height
+     * @param {Number} val
+     */
+    setCanvasHeight(val) {
+        this.renderer.view.style.height = val + 'px';
+    };
+
+    /**
+     * get pixi world (main Container)
+     * @returns {Object}
+     */
+    getPixiWorld() {
+        return this.world;
+    }
+
+    /**
+     * set new scene
+     * @param {Object} model
+     */
+    setNewScene(model) {
+        this._createWorld();
+        this.currentScene = model;
+    }
+
+    /**
+     * get fps
+     * @returns {Number}
+     */
+    getFps() {
+        return this._currentFPS;
+    }
+
+    /**
+     * get fps data
+     * @returns {Object}
+     */
+    getFpsData() {
+        return {
+            fps: this._currentFPS,
+            limit: this._maxFPSLimit
+        }
+    }
+
+    /**
+     * get cached mouse coords
+     * @returns {Object}
+     */
+    getCachedMouseCoords() {
+        return this._mouseCoords;
+    }
+
+    /**
+     * generateTexture from object
+     * @param {Object} obj
+     * @returns {Object} - pixi.Texture
+     */
+    generateTexture(obj) {
+        return this.renderer.generateTexture(obj);
+    }
+
     _setPixiSettings() {
         PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
         PIXI.settings.TEXT_RESOLUTION = 1;
@@ -107,19 +219,53 @@ class ModulesScenesPixiWrapper {
         return deltaTime * 60 / 1000;
     };
 
-    loop() {
+    _loop() {
         if (this._loopStopped)
             return false;
 
-        this._requestAnimFrame(this.loop);
+        this._requestAnimFrame(this._loop);
 
-        if (!this._loopPaused)
-            this.update();
+        if (!this._loopPaused) {
+            if (!this._fpsCheckAllowUpdate())
+                return;
+
+            this._update();
+        }
 
         return true;
     };
 
-    update() {
+    _fpsCheckAllowUpdate() {
+        const currentTime = Urso.time.get();
+        this._updateCurrentFPS(currentTime);
+
+        //setup maxFPSLimit
+        if (Urso.config.fps.optimizeLowPerformance)
+            if (this._currentFPS < NORMAL_FPS_COUNT)
+                this._maxFPSLimit = LOW_PERFORMANCE_FPS_COUNT;
+            else
+                this._maxFPSLimit = Urso.config.fps.limit;
+
+        //check need update
+        if (currentTime - this._lastUpdateTime < ~~(1000 / this._maxFPSLimit))
+            return false;
+
+        this._lastUpdateTime = currentTime;
+        return true;
+    }
+
+    _updateCurrentFPS(currentTime) {
+        this._frames++;
+
+        if (currentTime - this._lastTimeCheckFPS < 1000)
+            return;
+
+        this._currentFPS = Math.round(1000 * this._frames / (currentTime - this._lastTimeCheckFPS));
+        this._lastTimeCheckFPS = currentTime;
+        this._frames = 0;
+    }
+
+    _update() {
         if (!this.currentScene)
             return;
 
@@ -135,41 +281,6 @@ class ModulesScenesPixiWrapper {
         this.renderer.render(this._root);
     };
 
-    //size
-    resize(width, height) {
-        this.renderer.resize(width, height);
-    };
-
-    hideCanvas() {
-        this.renderer.view.style.display = 'none';
-    }
-
-    showCanvas() {
-        this.renderer.view.style.display = '';
-    }
-
-    setWorldScale(x, y) {
-        this.world.scale.x = x;
-        this.world.scale.y = y;
-    }
-
-    setCanvasWidth(val) {
-        this.renderer.view.style.width = val + 'px';
-    };
-
-    setCanvasHeight(val) {
-        this.renderer.view.style.height = val + 'px';
-    };
-
-    getPixiWorld() {
-        return this.world;
-    }
-
-    setNewScene(model) {
-        this._createWorld();
-        this.currentScene = model;
-    }
-
     _checkMouse() {
         let newCoords = this._getMouseCoords();
 
@@ -180,10 +291,6 @@ class ModulesScenesPixiWrapper {
         this.emit(Urso.events.MODULES_SCENES_MOUSE_NEW_POSITION, this._mouseCoords);
     };
 
-    getCachedMouseCoords() {
-        return this._mouseCoords;
-    }
-
     _getMouseCoords() {
         const coords = {
             x: ~~(this.interaction.mouse.global.x / this.world.scale.x),
@@ -204,7 +311,7 @@ class ModulesScenesPixiWrapper {
      * reserve loop, when browser tab is inactive
      * @param {Boolean} isVisible
      */
-    visibilityChangeHandler(isVisible) {
+    _visibilityChangeHandler(isVisible) {
         if (isVisible) {
             if (this.passiveCallIntervalId) {
                 clearInterval(this.passiveCallIntervalId);
@@ -215,22 +322,13 @@ class ModulesScenesPixiWrapper {
 
         this.passiveCallIntervalId = setInterval(() => {
             if (!this._loopStopped && !this._loopPaused) {
-                this.update();
+                this._update();
             }
         }, 16);
     }
 
-    /**
-     * generateTexture from object
-     * @param {Object} obj
-     * @returns {Object} - pixi.Texture
-     */
-     generateTexture(obj) {
-        return this.renderer.generateTexture(obj);
-    }
-
     _subscribeOnce() {
-        this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_VISIBILITYCHANGE, this.visibilityChangeHandler.bind(this), true);
+        this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_VISIBILITYCHANGE, this._visibilityChangeHandler.bind(this), true);
     }
 }