@urso/core 0.4.0 → 0.4.4

package/package.json

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

package/src/js/app.js

@@ -44,6 +44,7 @@ class App {
 
         //Modules
         Urso.assets = Urso.getInstance('Modules.Assets.Controller');
+        Urso.i18n = Urso.getInstance('Modules.I18n.Controller');
         Urso.transport = Urso.getInstance('Modules.Transport.Controller');
         Urso.logic = Urso.getInstance('Modules.Logic.Controller');
         Urso.objects = Urso.getInstance('Modules.Objects.Controller');

package/src/js/modules/_info.js

@@ -1,5 +1,6 @@
 Urso.Core.Modules = {};
 require('./assets/_info.js');
+require('./i18n/_info.js');
 require('./instances/_info.js');
 require('./logic/_info.js');
 require('./objects/_info.js');

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

@@ -38,7 +38,7 @@ class ModulesAssetsService {
         Urso.scenes.loadUpdate(Math.floor(param.progress));
     }
 
-    loadGroup(group, callback) {
+    loadGroup(group, callback = () => { }) {
         if (!this.assets[group])
             return Urso.logger.error('ModulesAssetsService group error, no assets:' + group + ' Check ModulesAssetsConfig please');
 

package/src/js/modules/i18n/_info.js

@@ -0,0 +1,4 @@
+Urso.Core.Modules.I18n = {
+    Config: require('./config.js'),
+    Controller: require('./controller.js')
+};

package/src/js/modules/i18n/config.js

@@ -0,0 +1,17 @@
+class ModulesI18nConfig {
+    constructor() {
+        this.singleton = true;
+
+        /**
+         * example of locales. Set please your keys and paths
+         */
+        this.locales = {
+            'de': 'i18n/de.json',
+            'en': 'i18n/en.json',
+            'ru': 'i18n/ru.json'
+        }
+    }
+};
+
+module.exports = ModulesI18nConfig;
+

package/src/js/modules/i18n/controller.js

@@ -0,0 +1,75 @@
+class ModulesI18nController {
+
+    #vocabulary = null;
+
+    /**
+     * get text by localeId
+     * @param {String} localeId 
+     * @param {Object} [localeVariables] - variables for locale string
+     */
+    get(localeId, localeVariables = {}) {
+        if (this.#vocabulary && this.#vocabulary[localeId]) {
+            return this._interpolate(this.#vocabulary[localeId], localeVariables);
+        }
+
+        return localeId;
+    }
+
+    /**
+     * set alredy loaded as asset locale
+     * @param {String} localeKey - loaded json asset key with locale
+     */
+    setLocale(localeKey) {
+        const jsonResource = Urso.cache.getJson(localeKey);
+
+        if (!jsonResource)
+            return Urso.logger.error('ModulesI18nController setLocale error, no loaded json:' + localeKey + '. Check assets please');
+
+        this.#vocabulary = jsonResource.data;
+        this.emit(Urso.events.MODULES_I18N_NEW_LOCALE_WAS_SET, localeKey);
+    }
+
+    /**
+     * load json with locale, store as asset witn localeKey as key and set locale
+     * @param {String} localeKey 
+     * @param {String} [pathToLocaleJson] if this param will not used - we will check localeKey in config
+     */
+    loadAndSetLocale(localeKey, pathToLocaleJson) {
+        //check if localeKey was alredy loaded
+        const jsonResource = Urso.cache.getJson(localeKey);
+
+        if (jsonResource) {
+            this.setLocale(localeKey);
+        }
+
+        //load locale by path
+        if (pathToLocaleJson) {
+            this._loadLocaleByPath(localeKey, pathToLocaleJson);
+        } else { //we will check localeKey in config
+            this._loadLocaleByConfig(localeKey);
+        }
+    }
+
+    _loadLocaleByConfig(localeKey) {
+        const locales = this.getInstance('Config').locales;
+        const pathToLocaleJson = locales[localeKey];
+
+        if (!pathToLocaleJson)
+            return Urso.logger.error('ModulesI18nController _loadLocaleByConfig error, no locale data in config:' + localeKey + '. Check ModulesI18nConfig please');
+
+        this._loadLocaleByPath(localeKey, pathToLocaleJson);
+    }
+
+    _loadLocaleByPath(localeKey, pathToLocaleJson) {
+        const localeAsset = { type: Urso.types.assets.JSON, key: localeKey, path: pathToLocaleJson };
+        Urso.assets.preload(localeAsset, () => this.setLocale(localeKey));
+    }
+
+    _interpolate(string, params) {
+        const names = Object.keys(params);
+        const vals = Object.values(params);
+        return new Function(...names, `return \`${string}\`;`)(...vals);
+    }
+}
+
+module.exports = ModulesI18nController;

package/src/js/modules/objects/baseModel.js

@@ -15,6 +15,10 @@ class ModulesObjectsBaseModel {
         this._parsed = false;
     }
 
+    /**
+     * setup params to object model
+     * @param {Object} params
+     */
     setupParams(params) {
         this.type = Urso.helper.recursiveGet('type', params, null);
 

package/src/js/modules/objects/models/bitmapText.js

@@ -10,6 +10,10 @@ class ModulesObjectsModelsBitmapText extends Urso.Core.Modules.Objects.BaseModel
         super.setupParams(params);
 
         this.text = Urso.helper.recursiveGet('text', params, false);
+        this.localeId = Urso.helper.recursiveGet('localeId', params, false); //you can use this instead text for localization
+
+        this.localeVariables = Urso.helper.recursiveGet('localeVariables', params, {}); //optional variables for localization by localeId
+
         this.fontName = Urso.helper.recursiveGet('fontName', params, false);
         this.fontSize = Urso.helper.recursiveGet('fontSize', params, false);
 
@@ -17,8 +21,20 @@ class ModulesObjectsModelsBitmapText extends Urso.Core.Modules.Objects.BaseModel
     }
 
     _addBaseObject() {
+        if (this.localeId)
+            this._originalModel.text = this.text = Urso.i18n.get(this.localeId, this.localeVariables);
+
         this._baseObject = new PIXI.BitmapText(this.text, { fontName: this.fontName, fontSize: this.fontSize });
     };
+
+    _newLocaleHandler() {
+        this.text = this._baseObject.text = Urso.i18n.get(this.localeId, this.localeVariables);
+    }
+
+    _subscribeOnce() {
+        if (this.localeId)
+            this.addListener(Urso.events.MODULES_I18N_NEW_LOCALE_WAS_SET, this._newLocaleHandler.bind(this));
+    }
 }
 
 module.exports = ModulesObjectsModelsBitmapText;

package/src/js/modules/objects/models/spine.js

@@ -6,6 +6,10 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
         this._addBaseObject();
     }
 
+    /**
+     * setup params to object model
+     * @param {Object} params
+     */
     setupParams(params) {
         super.setupParams(params);
 
@@ -21,27 +25,98 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
         params.animation = this.animation; //we redefine original property here
     }
 
+    /**
+     * play spine animation
+     * @param {String} animationName
+     * @param {Boolean} [loopFlag]
+     * @param {Number} [track] - you can define track number for current animation
+     */
     play(animationName, loopFlag = false, track = 0) {
         this._baseObject.state.setAnimation(track, animationName, loopFlag);
     }
 
-    addToSlot(object, slotName) {
-        const spine = this._baseObject;
-        const slotIndex = spine.spineData.slots.findIndex(({ name }) => name === slotName);
-        const currentSlot = spine.slotContainers[slotIndex];
+    /**
+     * play spine animation and execute function after animation completes
+     * @param {String} animation - name of the animation to be played
+     * @param {Function} func - function to be executed
+     */
+    playAndThen(animation, func) {
+        this.playInSequenceAndThen([animation], func);
+    }
 
-        if (currentSlot) {
-            object._baseObject.scale.y = -1;
+    /**
+     * play spine animations in sequence
+     * @param {String[]} animations - names of the animations to be played
+     */
+    playInSequence(animations) {
+        this.stop();
+        const defaultTrack = 0;
+        animations.forEach(e => this._baseObject.state.addAnimation(defaultTrack, e));
+    }
 
-            Urso.objects.removeChild(object.parent, object)
-            currentSlot.addChild(object._baseObject);
-        } else {
-            Urso.logger.warn('ModulesObjectsModelsSpine addToSlot error: no spine slot ' + slotName);
-        }
+    /**
+     * play spine animations in sequence and execute function after last animation completes
+     * @param {String[]} animations - names of the animations to be played
+     * @param {Function} func - function to be executed
+     */
+    playInSequenceAndThen(animations, func) {
+        let animationsLeft = animations.length;
+        let removeSelf = () => { };
+        let completer = {
+            complete: () => {
+                if (--animationsLeft === 0) {
+                    func();
+                    removeSelf();
+                }
+            }
+        };
+        removeSelf = () => this._baseObject.state.removeListener(completer);
+        this._baseObject.state.addListener(completer);
+        this.playInSequence(animations);
     }
 
     /**
-     *
+     * stop track animation
+     * @param {Number} [track] - you can define track number to stop
+     */
+    stopTrack(track) {
+        this._baseObject.state.clearTrack(track);
+    }
+
+    /**
+     * stop all animations
+     */
+    stop() {
+        this._baseObject.state.clearTracks();
+    }
+
+    /**
+     * reset all animations
+     */
+    reset() {
+        this._baseObject.state.setEmptyAnimations();
+    }
+
+    /**
+     * add object to spine slot
+     * @param {String} slotName
+     * @param {Object} object - created by engine object
+     */
+    addToSlot(slotName, object) {
+        this._addToSlot(slotName, object, false);
+    }
+
+    /**
+     * replace spine slot with new object
+     * @param {String} slotName
+     * @param {Object} object - created by engine object
+     */
+    replaceSlotWith(slotName, object) {
+        this._addToSlot(slotName, object, true);
+    }
+
+    /**
+     * set/update animation config
      * @param {*} config
      * @param {boolean} [noObjectCreate] dont use this flag out of core
      *
@@ -59,11 +134,18 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             this._baseObject.state.timeScale = config.timeScale;*/ //deprecated - now we use getTimeScale getter
 
         if (config.onComplete) {
+            if (this._baseObject.state.listeners.length !== 0) {
+                Urso.logger.warn('ModulesObjectsModelsSpine setAnimationConfig warning: animation state listeners will be cleared');
+            }
             this._baseObject.state.clearListeners();
             this._baseObject.state.addListener({ complete: this.animation.onComplete });
         }
     }
 
+    /**
+     * system function
+     * add object to pixi tree
+     */
     _addBaseObject() {
         let spineAsset = Urso.cache.getSpine(this.assetKey);
 
@@ -81,6 +163,30 @@ class ModulesObjectsModelsSpine extends Urso.Core.Modules.Objects.BaseModel {
             this.play(this.animation.name, this.animation.loop);
     };
 
+    _addToSlot(slotName, object, replaceSlotContents) {
+        const spine = this._baseObject;
+        const slotIndex = spine.spineData.slots.findIndex(({ name }) => name === slotName);
+        const currentSlot = spine.slotContainers[slotIndex];
+
+        if (currentSlot) {
+            object._baseObject.scale.y = -1;
+
+            Urso.objects.removeChild(object.parent, object);
+
+            if (replaceSlotContents)
+                currentSlot.removeChildren(); //todo check if its proxy and reset parent
+
+            //object.parent = this; //todo && make removeChild
+            currentSlot.addChild(object._baseObject);
+        } else {
+            Urso.logger.warn('ModulesObjectsModelsSpine _addToSlot error: no spine slot ' + slotName);
+        }
+    }
+
+    /**
+     * get animation timeScale
+     * @returns Number
+     */
     getTimeScale() {
         return Urso.scenes.timeScale * this.animation.timeScale;
     }

package/src/js/modules/objects/models/text.js

@@ -10,6 +10,9 @@ class ModulesObjectsModelsText extends Urso.Core.Modules.Objects.BaseModel {
         super.setupParams(params);
 
         this.text = Urso.helper.recursiveGet('text', params, false);
+        this.localeId = Urso.helper.recursiveGet('localeId', params, false); //you can use this instead text for localization
+
+        this.localeVariables = Urso.helper.recursiveGet('localeVariables', params, {}); //optional variables for localization by localeId
 
         this.lineHeight = Urso.helper.recursiveGet('lineHeight', params, 0);
         this.fontFamily = Urso.helper.recursiveGet('fontFamily', params, 'Arial');
@@ -31,8 +34,20 @@ class ModulesObjectsModelsText extends Urso.Core.Modules.Objects.BaseModel {
     }
 
     _addBaseObject() {
+        if (this.localeId)
+            this._originalModel.text = this.text = Urso.i18n.get(this.localeId, this.localeVariables);
+
         this._baseObject = new PIXI.Text(this.text);
     };
+
+    _newLocaleHandler() {
+        this.text = this._baseObject.text = Urso.i18n.get(this.localeId, this.localeVariables);
+    }
+
+    _subscribeOnce() {
+        if (this.localeId)
+            this.addListener(Urso.events.MODULES_I18N_NEW_LOCALE_WAS_SET, this._newLocaleHandler.bind(this));
+    }
 }
 
 module.exports = ModulesObjectsModelsText;

package/src/js/modules/observer/events.js

@@ -6,6 +6,7 @@ class ModulesObserverConfig {
             MODULES_ASSETS_GROUP_LOADED: 'modules.assets.group.loaded',
             MODULES_ASSETS_LOAD_PROGRESS: 'modules.assets.load.progress',
             MODULES_ASSETS_LAZYLOAD_FINISHED: 'modules.assets.lazyLoad.finished',
+            MODULES_I18N_NEW_LOCALE_WAS_SET: 'modules.i18n.new.locale.was.set',
             MODULES_INSTANCES_MODES_CHANGED: 'modules.instances.modes.changed',
             MODULES_OBJECTS_BUTTON_PRESS: 'modules.objects.button.press',
             MODULES_OBJECTS_HIT_AREA_PRESS: 'modules.objects.hitArea.press',