@urso/core 0.1.92 → 0.2.1-dev

package/package.json

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

package/src/js/app.js

@@ -14,7 +14,7 @@ class App {
         //setup Instances
         let instances = new Urso.Core.Modules.Instances.Controller();
         Urso.getInstance = instances.getInstance;
-        Urso.getPath = instances.getPath;
+        Urso.getByPath = instances.getByPath;
         Urso.getInstancesModes = instances.getModes;
         Urso.addInstancesMode = instances.addMode;
         Urso.removeInstancesMode = instances.removeMode;
@@ -34,7 +34,7 @@ class App {
 
         //libs
         Urso.cache = Urso.getInstance('Lib.Cache'); //all assets cache
-        Urso.device = Urso.getPath('Lib.Device'); //all device info
+        Urso.device = Urso.getByPath('Lib.Device'); //all device info
         Urso.loader = Urso.getInstance('Lib.Loader'); //assets loader class
         Urso.localData = Urso.getInstance('Lib.LocalData'); //local data storage
         Urso.logger = Urso.getInstance('Lib.Logger'); //logger
@@ -59,6 +59,7 @@ class App {
 
         //App.run
         Urso.device.whenReady(() => {
+            Urso.assets.updateQuality();
             Urso.getInstance('App').run();
         });
     }

package/src/js/components/stateDriven/_info.js

@@ -1,3 +1,4 @@
 Urso.Core.Components.StateDriven = {
+    ActionConfig: require('./actionConfig.js'),
     Controller: require('./controller.js')
 };

package/src/js/components/stateDriven/actionConfig.js

@@ -0,0 +1,7 @@
+class ComponentsStateDrivenActionConfig  {
+
+    //TODO run logic and save finish callback and autocall it
+
+}
+
+module.exports = ComponentsStateDrivenActionConfig;

package/src/js/components/stateDriven/controller.js

@@ -1,50 +1,56 @@
 ComponentsBaseController = require('./../base/controller.js');
 
 class ComponentsStateDrivenController extends ComponentsBaseController {
-//TODO subscribe to N actions
-    constructor(options) {
-        super(options);
-        //todo set guard
-        this.eventBlank = 'components.example';
-
-        this._finished = this._finished.bind(this);
-        this._terminated = this._terminated.bind(this);
-    }
 
-    _setGuard() {
-        Urso.statesManager.setGuard(this.eventBlank, this._guard.bind(this));
-    }
+    configStates = {
+        /*IDLE: {
+            guard: () => { log(123, 'IDLE guard'); return true; }
+        }*/
+    };
 
-    _subscribeOnce() {
-        this._setGuard();
-        this.addListener(`${this.eventBlank}.onStart`, this._start.bind(this));
-        this.addListener(`${this.eventBlank}.onTerminate`, this._terminate.bind(this));
-    }
+    configActions = {
+        /*startSpin: {
+            guard: () => { log(123, 'guard'); return true; },
+            run: (finish) => { log(123, 'run'); finish(); },
+            terminate: () => { log(123, 'terminate'); }
+        }*/
+    };
 
-    _guard() {
-        return true; //or rewrite
+    _processStates() {
+        for (const stateKey in this.configStates) {
+            Urso.statesManager.setStateGuard(stateKey, this.configStates[stateKey].guard.bind(this));
+        }
     }
 
-    _start() {
-        Urso.logger.warn('ComponentsStateDrivenController warning: rewrite _start to make your logic', this);
-        this._finished();
-    }
+    _processActions() {
+        for (const actionKey in this.configActions) {
 
-    _finished() {
-        this.emit(`${this.eventBlank}.completed`);
-    }
+            //const actionCfg = this.getInstance('ActionConfig', this.configActions[actionKey]);
+            const actionCfg = this.configActions[actionKey];
+
+            if (actionCfg.run)
+                Urso.statesManager.addActionRun(actionKey, actionCfg.run.bind(this));
+            else {
+                Urso.logger.error('ComponentsStateDrivenController: no run function in config', actionKey, this);
+                continue;
+            }
 
-    _terminate() {
-        Urso.logger.warn('ComponentsStateDrivenController warning: rewrite _terminate to make your logic', this);
-        this._terminated();
+            if (actionCfg.terminate)
+                Urso.statesManager.addActionTerminate(actionKey, actionCfg.terminate.bind(this));
+
+            if (actionCfg.guard)
+                Urso.statesManager.addActionGuard(actionKey, actionCfg.guard.bind(this));
+        }
     }
 
-    _terminated() {
-        this.emit(`${this.eventBlank}.terminated`);
+    _subscribeOnce() {
+        this._processStates();
+        this._processActions();
     }
 
+    //todo
     destroy() {
-        Urso.statesManager.removeGuard(key, guard)
+        Urso.logger.error('ComponentsStateDrivenController will remove States and Actions by configs');
     }
 
 }

package/src/js/config/main.js

@@ -2,7 +2,8 @@ let ConfigMain = {
     title: 'Urso', //game title
     mode: "development", // development/production/testing
     extendingChain: ['Urso.Core'], //chain that will be set as Urso.Game
-    defaultScene: 'play' //default scene to display
+    defaultScene: 'play', //default scene to display
+    useBinPath: false 
 };
 
 module.exports = ConfigMain;

package/src/js/lib/loader.js

@@ -17,6 +17,26 @@ class LibLoader {
         this._assetsQuery.push(asset);
     }
 
+    /**
+     * gets part of loading path
+     */
+    _getLoadPath(asset){
+        const { path } = asset;
+
+        if(!Urso.config.useBinPath) {
+            return `assets/${path}`;
+        }
+
+        const quality = Urso.getInstance('Modules.Assets.Service').getQuality();
+        const splitted = path.split('/');
+
+        if (splitted[0] === 'images') {
+            splitted.splice(1, 0, quality);
+        }
+        
+        return `bin/${splitted.join('/')}`;
+    };
+
     /**
      * store loaded asset in cache
      */
@@ -79,7 +99,8 @@ class LibLoader {
             // TODO: check to load
 
             const params = asset.params || false; // TODO: Set params field in base mode
-            loader.add(asset.key, asset.path, params, (resource) => this._storeAsset(asset, resource))  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
+            const loadPath = this._getLoadPath(asset);
+            loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource))  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
         });
 
         this._onLoadUpdate({progress: 0});

package/src/js/modules/assets/config.js

@@ -2,6 +2,16 @@ class ModulesAssetsConfig {
     constructor() {
         this.singleton = true;
 
+        /**
+         * quality settings for resource loading selection
+         */
+        this.qualityFactors = {
+            medium: 0.5,
+            hd: 0.75,
+            high: 1 
+        };
+
+
         /**
          * initial is the default and will load on the preload
          * also you can call preload manualy by assets.loadGroup('groupName')
@@ -10,7 +20,7 @@ class ModulesAssetsConfig {
             initial: 0 //will load on the preload
             /*lazyPart1: 'lazyPart1',
             lazyPart2: 'lazyPart2'*/
-        }
+        };
 
         /**
          * you can make lazy load groups priority here

package/src/js/modules/assets/controller.js

@@ -3,6 +3,22 @@ class ModulesAssetsController {
         this.singleton = true;
     };
 
+    /**
+     * Update quality
+     */
+    updateQuality(){
+        if(Urso.config.useBinPath){
+            this.getInstance('Service').updateQuality();
+        }
+    }
+
+    /**
+     * Current quality getter
+     */
+    getQuality(){
+        this.getInstance('Service').getQuality();
+    }
+
     /**
      * instantly load initial assets and start lazy loading process, if needed
      * @param {Mixed} assets - asset or array of assets

package/src/js/modules/assets/service.js

@@ -1,12 +1,22 @@
 class ModulesAssetsService {
     constructor() {
         this.singleton = true;
-
+        
         this.assets = {};
 
+        this._currentQuality = 'auto';
         this._addedAssetsCache = [];
     };
 
+    getQuality(){
+        return this._currentQuality;
+    }
+
+    updateQuality(){
+        this._currentQuality = this._detectQuality();
+        Urso.addInstancesMode(this._currentQuality);
+    }
+
     sortAssets(assets) {
         this.assets[this.getInstance('Config').loadingGroups.initial] = [];
 
@@ -125,13 +135,9 @@ class ModulesAssetsService {
     }
 
     _processLoadedImage(assetModel) {
-        const { params, current } = this._getQualityParams();
-        let imageQualityKey = assetModel.useBinPath;
+        const { qualityFactors } = this.getInstance('Config');
 
-        if (imageQualityKey === true)
-            imageQualityKey = current;
-
-        let qualityTextureResolution = params[imageQualityKey] || 1;
+        const resolution = qualityFactors[this._currentQuality] || 1;
 
         const assetKey = assetModel.key;
         //textures cache
@@ -140,14 +146,14 @@ class ModulesAssetsService {
         if (!imageData) {
             //from atlas ?!
             let texture = Urso.cache.getFile(assetModel.path);
-
+            
             if (!texture)
                 return Urso.logger.error('ModulesAssetsService process Loaded Image error: no image ', assetModel);
 
             Urso.cache.addTexture(assetKey, texture); //TODO change resolution of base texture
         } else {
             //regular image
-            const baseTexture = new PIXI.BaseTexture(imageData.data, { resolution: qualityTextureResolution });
+            const baseTexture = new PIXI.BaseTexture(imageData.data, { resolution });
             const texture = new PIXI.Texture(baseTexture);
             Urso.cache.addTexture(assetKey, texture);
         }
@@ -215,9 +221,6 @@ class ModulesAssetsService {
         //set loadingGroup
         model.loadingGroup = loadingGroup || model.loadingGroup || this.getInstance('Config').loadingGroups.initial;
 
-        //setup path if its need
-        this._setQualityPath(model); //TODO adapt for dragonbones
-
         //check if container or dragonbones
         if (model.contents) {
             for (let content of model.contents) {
@@ -253,41 +256,65 @@ class ModulesAssetsService {
         this.loadGroup(groupName, () => { this._continueLazyLoad(step + 1); })
     }
 
-    // TODO: MOVE TO CFG OR HELPER?
-    _getQualityParams() {
-        const params = {
-            high: 1,
-            hd: 0.75,
-            medium: 0.5,
-            low: 0.25
-        }
-        const current = 'hd';
-        return { params, current };
+    _qualityReducer(qualityFactors, widthFactor){
+        return [(acc, val) => {
+            if (acc === null) {
+                return val;
+            }
+
+            const currentQuality = qualityFactors[acc];
+            const qualityFactor = qualityFactors[val];
+
+            const nextQuality = (currentQuality > qualityFactor && qualityFactor >= widthFactor)
+                || (qualityFactor >= widthFactor && widthFactor > currentQuality)
+                || (widthFactor >= qualityFactor && qualityFactor > currentQuality);
+            
+            return nextQuality ? val : acc;
+                
+        }, null]
     }
 
-    _setQualityPath(asset) {
-        if (!asset.useBinPath)
-            return;
+    _detectQuality(){
+        const { qualityFactors } = this.getInstance('Config');
+        const userQuality = Urso.helper.parseGetParams()['quality'];
+        
+        if(userQuality && qualityFactors[userQuality]){
+            return userQuality;
+        }
+        
+        return this._calculateQuality(qualityFactors);
+    }
 
-        const { params, current } = this._getQualityParams();
+    _calculateQuality(qualityFactors){
+        const { android, iOS, iPad, macOS } = Urso.device;
+        const isMobile = android || iOS || iPad;
 
-        const setQuality = asset => {
-            const qualityPath = (typeof asset.useBinPath === 'string' && params[asset.useBinPath]) ? asset.useBinPath : current;
-            asset.path = asset.path.replace('assets', `bin/${qualityPath}`);
+        if (macOS && !isMobile) {
+            return 'high';
         }
 
-        if (!asset.contents) {
-            setQuality(asset);
-            return;
+        if(macOS && iPad) {
+            return 'medium';
         }
 
-        for (const childAsset of asset.contents) {
-            const binPath = (childAsset.useBinPath && childAsset.useBinPath !== asset.useBinPath)
-                ? childAsset.useBinPath : asset.useBinPath;
+        const resCfg = Urso.getInstance('Modules.Scenes.ResolutionsConfig').contents[0];
+        
+        const { devicePixelRatio } = window;
+        let { width, height } = screen;
 
-            childAsset.useBinPath = binPath;
-            setQuality(childAsset);
+        if (isMobile) {
+            width = (width > height) ? width : height;
         }
+
+        if (iOS) {
+            width *= devicePixelRatio;
+        }
+
+        const widthFactor = width / resCfg.width;
+    
+        return Object
+            .keys(qualityFactors)
+            .reduce(...this._qualityReducer(qualityFactors, widthFactor));
     }
 
     _addAssetToLoader(assetModel, loader) {

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

@@ -4,7 +4,7 @@ class ModulesInstancesController {
         this._cache = {};
 
         this.getInstance = this.getInstance.bind(this);
-        this.getPath = this.getPath.bind(this);
+        this.getByPath = this.getByPath.bind(this);
         this._setComonFunctions = this._setComonFunctions.bind(this);
 
         this.getModes = this.getModes.bind(this);
@@ -12,12 +12,12 @@ class ModulesInstancesController {
         this.removeMode = this.removeMode.bind(this);
     }
 
-    getPath(path, noModes, modeName) {
+    getByPath(path, noModes, modeName) {
         let callback = (a) => {
             return a;
         };
 
-        return this._findClass({ path: path, callback: callback, noModes: noModes, modeName: modeName });
+        return this._findClass({ path, callback, noModes, modeName });
     }
 
     getModes() {
@@ -64,7 +64,7 @@ class ModulesInstancesController {
             return instance;
         };
 
-        return this._findClass({ path: path, callback: callback, noModes: noModes, modeName: modeName });
+        return this._findClass({ path, callback, noModes, modeName });
     }
 
     _setComonFunctions(classObject, path) {
@@ -147,7 +147,7 @@ class ModulesInstancesController {
             return this._cache[cacheKey] ? params.callback(this._cache[cacheKey]) : false;
 
         //no class in cache - we will find class by path
-        let classObject = this._getClassByPath(params.path);
+        let classObject = this._getClassByPath(params.path, params.noModes);
 
         if (!classObject)
             return false;
@@ -166,10 +166,10 @@ class ModulesInstancesController {
         return params.callback(this._cache[cacheKey]);
     }
 
-    _getClassByPath(path) {
+    _getClassByPath(path, noModes) {
         let pathArr = path.split('.');
         let entitiesArray = Urso.helper.mergeArrays(['Urso', 'Game'], pathArr);
-        return this._checkPathExist(entitiesArray);
+        return this._checkPathExist(entitiesArray, noModes);
     }
 
     /**
@@ -177,12 +177,12 @@ class ModulesInstancesController {
      * @param {Object} entitiesArray like ['Urso', 'Game', 'Lib', 'Helper']
      * @returns {mixed}
      */
-    _checkPathExist(entitiesArray) {
+    _checkPathExist(entitiesArray, noModes) {
         let currentTestObject = window;
         let testMode;
 
         for (let entitiesIndex = 0; entitiesIndex < entitiesArray.length; entitiesIndex++) {
-            if (this._modes && entitiesIndex === entitiesArray.length - 1)
+            if (!noModes && this._modes && entitiesIndex === entitiesArray.length - 1)
                 testMode = this._checkPathWithModes(currentTestObject, entitiesArray, entitiesIndex);
 
             if (testMode)

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

@@ -1,12 +1,12 @@
 Urso.Core.Modules.StatesManager = {
     Action: require('./action.js'),
-    ActionModel: require('./actionModel.js'),
     All: require('./all.js'),
-    ConfigActions: require('./configActions.js'),
     ConfigStates: require('./configStates.js'),
     Controller: require('./controller.js'),
+    FunctionsStorage: require('./functionsStorage.js'),
     Helper: require('./helper.js'),
     Race: require('./race.js'),
     Sequence: require('./sequence.js')
 };
+
 require('./actions/_info.js');

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(name) {
+        this.name = name;
 
-    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);
+        this._onFinish = this._onFinish.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;
+        return this.getInstance('Controller').checkActionGuard(this.name);
     }
 
     run(onFinishCallback) {
-        log(`%c action run ---> ${this.name}`, 'color: blue', this.options);
+        log(`%c action run ---> ${this.name}`, 'color: blue');
 
         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);
+        Urso.statesManager.runAction(this.name, this._onFinish);
 
         //TODO remove temp for debug
-        // let timeout = Math.floor(Math.random() * 2000);
-        // setTimeout(() => { this._onFinish(); }, timeout);
+        //let timeout = Math.floor(Math.random() * 2000);
+        //Urso.statesManager.runAction(this.name, () => setTimeout(() => { this._onFinish(); }, timeout));
     }
 
     terminate() {
-        if (!this.isTerminable() || this._terminating)
+        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;
-
-        if (this.options && Urso.helper.recursiveGet('options.terminateEvents.onStart', this, false))
-            this.emit(this.options.terminateEvents.onStart);
+        Urso.statesManager.terminateAction(this.name);
     }
 
     _onFinish() {
-        if (this.finished)
+        if (this.finished) {
+            Urso.logger.error('ModulesStatesManagerAction: action alredy finished', this.name);
             return;
+        }
 
-        this._removeListeners();
+        this._terminating = false;
         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;

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

@@ -19,15 +19,15 @@ class ModulesStatesManagerConfigStates {
             PICK_GAME1: {
                 sequence: [
                     { action: 'someAction' },
-                    { action: 'showPickGame' },        //showPickGame --> setGuardAction, setGuardState(PICK_GAME1)
+                    { action: 'showPickGame' },        //showPickGame --> addActionGuard(showPickGame, funk)
                     { action: 'showBIGWin' }
                 ],
-                nextState: ["PICK_GAME2", "PICK_GAME1", "IDLE"]
+                nextState: ["PICK_GAME2", "PICK_GAME1", "IDLE"]  //setGuardState(PICK_GAME2, func)
             },
 
             PICK_GAME2: {
                 sequence: [
-                    { action: 'showWheel' },          //showWheel --> setGuardAction, setGuardState(PICK_GAME2)
+                    { action: 'showWheel' },          //showWheel --> addActionGuard(showWheel, funk)
                     { action: 'showBIGWin' }
                 ],
                 nextState: ["PICK_GAME1", "IDLE"]
@@ -60,21 +60,6 @@ class ModulesStatesManagerConfigStates {
                 ]
             }
         };
-
-        // 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() {