@urso/core 0.7.80 → 0.7.82-dev

package/package.json

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

package/src/js/config/load.js

@@ -78,6 +78,7 @@ window.Urso = {
                     Html: require('../modules/assets/models/html'),
                     Image: require('../modules/assets/models/image'),
                     Json: require('../modules/assets/models/json'),
+                    JsonAtlas: require('../modules/assets/models/jsonAtlas'),
                     Sound: require('../modules/assets/models/sound'),
                     Spine: require('../modules/assets/models/spine')
                 }
@@ -100,8 +101,10 @@ window.Urso = {
             Objects: {
                 BaseModel: require('../modules/objects/baseModel'),
                 Cache: require('../modules/objects/cache'),
+                Config: require('../modules/objects/config'),
                 Controller: require('../modules/objects/controller'),
                 Find: require('../modules/objects/find'),
+                Pool: require('../modules/objects/pool'),
                 PropertyAdapter: require('../modules/objects/propertyAdapter'),
                 Proxy: require('../modules/objects/proxy'),
                 Selector: require('../modules/objects/selector'),

package/src/js/lib/cache.js

@@ -1,15 +1,16 @@
 class LibCache {
     constructor() {
         this.assetsList = {
-            image: {},
             atlas: {},
-            json: {},
             binary: {},
-            spine: {},
             bitmapFont: {},
+            file: {},
+            image: {},
+            json: {},
+            jsonAtlas: {},
             sound: {},
-            texture: {},
-            file: {}
+            spine: {},
+            texture: {}
         };
 
         this.globalAtlas = new PIXI.spine.TextureAtlas();
@@ -50,6 +51,10 @@ class LibCache {
         this._setDataToAssetsList('json', key, someData);
     };
 
+    addJsonAtlas(key, someData) {
+        this._setDataToAssetsList('jsonAtlas', key, someData);
+    };
+
     addSound(key, someData) {
         this._setDataToAssetsList('sound', key, someData);
     };
@@ -91,6 +96,14 @@ class LibCache {
         return this.assetsList.json[key];
     };
 
+    getJsonAtlas(key) {
+        return this.assetsList.jsonAtlas[key];
+    };
+
+    getJsonAtlases() {
+        return this.assetsList.jsonAtlas;
+    };
+
     getSound(key) {
         return this.assetsList.sound[key];
     };

package/src/js/lib/loader.js

@@ -120,11 +120,27 @@ class LibLoader {
 
             let params = asset.params || false; // TODO: Set params field in base mode
 
-            if (asset.type === Urso.types.assets.SPINE && asset.noAtlas) {
+            if (asset.type === Urso.types.assets.JSON) { // check json in JSONATLAS
+                const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
+
+                if (jsonData) {
+                    Urso.cache.addJson(asset.key, { data: jsonData });
+                    return;
+                }
+            }
+
+            if (asset.type === Urso.types.assets.SPINE && asset.noAtlas) { // check SPINE in JSONATLAS
                 if (!params)
                     params = {};
 
                 params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
+                //check for json in JSONATLAS
+                const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
+
+                if (jsonData) {
+                    this._loadSpineFromExistingResourses(asset, jsonData, params);
+                    return;
+                }
             }
 
             const loadPath = this._getLoadPath(asset);
@@ -146,6 +162,34 @@ class LibLoader {
         }.bind(this));
     };
 
+    _getJsonDataFromJsonAtlases(key) {
+        const jsonAtlases = Urso.cache.getJsonAtlases();
+
+        for (let i = 0; i < jsonAtlases.length; i++) {
+            if (jsonAtlases[i].data.hasOwnProperty(key)) {
+                return jsonAtlases[i].data[key];
+            }
+        }
+
+        return null;
+    }
+
+    _loadSpineFromExistingResourses(asset, jsonData, params) {
+        const rawSkeletonData = jsonData; //skeleton
+        const rawAtlasData = params.metadata.spineAtlas; //atlas file 
+
+        const spineAtlas = new PIXI.spine.core.TextureAtlas(rawAtlasData, function (line, callback) {
+            // pass the image here.
+            callback(PIXI.BaseTexture.fromImage(line));
+        }); // specify path, image.png will be added automatically
+
+        const spineAtlasLoader = new PIXI.spine.core.AtlasAttachmentLoader(spineAtlas)
+        const spineJsonParser = new PIXI.spine.core.SkeletonJson(spineAtlasLoader);
+
+        const spineData = spineJsonParser.readSkeletonData(rawSkeletonData);
+        Urso.cache.addSpine(asset.key, spineData);
+    }
+
     _onError(error) {
         Urso.logger.warn('LibLoader file load error: ', error);
 

package/src/js/modules/assets/models/jsonAtlas.js

@@ -0,0 +1,11 @@
+const ModulesAssetsBaseModel = require('./../baseModel');
+
+class ModulesAssetsModelsJsonAtlas extends ModulesAssetsBaseModel {
+    constructor(params) {
+        super(params);
+
+        this.type = Urso.types.assets.JSON;
+    }
+}
+
+module.exports = ModulesAssetsModelsJsonAtlas;

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

@@ -366,6 +366,9 @@ class ModulesAssetsService {
             case Urso.types.assets.JSON:
                 model = this.getInstance('Models.Json', asset)
                 break;
+            case Urso.types.assets.JSONATLAS:
+                model = this.getInstance('Models.JsonAtlas', asset)
+                break;
             case Urso.types.assets.SOUND:
                 model = this.getInstance('Models.Sound', asset)
                 break;

package/src/js/modules/objects/config.js

@@ -0,0 +1,10 @@
+class ModulesObjectsConfig {
+
+    constructor() {
+        this.singleton = true;
+        this.objectsToCache = []; //arrow of types. as example [Urso.types.objects.IMAGE, Urso.types.objects.SPINE]
+    };
+
+}
+
+module.exports = ModulesObjectsConfig;

package/src/js/modules/objects/pool.js

@@ -0,0 +1,68 @@
+class ModulesObjectsPool {
+
+    _objectsCache = {};
+    _objectsCounter = 0;
+
+    constructor() {
+        this.singleton = true;
+
+        this._objectsPool = new Urso.Game.Lib.ObjectPool(
+            this._constructorFunction.bind(this),
+            this._resetFunction.bind(this)
+        );
+    };
+
+    getElement(object, parent) {
+        const poolElement = this._objectsPool.getElement(object.assetKey, { object, parent });
+        this._objectsCounter++;
+        this._objectsCache[this._objectsCounter] = poolElement;
+
+
+        const newObject = poolElement.data;
+        newObject._poolCacheId = this._objectsCounter;
+
+        if (typeof object.x === 'number') newObject.x = object.x; else newObject.x = 0;
+        if (typeof object.y === 'number') newObject.y = object.y; else newObject.y = 0;
+        if (typeof object.angle === 'number') newObject.angle = object.angle; else newObject.angle = 0;
+        if (typeof object.anchorX === 'number') newObject.anchorX = object.anchorX; else newObject.anchorX = 0;
+        if (typeof object.anchorY === 'number') newObject.anchorY = object.anchorY; else newObject.anchorY = 0;
+        if (typeof object.visible === 'boolean') newObject.visible = object.visible; else newObject.visible = true;
+
+        if (object?.type === Urso.types.objects.SPINE)
+            newObject.setAnimationConfig(object.animation); //setup oncomplete
+
+        this.getInstance('Service').addChild(parent, newObject, true);
+        return newObject;
+    }
+
+    putElement(object, doNotRefreshStylesFlag) {
+        if (object._poolCacheId) {
+            this._objectsPool.putElement(this._objectsCache[object._poolCacheId]);
+            delete this._objectsCache[object._poolCacheId];
+            return;
+        }
+
+        console.error('ModulesObjectsPool something goes wrong: object must be in pool');
+    }
+
+    _constructorFunction(_, { object, parent }) {
+        return this.getInstance('Service').add(object, parent, true);
+    }
+
+    _resetFunction(object) {
+        if (object.parent)
+            this.getInstance('Service').removeChild(object.parent, object, true);
+
+        if (object?.type === Urso.types.objects.SPINE) {
+            object.setToSetupPose();
+            object.stop();
+            object.clearListeners();
+            object._baseObject.lastTime = null;
+        }
+
+        return object;
+    }
+
+}
+
+module.exports = ModulesObjectsPool;

package/src/js/modules/objects/service.js

@@ -62,7 +62,12 @@ class ModulesObjectsService {
         return this._world;
     }
 
-    add(object, parent) {
+    add(object, parent, _ignorePool = false) {
+        const { objectsToCache } = this.getInstance('Config');
+
+        if (!_ignorePool && objectsToCache.includes(object.type))
+            return this.getInstance('Pool').getElement(object, parent);
+
         const world = this._checkWorld();
 
         if (!parent)
@@ -94,7 +99,7 @@ class ModulesObjectsService {
                 break;
             case Urso.types.objects.EMITTERFX:
                 model = this.getInstance('Models.EmitterFx', object);
-                break;  
+                break;
             case Urso.types.objects.HITAREA:
                 model = this.getInstance('Models.HitArea', object);
                 break;
@@ -181,6 +186,11 @@ class ModulesObjectsService {
     }
 
     destroy(object, doNotRefreshStylesFlag) {
+        const { objectsToCache } = this.getInstance('Config');
+
+        if (objectsToCache.includes(object.type))
+            return this.getInstance('Pool').putElement(object, doNotRefreshStylesFlag);
+
         if (object.parent)
             this.removeChild(object.parent, object, true);
 
@@ -191,7 +201,7 @@ class ModulesObjectsService {
                 this.destroy(object.contents[0], true);
 
         object._customDestroy();
-        object._baseObject && object._baseObject.destroy({children: true});
+        object._baseObject && object._baseObject.destroy({ children: true });
         this._removeFromCache(object);
         this.getInstance('Styles').removeFromCache(object);
 

package/src/js/modules/template/types.js

@@ -9,8 +9,9 @@ class ModulesTemplateTypes {
                 FONT: 5,
                 IMAGE: 6,
                 JSON: 7,
-                SOUND: 8,
-                SPINE: 9,
+                JSONATLAS: 8,
+                SOUND: 9,
+                SPINE: 10,
                 HTML: 100
             },