@urso/core 0.5.13 → 0.6.1

package/package.json

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

package/src/js/app.js

@@ -1,4 +1,5 @@
 class App {
+
     constructor() {
         this.version = 'APP_VERSION';
 

package/src/js/lib/helper.js

@@ -247,6 +247,23 @@ class LibHelper {
         return newObj;
     }
 
+    /**
+     * rename objects key
+     * @param {Object} obj
+     * @param {String} oldKey
+     * @param {String} newKey
+     */
+    renameObjectsKey(obj, oldKey, newKey) {
+        if (oldKey !== newKey) {
+            Object.defineProperty(
+                obj, newKey,
+                Object.getOwnPropertyDescriptor(obj, oldKey)
+            );
+
+            delete obj[oldKey];
+        }
+    }
+
     /**
      * clone object
      * @param {Object} obj 

package/src/js/lib/objectPool.js

@@ -1,31 +1,64 @@
 class ObjectPoolMember {
+
     free = true;
+    putCacheTimeKey = 0;
+    key = null; //element branch;
+    branchKey = 0; //element branch key
     data = null;
 
-    constructor(data) {
-        this.data = data
+    constructor(data, key, branchKey) {
+        this.data = data;
+        this.key = key;
+        this.branchKey = branchKey;
     }
 }
 
+
+/**
+ * @param {Function} constructorFunction - function to constract element
+ * @param {Function} constructorFunction - function to reset element when put back to pool
+ * @param {Number} [initialSize] - initial pool size. Use only if you not using keys when constract
+ * @param {Number} [maxSize] - max pool size. Old elements will be removed from pool
+ */
 class LibObjectPool {
-    pool = {};
-    resetFunction = () => { }
-    constructorFunction = () => { }
 
-    constructor(constructorFunction, resetFunction = (obj) => obj, initialSize = 0) { //todo initialSize
+    _pool = {};
+    resetFunction = () => { };
+    constructorFunction = () => { };
+    _maxSize = 0;
+
+    _lastBranchKeys = {};
+    _putTimeCache = {};
+
+    constructor(constructorFunction, resetFunction = (obj) => obj, initialSize = 0, maxSize = 0) {
         this.resetFunction = resetFunction;
         this.constructorFunction = constructorFunction;
+        this._maxSize = maxSize;
+
+        this._createInitial(initialSize);
     }
 
+    /**
+     * get element from pool
+     * @param {String | Number} key - element key to get
+     * @param {mixed} [additionalCreateArguments] - additional create Arguments
+     * @returns {ObjectPoolMember}
+     */
     getElement(key = 'default', additionalCreateArguments) {
         this._checkPoolKey(key);
-        const poolArray = this.pool[key];
+        const poolBranch = this._pool[key];
 
+        for (const poolObject of Object.values(poolBranch)) {
+            if (poolObject.free) {
+                poolObject.free = false;
 
-        for (let i = 0; i < poolArray.length; i++) {
-            if (poolArray[i].free) {
-                poolArray[i].free = false;
-                return poolArray[i];
+                //remove from putTimeCache
+                if (poolObject.putCacheTimeKey) {
+                    delete this._putTimeCache[poolObject.putCacheTimeKey];
+                    poolObject.putCacheTimeKey = 0;
+                }
+
+                return poolObject;
             }
         }
 
@@ -34,21 +67,137 @@ class LibObjectPool {
         return newObj;
     }
 
+    /**
+     * put element back to pool (resetFunction will call)
+     * @param {ObjectPoolMember} element
+     */
     putElement(element) {
         element.free = true;
         this.resetFunction(element.data);
+
+        if (this._maxSize) {
+            //lets write put time cache
+            const putCacheTimeKey = this._getElementBranchKey('_putTimeCache', this._putTimeCache);
+            this._putTimeCache[putCacheTimeKey] = element;
+            element.putCacheTimeKey = putCacheTimeKey;
+        }
+
+        this._checkMaxSize();
+    }
+
+    /**
+     * check max pool size
+     */
+    _checkMaxSize() {
+        if (!this._maxSize)
+            return;
+
+        //remove oldest inactive element
+        const poolSize = this._getPoolSize();
+
+        if (poolSize > this._maxSize) {
+            this._removeOldestInactiveElement();
+        }
+
+    }
+
+    /**
+     * remove oldest inactive element
+     */
+    _removeOldestInactiveElement() {
+        const keyToRemove = Object.keys(this._putTimeCache)[0];
+        const element = this._putTimeCache[keyToRemove];
+
+        //remove from pool
+        delete this._pool[element.key][element.branchKey];
+
+        //reset element
+        element.free = false;
+        element.putCacheTimeKey = 0;
+        element.key = null;
+        element.branchKey = 0;
+        element.data = null;
+
+        //remove from putTimeCache
+        delete this._putTimeCache[keyToRemove];
+    }
+
+    /**
+     * pool size (all branches)
+     */
+    _getPoolSize() {
+        let size = 0;
+
+        for (const branch of Object.values(this._pool)) {
+            size += Object.keys(branch).length;
+        }
+
+        return size;
     }
 
+    /**
+     * create new element for pool
+     * @param {String | Number} key - element key to create
+     * @param {mixed} [additionalCreateArguments] - additional create Arguments
+     * @returns {ObjectPoolMember}
+     */
     _createElement(key, additionalCreateArguments = null) {
         const newObj = this.resetFunction(this.constructorFunction(key, additionalCreateArguments));
-        const poolMember = new ObjectPoolMember(newObj);
-        this.pool[key].push(poolMember);
+        const branchKey = this._getElementBranchKey(key, this._pool[key]);
+        const poolMember = new ObjectPoolMember(newObj, key, branchKey);
+        this._pool[key][branchKey] = poolMember;
         return poolMember;
     }
 
+    /**
+     * get element branch key
+     * @param {String | Number} key - element key to get
+     * @returns {Nymber}
+     */
+    _getElementBranchKey(key, poolBranch) {
+        let branchKey = Urso.time.get();
+
+        //prevent duplicates
+        if (poolBranch[branchKey]) {
+            branchKey = this._lastBranchKeys[key] + 1;
+        }
+
+        this._lastBranchKeys[key] = branchKey;
+        return branchKey;
+    }
+
+    /**
+     * create initial pool objects
+     * @param {Number} initialSize
+     */
+    _createInitial(initialSize) {
+        if (!initialSize)
+            return;
+
+        let newObjectsArray = [];
+
+        for (let index = 0; index < initialSize; index++) {
+            newObjectsArray.push(this.getElement());
+        }
+
+        newObjectsArray.forEach(newObject => { this.putElement(newObject); });
+    }
+
+    /**
+     * check exist key namespace
+     * @param {String | Number} key - element key
+     */
     _checkPoolKey(key) {
-        if (!this.pool[key])
-            this.pool[key] = [];
+        if (!this._pool[key])
+            this._pool[key] = {};
+    }
+
+    /**
+     * debug get pool data
+     * @returns {Array}
+     */
+    _debugGetPoolData() {
+        return this._pool;
     }
 }
 

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

@@ -1,4 +1,5 @@
 class ModulesAssetsModelsImage extends Urso.Core.Modules.Assets.BaseModel {
+
     constructor(params) {
         super(params);
         this.type = Urso.types.assets.IMAGE;
@@ -11,4 +12,4 @@ class ModulesAssetsModelsImage extends Urso.Core.Modules.Assets.BaseModel {
     }
 }
 
-module.exports = ModulesAssetsModelsImage;
+module.exports = ModulesAssetsModelsImage;

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

@@ -1,4 +1,5 @@
 class ModulesAssetsService {
+
     constructor() {
         this.singleton = true;
 

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

@@ -5,6 +5,7 @@ class ModulesInstancesController {
     constructor() {
         this._modes = [];
         this._cache = {};
+        this._counter = 0;
 
         this.getInstance = this.getInstance.bind(this);
         this.getByPath = this.getByPath.bind(this);
@@ -73,6 +74,8 @@ class ModulesInstancesController {
             if (instance.singleton)
                 classObject._instance = instance;
 
+            instance._iuid = this._getUid();
+
             this._launchDefaultFunctions(instance);
 
             return instance;
@@ -81,6 +84,11 @@ class ModulesInstancesController {
         return this._findClass({ path, callback, noModes, modeName });
     }
 
+    _getUid() {
+        this._counter++;
+        return 'instance' + this._counter;
+    }
+
     _setComonFunctions(classObject, path) {
         classObject.prototype.getInstance = this._entityGetInstance(path);
         classObject.prototype.addListener = this._entityAddListener;
@@ -133,7 +141,8 @@ class ModulesInstancesController {
         if (!callerObject.__entities)
             callerObject.__entities = [];
 
-        callerObject.__entities.push(classObject);
+        if (!callerObject.__entities.includes(classObject))
+            callerObject.__entities.push(classObject);
     }
 
     _entityAddListener() {

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

@@ -1,4 +1,5 @@
 class ModulesObjectsModelsComponent extends Urso.Core.Modules.Objects.BaseModel {
+
     constructor(params) {
         super(params);
 
@@ -42,4 +43,4 @@ class ModulesObjectsModelsComponent extends Urso.Core.Modules.Objects.BaseModel
     }
 }
 
-module.exports = ModulesObjectsModelsComponent;
+module.exports = ModulesObjectsModelsComponent;

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

@@ -191,7 +191,7 @@ class ModulesObjectsService {
                 this.destroy(object.contents[0], true);
 
         object._customDestroy();
-        object._baseObject && object._baseObject.destroy();
+        object._baseObject && object._baseObject.destroy({children: true});
         this._removeFromCache(object);
         this.getInstance('Styles').removeFromCache(object);