@makefully/platypus 4.1.10 → 4.1.13

package/src/components/LevelBuilder.js

@@ -6,6 +6,176 @@ import {inflate} from 'pako';
 import TiledLoader from './TiledLoader.js';
 
 const
+    assertLevelPiece = function (piece, label) {
+        if (piece == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is undefined. Check that it is defined in platypus.game.settings.levels or levelPieces.`);
+        }
+
+        if (typeof piece !== 'object') {
+            throw new Error(`Level Builder: Level piece "${label}" must be a level definition object, received ${typeof piece}.`);
+        }
+
+        if (piece.width == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is missing width.`);
+        }
+
+        if (piece.height == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is missing height.`);
+        }
+
+        if (piece.tilewidth == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is missing tilewidth.`);
+        }
+
+        if (piece.tileheight == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is missing tileheight.`);
+        }
+
+        if (piece.layers == null) {
+            throw new Error(`Level Builder: Level piece "${label}" is missing a layers array.`);
+        }
+
+        if (!Array.isArray(piece.layers)) {
+            throw new Error(`Level Builder: Level piece "${label}" layers must be an array.`);
+        }
+
+        return piece;
+    },
+    assertLevelTemplate = function (template) {
+        if (template == null) {
+            throw new Error(`Level Builder: levelTemplate is required but was not provided.`);
+        }
+
+        if (!Array.isArray(template)) {
+            throw new Error(`Level Builder: levelTemplate must be an array, received ${typeof template}.`);
+        }
+
+        if (template.length === 0) {
+            throw new Error(`Level Builder: levelTemplate cannot be empty.`);
+        }
+
+        let rowLength = null;
+
+        for (let i = 0; i < template.length; i++) {
+            const
+                row = template[i];
+
+            if (typeof row === 'string') {
+                if (!row) {
+                    throw new Error(`Level Builder: levelTemplate[${i}] is an empty string.`);
+                }
+
+                if (rowLength != null && rowLength !== '1d') {
+                    throw new Error(`Level Builder: levelTemplate is not rectangular: row 0 has ${rowLength} columns but row ${i} is a string.`);
+                }
+
+                rowLength = '1d';
+            } else if (Array.isArray(row)) {
+                if (row.length === 0) {
+                    throw new Error(`Level Builder: levelTemplate row ${i} is empty.`);
+                }
+
+                if (rowLength === '1d') {
+                    throw new Error(`Level Builder: levelTemplate is not rectangular: row 0 is a string but row ${i} is an array.`);
+                }
+
+                if (rowLength == null) {
+                    rowLength = row.length;
+                } else if (rowLength !== row.length) {
+                    throw new Error(`Level Builder: levelTemplate is not rectangular: row 0 has ${rowLength} columns but row ${i} has ${row.length}.`);
+                }
+
+                for (let j = 0; j < row.length; j++) {
+                    if (typeof row[j] !== 'string') {
+                        throw new Error(`Level Builder: levelTemplate[${i}][${j}] must be a piece id string, received ${typeof row[j]}.`);
+                    }
+
+                    if (!row[j]) {
+                        throw new Error(`Level Builder: levelTemplate[${i}][${j}] is an empty string.`);
+                    }
+                }
+            } else {
+                throw new Error(`Level Builder: levelTemplate[${i}] must be a string or array of strings, received ${typeof row}.`);
+            }
+        }
+
+        return template;
+    },
+    assertLevelPieces = function (pieces) {
+        if (pieces == null) {
+            return;
+        }
+
+        if (typeof pieces !== 'object' || Array.isArray(pieces)) {
+            throw new Error(`Level Builder: levelPieces must be an object, received ${Array.isArray(pieces) ? 'array' : typeof pieces}.`);
+        }
+
+        const
+            keys = Object.keys(pieces),
+            {length} = keys;
+
+        for (let i = 0; i < length; i++) {
+            const
+                key = keys[i],
+                value = pieces[key];
+
+            if (typeof value === 'string') {
+                if (!value) {
+                    throw new Error(`Level Builder: levelPieces["${key}"] is an empty string.`);
+                }
+            } else if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    throw new Error(`Level Builder: levelPieces["${key}"] is an empty array. Provide at least one level piece id.`);
+                }
+
+                for (let j = 0; j < value.length; j++) {
+                    if (typeof value[j] !== 'string') {
+                        throw new Error(`Level Builder: levelPieces["${key}"][${j}] must be a string level id, received ${typeof value[j]}.`);
+                    }
+
+                    if (!value[j]) {
+                        throw new Error(`Level Builder: levelPieces["${key}"][${j}] is an empty string.`);
+                    }
+                }
+            } else {
+                throw new Error(`Level Builder: levelPieces["${key}"] must be a string or array of strings, received ${typeof value}.`);
+            }
+        }
+    },
+    resolveLevelPiece = function (piece, label) {
+        if (typeof piece === 'string') {
+            const
+                levelDefinitions = platypus.game.settings.levels,
+                transformIndex = piece.indexOf(':');
+            let levelDefinition = levelDefinitions?.[piece];
+
+            if (!levelDefinition && transformIndex >= 0) {
+                const
+                    baseLabel = piece.substring(0, transformIndex),
+                    transform = piece.substring(transformIndex + 1);
+
+                levelDefinition = levelDefinitions?.[baseLabel];
+
+                if (!levelDefinition) {
+                    throw new Error(`Level Builder: Level piece "${baseLabel}" (from "${piece}") was not found in platypus.game.settings.levels.`);
+                }
+
+                if (transform === 'mirror') {
+                    return levelDefinitions[piece] = mirrorSegment(assertLevelPiece(levelDefinition, baseLabel));
+                }
+
+                throw new Error(`Level Builder: Unknown transform "${transform}" in level piece "${piece}". Supported transforms: mirror.`);
+            }
+
+            if (!levelDefinition) {
+                throw new Error(`Level Builder: Level piece "${piece}" was not found in platypus.game.settings.levels.`);
+            }
+
+            return assertLevelPiece(levelDefinition, piece);
+        }
+
+        return assertLevelPiece(piece, label);
+    },
     maskXFlip = 0x80000000,
     decodeString = (str, index) => (((str.charCodeAt(index)) + (str.charCodeAt(index + 1) << 8) + (str.charCodeAt(index + 2) << 16) + (str.charCodeAt(index + 3) << 24 )) >>> 0),
     decodeArray = (arr, index) => ((arr[index] + (arr[index + 1] << 8) + (arr[index + 2] << 16) + (arr[index + 3] << 24 )) >>> 0),
@@ -25,7 +195,11 @@ const
         
         return arr;
     },
-    decodeLayer = function (layer) {
+    decodeLayer = function (layer, label) {
+        if (layer == null) {
+            throw new Error(`Level Builder: Cannot decode layer${label ? ` in "${label}"` : ''}: layer is undefined.`);
+        }
+
         if (layer.encoding === 'base64') {
             layer.data = decodeBase64(layer.data, layer.compression);
             layer.encoding = 'csv'; // So we won't have to decode again.
@@ -81,8 +255,8 @@ const
         }
         return list;
     },
-    mergeSegment  = function (level, segment, mergeAxis) {
-        segment = cloneLevelDefinition(segment);
+    mergeSegment  = function (level, segment, mergeAxis, segmentLabel) {
+        segment = cloneLevelDefinition(assertLevelPiece(segment, segmentLabel ?? 'segment'));
 
         if (!level.tilewidth && !level.tileheight) {
             //set level tile size data if it's not already set.
@@ -107,9 +281,13 @@ const
         }
 
         for (let i = 0; i < segment.layers.length; i++) {
+            if (segment.layers[i] == null) {
+                throw new Error(`Level Builder: Level piece "${segmentLabel ?? 'segment'}" layer ${i} is undefined.`);
+            }
+
             if (!level.layers[i]) {
                 //if the level doesn't have a layer yet, we're creating it and then copying it from the segment.
-                decodeLayer(segment.layers[i]);
+                decodeLayer(segment.layers[i], segmentLabel);
                 
                 const
                     layer = level.layers[i] = cloneLevelDefinition(segment.layers[i]);
@@ -126,7 +304,7 @@ const
                 //if the level does have a layer, we're appending the new data to it.
                 if (level.layers[i].data && segment.layers[i].data) {
                     // Make sure we're not trying to merge compressed levels.
-                    decodeLayer(segment.layers[i]);
+                    decodeLayer(segment.layers[i], segmentLabel);
                     
                     if (mergeAxis === 'horizontal') {
                         level.layers[i].data = mergeData(level.layers[i].data, level.width, segment.layers[i].data, segment.width, level.height, mergeAxis);
@@ -169,7 +347,6 @@ const
     },
     mergeLevels = function (levelSegments) {
         const
-            levelDefinitions = platypus.game.settings.levels,
             level = {
                 height: 0,
                 width: 0,
@@ -184,35 +361,25 @@ const
                     layers: []
                 };
 
+            if (!Array.isArray(levelSegments[i])) {
+                throw new Error(`Level Builder: mergeLevels row ${i} must be an array of level pieces, received ${typeof levelSegments[i]}.`);
+            }
+
             for (let j = 0; j < levelSegments[i].length; j++) {
-                //Merge horizontally
-                if (typeof levelSegments[i][j] === 'string') {
-                    const
-                        levelDefinitionLabel = levelSegments[i][j],
-                        transformIndex = levelDefinitionLabel.indexOf(':');
-                    let levelDefinition = levelDefinitions[levelDefinitionLabel];
-                    
-                    // check for transform
-                    if (!levelDefinition && (transformIndex >= 0)) {
-                        const transform = levelDefinitionLabel.substring(transformIndex + 1);
+                const
+                    piece = levelSegments[i][j],
+                    pieceLabel = typeof piece === 'string' ? piece : `row ${i}, column ${j}`;
 
-                        levelDefinition = levelDefinitions[levelDefinitionLabel.substring(0, transformIndex)];
-                        if (transform === 'mirror') {
-                            levelDefinition = levelDefinitions[levelDefinitionLabel] = mirrorSegment(levelDefinition);
-                        }
-                    }
-                    mergeSegment(row, levelDefinition, 'horizontal');
-                } else {
-                    mergeSegment(row, levelSegments[i][j], 'horizontal');
-                }
+                //Merge horizontally
+                mergeSegment(row, resolveLevelPiece(piece, pieceLabel), 'horizontal', pieceLabel);
             }
             //Then merge vertically
-            mergeSegment(level, row, 'vertical');
+            mergeSegment(level, row, 'vertical', `row ${i}`);
         }
         return level;
     },
-    mirrorSegment = function (segment) {
-        segment = cloneLevelDefinition(segment);
+    mirrorSegment = function (segment, segmentLabel) {
+        segment = cloneLevelDefinition(assertLevelPiece(segment, segmentLabel ?? 'segment'));
 
         const
             newSegment = {
@@ -221,7 +388,11 @@ const
             width = segment.width * segment.tilewidth;
 
         for (let i = 0; i < segment.layers.length; i++) {
-            decodeLayer(segment.layers[i]);
+            if (segment.layers[i] == null) {
+                throw new Error(`Level Builder: Level piece "${segmentLabel ?? 'segment'}" layer ${i} is undefined.`);
+            }
+
+            decodeLayer(segment.layers[i], segmentLabel);
 
             const
                 fromLayer = segment.layers[i],
@@ -369,6 +540,8 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
             this.levelMessage.persistentData = data;
             this.levelTemplate = data?.levelTemplate ?? this.levelTemplate;
             this.useUniques = data?.useUniques ?? this.useUniques;
+            assertLevelPieces(piecesToCopy);
+
             this.levelPieces = {};
             if (piecesToCopy) {
                 const
@@ -385,32 +558,26 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
                         this.levelPieces[key] = [
                             ...piecesToCopy[key]
                         ];
-                    } else {
-                        throw ('Level Builder: Level pieces of incorrect type: ' + piecesToCopy[key]);
                     }
                 }
             }
 
             if (this.levelTemplate) {
-                if (this.levelTemplate) {
-                    this.levelMessage.level = [];
-                    for (let i = 0; i < this.levelTemplate.length; i++) {
-                        const
-                            templateRow = this.levelTemplate[i];
-
-                        if (typeof templateRow === "string") {
-                            this.levelMessage.level[i] = this.getLevelPiece(templateRow);
-                        } else if (templateRow.length) {
-                            this.levelMessage.level[i] = [];
-                            for (let j = 0; j < templateRow.length; j++) {
-                                this.levelMessage.level[i][j] = this.getLevelPiece(templateRow[j]);
-                            }
-                        } else {
-                            throw ('Level Builder: Template row is neither a string or array. What is it?');
+                assertLevelTemplate(this.levelTemplate);
+
+                this.levelMessage.level = [];
+                for (let i = 0; i < this.levelTemplate.length; i++) {
+                    const
+                        templateRow = this.levelTemplate[i];
+
+                    if (typeof templateRow === "string") {
+                        this.levelMessage.level[i] = this.getLevelPiece(templateRow);
+                    } else {
+                        this.levelMessage.level[i] = [];
+                        for (let j = 0; j < templateRow.length; j++) {
+                            this.levelMessage.level[i][j] = this.getLevelPiece(templateRow[j]);
                         }
                     }
-                } else {
-                    platypus.debug.warn('Level Builder: Template is not defined');
                 }
             } else {
                 platypus.debug.warn('Level Builder: There is no level template.');
@@ -452,6 +619,10 @@ export default createComponentClass(/** @lends platypus.components.LevelBuilder.
     
     methods: {// These are methods that are called by this component.
         getLevelPiece: function (type) {
+            if (type == null || type === '') {
+                throw new Error(`Level Builder: Template references an invalid piece id: ${type}.`);
+            }
+
             const
                 pieces = this.levelPieces[type] ?? type;
             

package/src/components/Render.js

@@ -178,11 +178,17 @@ export default createComponentClass(/** @lends platypus.components.RenderSprite.
     
     getAssetList (a, b, c) {
         const
-            image = a?.image ?? b?.image ?? c?.image;
+            image = a?.image ?? b?.image ?? c?.image,
+            formatImageAsset = (src) => {
+                const
+                    alias = platypus.assetCache?.getFileId ? platypus.assetCache.getFileId(src) : src;
+
+                return {
+                    alias: [alias],
+                    src
+                };
+            };
 
-        return (image ? [image] : a?.images ?? b?.images ?? c?.images ?? []).map((src) => ({
-            alias: [src],
-            src
-        }));
+        return (image ? [image] : a?.images ?? b?.images ?? c?.images ?? []).map(formatImageAsset);
     }
 });

package/src/components/RenderSpine.js

@@ -379,14 +379,6 @@ export default createComponentClass(/** @lends platypus.components.RenderSpine.p
                     spine = this.spine = new Spine({skeletonData, autoUpdate: false}),
                     map = createAnimationMap(this.animationMap, skeleton.animations);
 
-                // Spine 4.3 inherits Pixi container world-transform deltas into skeleton physics by default.
-                // Platypus pans the camera by moving the world container, which shifts every entity's world
-                // transform even when owner.x/y are unchanged — causing unwanted physics on stationary characters.
-                // Use the `apply-spine-physics` event for intentional movement-driven physics instead.
-                spine.setPhysicsPositionInheritanceFactor(0, 0);
-                spine.physicsRotationInheritanceFactor = 0;
-                spine.resetPhysicsTransform();
-
                 let animation = '';
 
                 spine.state.addListener({

package/src/components/RenderSprite.js

@@ -489,12 +489,21 @@ export default createComponentClass(/** @lends platypus.components.RenderSprite.
     
     getAssetList: (function () {
         const
+            formatImageAsset = function (src) {
+                const
+                    alias = platypus.assetCache?.getFileId ? platypus.assetCache.getFileId(src) : src;
+
+                return {
+                    alias: [alias],
+                    src
+                };
+            },
             getImages = function (ss, spriteSheets) {
                 if (ss) {
                     if (typeof ss === 'string') {
                         return getImages(spriteSheets[ss], spriteSheets);
                     } else if (ss.images) {
-                        return greenSlice(ss.images);
+                        return greenSlice(ss.images).map(formatImageAsset);
                     }
                 }
 

package/src/index.js

@@ -5,7 +5,7 @@
 /**
  * @namespace platypus
  */
-/* global global, navigator, window */
+/* global global, navigator */
 
 import AssetManager from './AssetManager.js';
 import {Debugger} from 'springroll';
@@ -46,7 +46,6 @@ const
         components
     },
     uagent    = navigator.userAgent.toLowerCase(),
-    isEdge    = (uagent.search('edge')    > -1),
     isIPod    = (uagent.search('ipod')    > -1),
     isIPhone  = (uagent.search('iphone')  > -1),
     isIPad    = (uagent.search('ipad')    > -1) || (uagent.search('mac') > -1 && navigator.maxTouchPoints > 2 && !isIPhone),
@@ -109,20 +108,21 @@ const
 
 /**
  * This is an object of boolean key/value pairs describing the current browser's properties.
+ * Obsolete capability flags (`touch`, `edge`, `ie`) are fixed to match modern browser support.
  * @property supports
  * @type Object
  **/
 platypus.supports = {
-    touch: (window.ontouchstart !== 'undefined'),
-    edge: isEdge,
+    touch: true, // Touch Events are universally available in modern browsers
+    edge: false, // Legacy EdgeHTML is no longer supported
     iPod: isIPod,
     iPhone: isIPhone,
     iPad: isIPad,
-    safari: (uagent.search('safari') > -1) && !isEdge,
-    ie: (uagent.search('msie') > -1) || (uagent.search('trident') > -1),
+    safari: (uagent.search('safari') > -1),
+    ie: false, // Internet Explorer is no longer supported
     firefox: (uagent.search('firefox') > -1),
     android: isAndroid,
-    chrome: (uagent.search('chrome') > -1) && !isEdge,
+    chrome: (uagent.search('chrome') > -1),
     silk: isSilk,
     iOS: isIOS,
     mobile: isMobile,

package/src/sayHello.js

@@ -30,7 +30,7 @@ export default function (app) {
         author = docAuth ? `by ${docAuth}` : '',
         title = `${options.name ?? app.name ?? document.title ?? ''}${version ? ` ${version}` : ''}`,
         using = arrayCache.setUp(),
-        {springroll, supports} = platypus;
+        {springroll} = platypus;
     
     if (springroll) {
         using.push('SpringRoll ' + springroll.version);
@@ -38,13 +38,10 @@ export default function (app) {
     
     using.push('Pixi.js ' + pixiVersion);
     
-    if (supports.firefox || supports.chrome) {
-        console.log(`%c ${title} %c ${author}`, getStyle(title, title.substr(title.lastIndexOf(' ') - title.length + 1)), 'line-height: 1.5em;');
-        using.push(`Platypus ${platypus.version}`);
-        console.log(`Using %c ${using.join(' %c %c ')} %c `, ...getVersions(using));
-    } else {
-        console.log(`--- "${title}" ${author} - Using ${using.join(', ')}, and Platypus ${platypus.version} ---`);
-    }
+    // Styled console (%c) is supported in all modern browsers.
+    console.log(`%c ${title} %c ${author}`, getStyle(title, title.substr(title.lastIndexOf(' ') - title.length + 1)), 'line-height: 1.5em;');
+    using.push(`Platypus ${platypus.version}`);
+    console.log(`Using %c ${using.join(' %c %c ')} %c `, ...getVersions(using));
 
     arrayCache.recycle(using);
 };