@makefully/platypus 4.1.8 → 4.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@makefully/platypus",
-    "version": "4.1.8",
+    "version": "4.1.10",
     "description": "2D tile-based HTML5 game engine with a component-based entity model",
     "license": "MIT",
     "contributors": [

package/src/AssetManager.js

@@ -26,6 +26,9 @@ const
             'src', path,
             'data', asset.data ?? null
         );
+    },
+    isRegisteredWithPixi = function (alias, src) {
+        return Assets.resolver.hasKey(alias) || (src && src !== alias && Assets.resolver.hasKey(src));
     };
 
 export default class AssetManager {
@@ -71,7 +74,18 @@ export default class AssetManager {
      * @return {Object} Returns the asset if defined.
      */
     get (alias) {
-        return this.assets.get(alias);
+        if (this.assets.has(alias)) {
+            return this.assets.get(alias);
+        }
+
+        const
+            fileId = this.getFileId(alias);
+
+        if (fileId !== alias && this.assets.has(fileId)) {
+            return this.assets.get(fileId);
+        }
+
+        return undefined;
     }
 
     /**
@@ -131,6 +145,7 @@ export default class AssetManager {
         const
             counts = this.counts,
             needsLoading = arrayCache.setUp(),
+            needsRelink = arrayCache.setUp(),
             adds = Data.setUp();
 
         if (platypus.game?.options?.images ?? platypus.game?.options?.audio) {
@@ -154,13 +169,39 @@ export default class AssetManager {
                 adds[alias] += 1;
             } else {
                 adds[alias] = 1;
+                if (isRegisteredWithPixi(alias, item.src)) {
+                    needsRelink.push(item);
+                } else {
+                    needsLoading.push(item);
+                }
+            }
+        }
+
+        for (let i = needsRelink.length - 1; i >= 0; i--) {
+            const
+                item = needsRelink[i],
+                alias = item.alias[0],
+                asset = Assets.get(alias) ?? Assets.get(item.src);
+
+            if (asset) {
+                this.set(alias, asset, adds[alias]);
+                needsRelink.splice(i, 1);
+            } else {
                 needsLoading.push(item);
+                needsRelink.splice(i, 1);
             }
         }
 
         if (needsLoading.length) {
             // Do this first to pass `data` property if needed
-            needsLoading.forEach((asset) => Assets.add(asset));
+            needsLoading.forEach((asset) => {
+                const
+                    alias = asset.alias[0];
+
+                if (!isRegisteredWithPixi(alias, asset.src)) {
+                    Assets.add(asset);
+                }
+            });
 
             const
                 aliases = needsLoading.map((asset) => asset.alias[0]),
@@ -188,6 +229,7 @@ export default class AssetManager {
         }
 
         arrayCache.recycle(needsLoading);
+        arrayCache.recycle(needsRelink);
     }
 
     /**

package/src/VOPlayer.js

@@ -662,7 +662,7 @@ class VOPlayer extends Messenger {
      * @public
      */
     unloadSound (sound) {
-        this.assetCache.delete(sound);
+        this.assetCache.delete(this.assetCache.getFileId(sound));
     }
 
     /**

package/src/components/LevelBuilder.js

@@ -1,5 +1,6 @@
 /* global atob, platypus */
 import {arrayCache, greenSlice, greenSplice, union} from '../utils/array.js';
+import {cloneDefinition} from '../utils/clone.js';
 import createComponentClass from '../factory.js';
 import {inflate} from 'pako';
 import TiledLoader from './TiledLoader.js';
@@ -31,6 +32,21 @@ const
         }
         return layer;
     },
+    cloneLevelDefinition = cloneDefinition,
+    copySegmentProperty = function (target, source, key) {
+        if (target[key]) {
+            return;
+        }
+
+        const
+            value = source[key];
+
+        if (value != null && typeof value === 'object') {
+            target[key] = cloneDefinition(value);
+        } else {
+            target[key] = value;
+        }
+    },
     mergeData = function (levelData, levelMergeAxisLength, segmentData, segmentMergeAxisLength, nonMergeAxisLength, mergeAxis) {
         const
             combined = greenSlice(levelData);
@@ -54,9 +70,7 @@ const
 
         for (let i = 0; i < obj2s.length; i++) {
             const
-                obj = {
-                    ...obj2s[i]
-                };
+                obj = cloneLevelDefinition(obj2s[i]);
 
             if (mergeAxis === 'horizontal') {
                 obj.x += mergeAxisLength;
@@ -68,6 +82,8 @@ const
         return list;
     },
     mergeSegment  = function (level, segment, mergeAxis) {
+        segment = cloneLevelDefinition(segment);
+
         if (!level.tilewidth && !level.tileheight) {
             //set level tile size data if it's not already set.
             level.tilewidth  = segment.tilewidth;
@@ -96,9 +112,7 @@ const
                 decodeLayer(segment.layers[i]);
                 
                 const
-                    layer = level.layers[i] = {
-                        ...segment.layers[i]
-                    };
+                    layer = level.layers[i] = cloneLevelDefinition(segment.layers[i]);
 
                 // If we're adding objects, make sure that they're offset correctly.
                 if (layer.objects) {
@@ -149,9 +163,7 @@ const
                 const
                     key = keys[i];
 
-                if (!level[key]) {
-                    level[key] = segment[key];
-                }
+                copySegmentProperty(level, segment, key);
             }
         }
     },
@@ -200,6 +212,8 @@ const
         return level;
     },
     mirrorSegment = function (segment) {
+        segment = cloneLevelDefinition(segment);
+
         const
             newSegment = {
                 layers: []
@@ -211,9 +225,7 @@ const
 
             const
                 fromLayer = segment.layers[i],
-                toLayer = newSegment.layers[i] = {
-                    ...fromLayer
-                };
+                toLayer = newSegment.layers[i] = cloneLevelDefinition(fromLayer);
 
             if (fromLayer.data) {
                 const
@@ -237,9 +249,7 @@ const
                 for (let j = 0; j < fromObjects.length; j++) {
                     const
                         fromObject = fromObjects[j],
-                        toObject = toObjects[j] = {
-                            ...fromObject
-                        };
+                        toObject = toObjects[j] = cloneLevelDefinition(fromObject);
 
                     toObject.x = width - fromObject.x - (fromObject.width || 0); // subtract object width since its top-left corner is the origin.
                     if (fromObject.rotation) {
@@ -265,9 +275,7 @@ const
                 const
                     key = keys[i];
 
-                if (!newSegment[key]) {
-                    newSegment[key] = segment[key];
-                }
+                copySegmentProperty(newSegment, segment, key);
             }
         }
 
@@ -351,6 +359,10 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
 
     events: {
         "layer-loaded": function (data) {
+            if (data?.level && typeof data.level === 'object') {
+                return;
+            }
+
             const
                 piecesToCopy = data?.levelPieces ?? this.levelPieces;
             
@@ -417,7 +429,10 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
                  * @param data.persistentData.levelPieces {Object} An object of key/value pairs listing the pieces that map to an id in the level template.
                  * @param data.persistentData.useUniques {Boolean} If true, no single map piece is used twice in the creation of the combined map.
                  */
-                this.owner.triggerEvent('created-level', this.levelMessage);
+                this.owner.triggerEvent('created-level', {
+                    level: cloneLevelDefinition(this.levelMessage.level),
+                    persistentData: this.levelMessage.persistentData
+                });
 
                 /**
                  * Dispatched when the scene has loaded and the level has been composited so TileLoader can begin loading the level.
@@ -462,6 +477,9 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
                 throw new Error(`Level Builder: There are no level pieces of type: ${type}`);
             }
         },
+        cloneLevel: function (level) {
+            return cloneLevelDefinition(level);
+        },
         destroy: function () {
             this.levelMessage.level = null;
             this.levelMessage.persistentData = null;

package/src/components/Render.js

@@ -98,8 +98,18 @@ export default createComponentClass(/** @lends platypus.components.RenderSprite.
     initialize () {
         const
             {image, images, localRotation, localScaleX, localScaleY, offsetX, offsetY, offsetZ, options, owner, spriteType} = this,
+            resolveTexture = (path) => {
+                const
+                    texture = platypus.assetCache.get(path);
+
+                if (!texture) {
+                    platypus.debug.warn(`Render: Image is not a loaded asset: ${path}`);
+                }
+
+                return texture;
+            },
             sprite = this.sprite = new spriteTypes[spriteType === 'Sprite' && images && !images ? 'AnimatedSprite' : spriteType]({
-                ...(image ? {texture: platypus.assetCache.get(image)} : {textures: images.map((image) => platypus.assetCache.get(image))}),
+                ...(image ? {texture: resolveTexture(image)} : {textures: images.map((path) => resolveTexture(path))}),
                 ...options ?? {}
             }),
             matchEntity = this.matchEntity ? {

package/src/components/RenderTiles.js

@@ -437,14 +437,7 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
 
             if (map) {
                 this.updateTile(tile, map[z || 0], x, y);
-                // Only flag a re-render if the changed tile is within the currently
-                // cached region. Changes outside the cache will be drawn correctly
-                // the next time the camera pans to include them.
-                if (!this.cache.empty &&
-                    x >= this.cache.left && x <= this.cache.right &&
-                    y >= this.cache.top  && y <= this.cache.bottom) {
-                    this.updateCache = true;
-                }
+                this.updateCache = true;
             }
         },
 
@@ -458,70 +451,13 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
         },
 
         /**
-         * Forces an immediate full re-render centered on the current camera
-         * position. Call this after bulk tile changes to ensure the display
-         * is up to date without requiring a camera pan.
-         *
-         * For the panning cache, we invalidate cachePixels and re-run the full
-         * camera-update recache logic using the last known camera, which correctly
-         * handles texture swapping, tile population, and sprite positioning.
+         * Forces an immediate full re-render of all cached tile textures.
+         * Call this after bulk tile changes to ensure the display is up to date
+         * without requiring a camera pan.
          */
         "force-render": function () {
-            if (this.cacheAll) {
-                // Single/full cache — re-render entire layer.
-                this.populateTiles(this.cache, null);
-                this.renderCache(this.cache, this.cacheTexture, this.mapContainer, this.mapContainerWrapper);
-            } else if (this.cacheTexture) {
-                // Panning cache — invalidate cachePixels so the recache branch
-                // runs, then execute the full camera-update recache inline.
-                const
-                    {viewport: vp} = this.owner.parent.worldCamera,
-                    {cache, cachePixels} = this,
-                    tempC = tempCache,
-                    ctw   = this.cacheTilesWidth  - 1,
-                    cth   = this.cacheTilesHeight - 1,
-                    ctw2  = ctw / 2,
-                    cth2  = cth / 2;
-
-                this.convertCamera(vp);
-
-                // Force the recache branch to run regardless of camera position.
-                cachePixels.empty = true;
-
-                tempC.setAll(
-                    Math.round((this.laxCam.x - this.left) / this.tileWidth  - ctw2) + ctw2,
-                    Math.round((this.laxCam.y - this.top)  / this.tileHeight - cth2) + cth2,
-                    ctw, cth
-                );
-                if (tempC.left < 0) {
-                    tempC.moveX(tempC.halfWidth);
-                } else if (tempC.right > this.tilesWidth - 1) {
-                    tempC.moveX(this.tilesWidth - 1 - tempC.halfWidth);
-                }
-                if (tempC.top < 0) {
-                    tempC.moveY(tempC.halfHeight);
-                } else if (tempC.bottom > this.tilesHeight - 1) {
-                    tempC.moveY(this.tilesHeight - 1 - tempC.halfHeight);
-                }
-
-                this.tilesSpriteCache.texture = this.cacheTexture;
-                this.cacheTexture = this.cacheTexture.alternate;
-                this.tilesSprite.texture = this.cacheTexture;
-
-                this.populateTiles(tempC, cache);
-                this.renderCache(tempC, this.cacheTexture, this.mapContainer, this.mapContainerWrapper, this.tilesSpriteCache);
-                cache.set(tempC);
-
-                cachePixels.setAll(
-                    (cache.x + 0.5) * this.tileWidth  + this.left,
-                    (cache.y + 0.5) * this.tileHeight + this.top,
-                    (cache.width  + 1) * this.tileWidth,
-                    (cache.height + 1) * this.tileHeight
-                );
-
-                this.tilesSprite.x = vp.left - this.laxCam.left + cache.left * this.tileWidth  + this.left;
-                this.tilesSprite.y = vp.top  - this.laxCam.top  + cache.top  * this.tileHeight + this.top;
-            }
+            this.refreshAllCaches();
+            this.updateCache = false;
         }
     },
 
@@ -571,8 +507,7 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                 'handle-render': function () {
                     if (this.updateCache) {
                         this.updateCache = false;
-                        this.populateTiles(this.cache, null);
-                        this.renderCache(this.cache, this.cacheTexture, this.mapContainer, this.mapContainerWrapper);
+                        this.refreshAllCaches();
                     }
                 }
             });
@@ -632,21 +567,8 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                 },
                 'handle-render': function () {
                     if (this.updateCache) {
-                        const
-                            {cache, cacheGrid, cacheTilesHeight, cacheTilesWidth, tilesHeight, tilesWidth} = this,
-                            tsh = tilesHeight - 1,
-                            tsw = tilesWidth - 1;
-
                         this.updateCache = false;
-
-                        for (let x = 0; x < cacheGrid.length; x++) {
-                            for (let y = 0; y < cacheGrid[x].length; y++) {
-                                cache.setBounds(x * cacheTilesWidth, y * cacheTilesHeight, Math.min((x + 1) * cacheTilesWidth, tsw), Math.min((y + 1) * cacheTilesHeight, tsh));
-
-                                this.populateTiles(cache, null);
-                                this.renderCacheWithExtrusion(cache, cacheGrid[x][y].texture, this.mapContainer, this.mapContainerWrapper);
-                            }
-                        }
+                        this.refreshAllCaches();
                     }
                 }
             });
@@ -699,24 +621,7 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                             this.updateBufferRegion(laxCam);
                         }
 
-                        const
-                            ctw     = this.cacheTilesWidth - 1,
-                            cth     = this.cacheTilesHeight - 1,
-                            ctw2    = ctw / 2,
-                            cth2    = cth / 2;
-
-                        //only attempt to draw children that are relevant
-                        tempC.setAll(Math.round((laxCam.x - this.left) / this.tileWidth - ctw2) + ctw2, Math.round((laxCam.y - this.top) / this.tileHeight - cth2) + cth2, ctw, cth);
-                        if (tempC.left < 0) {
-                            tempC.moveX(tempC.halfWidth);
-                        } else if (tempC.right > this.tilesWidth - 1) {
-                            tempC.moveX(this.tilesWidth - 1 - tempC.halfWidth);
-                        }
-                        if (tempC.top < 0) {
-                            tempC.moveY(tempC.halfHeight);
-                        } else if (tempC.bottom > this.tilesHeight - 1) {
-                            tempC.moveY(this.tilesHeight - 1 - tempC.halfHeight);
-                        }
+                        this.alignCacheToCamera(tempC, vp);
                         
                         this.tilesSpriteCache.texture = this.cacheTexture;
                         this.cacheTexture = this.cacheTexture.alternate;
@@ -734,17 +639,9 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                     this.tilesSprite.y = vp.top  - laxCam.top  + cache.top  * this.tileHeight + this.top;
                 },
                 'handle-render': function () {
-                    if (this.updateCache && !this.cache.empty) {
+                    if (this.updateCache) {
                         this.updateCache = false;
-                        this.populateTiles(this.cache, null);
-                        this.renderCacheClear(this.cache, this.cacheTexture, this.mapContainer, this.mapContainerWrapper);
-                        this.tilesSpriteCache.texture = this.cacheTexture;
-                        this.cachePixels.setAll(
-                            (this.cache.x + 0.5) * this.tileWidth  + this.left,
-                            (this.cache.y + 0.5) * this.tileHeight + this.top,
-                            (this.cache.width  + 1) * this.tileWidth,
-                            (this.cache.height + 1) * this.tileHeight
-                        );
+                        this.refreshAllCaches();
                     }
                 }
             });
@@ -782,24 +679,7 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                             this.updateBufferRegion(laxCam);
                         }
 
-                        const
-                            ctw     = this.cacheTilesWidth - 1,
-                            cth     = this.cacheTilesHeight - 1,
-                            ctw2    = ctw / 2,
-                            cth2    = cth / 2;
-
-                        //only attempt to draw children that are relevant
-                        tempC.setAll(Math.round((laxCam.x - this.left) / this.tileWidth - ctw2) + ctw2, Math.round((laxCam.y - this.top) / this.tileHeight - cth2) + cth2, ctw, cth);
-                        if (tempC.left < 0) {
-                            tempC.moveX(tempC.halfWidth);
-                        } else if (tempC.right > this.tilesWidth - 1) {
-                            tempC.moveX(this.tilesWidth - 1 - tempC.halfWidth);
-                        }
-                        if (tempC.top < 0) {
-                            tempC.moveY(tempC.halfHeight);
-                        } else if (tempC.bottom > this.tilesHeight - 1) {
-                            tempC.moveY(this.tilesHeight - 1 - tempC.halfHeight);
-                        }
+                        this.alignCacheToCamera(tempC, vp);
                         
                         this.populateTiles(tempC, null);
                         cache.set(tempC);
@@ -1079,7 +959,151 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
             this.mapContainer.mask = new Graphics().rect(0, 0, this.cacheClipWidth, this.cacheClipHeight).fill(0x000000);
         },
 
+        /**
+         * Computes tile bounds for the panning cache centered on the current camera.
+         *
+         * @param {platypus.AABB} bounds - Receives the computed tile bounds.
+         * @param {platypus.AABB} viewport - The camera viewport.
+         */
+        alignCacheToCamera: function (bounds, viewport) {
+            const
+                ctw  = this.cacheTilesWidth - 1,
+                cth  = this.cacheTilesHeight - 1,
+                ctw2 = ctw / 2,
+                cth2 = cth / 2;
+
+            this.convertCamera(viewport);
+
+            bounds.setAll(
+                Math.round((this.laxCam.x - this.left) / this.tileWidth - ctw2) + ctw2,
+                Math.round((this.laxCam.y - this.top) / this.tileHeight - cth2) + cth2,
+                ctw, cth
+            );
+
+            if (bounds.left < 0) {
+                bounds.moveX(bounds.halfWidth);
+            } else if (bounds.right > this.tilesWidth - 1) {
+                bounds.moveX(this.tilesWidth - 1 - bounds.halfWidth);
+            }
+
+            if (bounds.top < 0) {
+                bounds.moveY(bounds.halfHeight);
+            } else if (bounds.bottom > this.tilesHeight - 1) {
+                bounds.moveY(this.tilesHeight - 1 - bounds.halfHeight);
+            }
+        },
+
+        /**
+         * Re-renders every texture in a multi-texture full-map cache grid.
+         */
+        refreshAllCacheGrid: function () {
+            const
+                {cache, cacheGrid, cacheTilesHeight, cacheTilesWidth, tilesHeight, tilesWidth} = this,
+                tsh = tilesHeight - 1,
+                tsw = tilesWidth - 1;
+
+            for (let x = 0; x < cacheGrid.length; x++) {
+                for (let y = 0; y < cacheGrid[x].length; y++) {
+                    cache.setBounds(
+                        x * cacheTilesWidth,
+                        y * cacheTilesHeight,
+                        Math.min((x + 1) * cacheTilesWidth, tsw),
+                        Math.min((y + 1) * cacheTilesHeight, tsh)
+                    );
+
+                    this.populate(cache, null);
+                    this.renderCacheWithExtrusion(cache, cacheGrid[x][y].texture, this.mapContainer, this.mapContainerWrapper);
+                }
+            }
+        },
+
+        /**
+         * Re-renders the current panning-cache window in place.
+         * Uses the alternate render texture while drawing so we never render
+         * into the texture that is currently displayed on screen.
+         *
+         * @param {platypus.AABB} [viewport] - Optional camera viewport.
+         */
+        refreshPanningCache: function (viewport) {
+            const
+                {cache, cachePixels, laxCam, left, top, tilesSprite} = this,
+                vp = viewport ?? this.owner.parent.worldCamera?.viewport;
+
+            if (!vp) {
+                return;
+            }
+
+            if (cache.empty) {
+                this.alignCacheToCamera(cache, vp);
+            }
+
+            if (cache.empty) {
+                return;
+            }
+
+            this.detachCacheCopy();
+
+            this.tilesSpriteCache.texture = this.cacheTexture;
+            this.cacheTexture = this.cacheTexture.alternate;
+            tilesSprite.texture = this.cacheTexture;
+
+            this.populate(cache, null);
+            this.renderCacheClear(cache, this.cacheTexture, this.mapContainer, this.mapContainerWrapper);
+
+            this.tilesSpriteCache.texture = this.cacheTexture;
+            cachePixels.setAll(
+                (cache.x + 0.5) * this.tileWidth + left,
+                (cache.y + 0.5) * this.tileHeight + top,
+                (cache.width + 1) * this.tileWidth,
+                (cache.height + 1) * this.tileHeight
+            );
+
+            this.convertCamera(vp);
+            tilesSprite.x = vp.left - laxCam.left + cache.left * this.tileWidth + left;
+            tilesSprite.y = vp.top - laxCam.top + cache.top * this.tileHeight + top;
+        },
+
+        detachCacheCopy: function () {
+            const
+                {mapContainer, tilesSpriteCache} = this;
+
+            if (tilesSpriteCache?.parent === mapContainer) {
+                mapContainer.removeChild(tilesSpriteCache);
+            }
+        },
+
+        /**
+         * Re-renders all cached tile textures for the active caching strategy.
+         *
+         * @param {platypus.AABB} [viewport] - Optional camera viewport for panning caches.
+         */
+        refreshAllCaches: function (viewport) {
+            if (!this.tileCache) {
+                this.cachePixels.empty = true;
+                return;
+            }
+
+            if (this.cacheGrid) {
+                this.refreshAllCacheGrid();
+                return;
+            }
+
+            if (this.cacheAll && this.cacheTexture) {
+                this.populate(this.cache, null);
+                this.render(this.cache, this.cacheTexture, this.mapContainer, this.mapContainerWrapper);
+                return;
+            }
+
+            if (this.cacheTexture) {
+                this.refreshPanningCache(viewport);
+            }
+        },
+
         populateTiles: function (bounds, oldBounds) {
+            // When oldBounds is provided, only tiles outside the previous window are
+            // drawn. That is correct for camera scrolling (reuse pixels from the old
+            // cache texture) but must not be used for in-place tile edits — pass null
+            // to redraw the entire bounds.
             const
                 tiles = arrayCache.setUp();
 
@@ -1194,6 +1218,11 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
                 container: wrapper,
                 target: renderTexture
             });
+
+            if (oldCache?.parent === src) {
+                src.removeChild(oldCache);
+            }
+
             renderTexture.requiresUpdate = true;
         },
 
@@ -1201,6 +1230,8 @@ export default createComponentClass(/** @lends platypus.components.RenderTiles.p
             const
                 {renderer} = this;
 
+            this.detachCacheCopy();
+
             src.x = -bounds.left * this.tileWidth;
             src.y = -bounds.top * this.tileHeight;
             renderer.render({

package/src/components/TiledLoader.js

@@ -1,5 +1,6 @@
 /* global atob, platypus */
 import {arrayCache, greenSlice, union} from '../utils/array.js';
+import {cloneDefinition} from '../utils/clone.js';
 import AABB from '../AABB.js';
 import Data from '../Data.js';
 import DataMap from '../DataMap.js';
@@ -336,6 +337,7 @@ const
     },
     checkLevel = function (levelOrLevelId, ss) {
         const
+            cacheAssetsOnLevel = typeof levelOrLevelId === 'string',
             addObjectGroupAssets = (assets, objectGroup, tilesets) => {
                 const objects = objectGroup.objects;
 
@@ -356,7 +358,7 @@ const
                 level.tilesets = importTilesetData(level.tilesets);
             }
 
-            if (level.assets) { // Property added by a previous parse (so that this algorithm isn't run on the same level multiple times)
+            if (cacheAssetsOnLevel && level.assets) { // Property added by a previous parse (so that this algorithm isn't run on the same level multiple times)
                 union(assets, level.assets);
             } else if (level.layers) {
                 for (let i = 0; i < level.layers.length; i++) {
@@ -405,7 +407,7 @@ const
                                             tile = tiles[l];
 
                                         if (((tile.id + firstgid) === id) && tile.objectgroup) {
-                                            addObjectGroupAssets(assets, tile.objectgroup);
+                                            addObjectGroupAssets(assets, tile.objectgroup, level.tilesets);
                                         }
                                     }
                                 }
@@ -452,7 +454,9 @@ const
                     union(assets, tilesets);
                     arrayCache.recycle(tilesets);
                 }
-                level.assets = greenSlice(assets); // Save for later in case this level is checked again.
+                if (cacheAssetsOnLevel) {
+                    level.assets = greenSlice(assets); // Save for later in case this level is checked again.
+                }
             }
         }
         
@@ -746,7 +750,7 @@ export default createComponentClass(/** @lends platypus.components.TiledLoader.p
                 } = layerProperties ? checkParallax(layer) : layer,
                 mapOffsetX = offsetX + layerOffsetX,
                 mapOffsetY = offsetY + layerOffsetY,
-                layerDefinition = JSON.parse(JSON.stringify(platypus.game.settings.entities[entityKind] ?? standardEntityLayers[entityKind])), //TODO: a bit of a hack to copy an object instead of overwrite values
+                layerDefinition = cloneDefinition(platypus.game.settings.entities[entityKind] ?? standardEntityLayers[entityKind]),
                 layerDefinitionProperties = layerDefinition.properties = layerDefinition.properties ?? {},
                 {components} = layerDefinition,
                 importAnimation = {},