melonjs 14.0.1 → 14.1.0

package/dist/melonjs.mjs/lang/deprecated.js

@@ -0,0 +1,157 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { TextureAtlas } from '../video/texture/atlas.js';
+import Renderer from '../video/renderer.js';
+import { Draggable, DropTarget } from '../renderable/dragndrop.js';
+import UISpriteElement from '../renderable/ui/uispriteelement.js';
+
+/*
+ * placeholder for all deprecated classes and corresponding alias for backward compatibility
+ */
+
+/**
+ * display a deprecation warning in the console
+ * @ignore
+ * @param {string} deprecated - deprecated class,function or property name
+ * @param {string} replacement - the replacement class, function, or property name
+ * @param {string} version - the version since when the lass,function or property is deprecated
+ */
+function warning(deprecated, replacement, version) {
+    var msg = "melonJS: %s is deprecated since version %s, please use %s";
+    var stack = new Error().stack;
+
+    if (console.groupCollapsed) {
+        console.groupCollapsed(
+            "%c" + msg,
+            "font-weight:normal;color:yellow;",
+            deprecated,
+            version,
+            replacement
+        );
+    } else {
+        console.warn(
+            msg,
+            deprecated,
+            version,
+            replacement
+        );
+    }
+
+    if (typeof stack !== "undefined") {
+        console.warn(stack);
+    }
+
+    if (console.groupCollapsed) {
+        console.groupEnd();
+    }
+}
+
+/**
+ * Alias of {@link TextureAtlas}
+ * @public
+ * @name Texture
+ * @class
+ * @memberof Renderer#
+ * @deprecated since 10.4.0
+ * @see TextureAtlas
+ */
+Object.defineProperty(Renderer.prototype, "Texture", {
+    /**
+     * @ignore
+     */
+    get : function () {
+        warning("me.video.renderer.Texture", "me.TextureAtlas", "10.4.0");
+        return TextureAtlas;
+    }
+});
+
+/**
+ * @classdesc
+ * Used to make a game entity draggable
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see Draggable
+ */
+class DraggableEntity extends Draggable {
+    /**
+     * @param {number} x - the x coordinates of the draggable object
+     * @param {number} y - the y coordinates of the draggable object
+     * @param {object} settings - Entity properties (see {@link Entity})
+     */
+    constructor(x, y, settings) {
+        warning("DraggableEntity", "Draggable", "10.5.0");
+        super(x, y, settings.width, settings.height);
+    }
+}
+
+/**
+ * @classdesc
+ * Used to make a game entity a droptarget
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see DropTarget
+ */
+class DroptargetEntity extends DropTarget {
+    /**
+     * @param {number} x - the x coordinates of the draggable object
+     * @param {number} y - the y coordinates of the draggable object
+     * @param {object} settings - Entity properties (see {@link Entity})
+     */
+    constructor(x, y, settings) {
+        warning("DroptargetEntity", "DropTarget", "10.5.0");
+        super(x, y, settings.width, settings.height);
+    }
+}
+
+/**
+ * return a reference to the screen canvas
+ * @name getScreenCanvas
+ * @memberof Renderer
+ * @returns {HTMLCanvasElement}
+ * @deprecated since 13.1.0
+ * @see getCanvas();
+ */
+Renderer.prototype.getScreenCanvas = function() {
+    warning("getScreenCanvas", "getCanvas", "13.1.0");
+    return this.getCanvas();
+};
+
+/**
+ * return a reference to the screen canvas corresponding 2d Context<br>
+ * (will return buffered context if double buffering is enabled, or a reference to the Screen Context)
+ * @name getScreenContext
+ * @memberof Renderer
+ * @returns {CanvasRenderingContext2D}
+ * @deprecated since 13.1.0
+ * @see getContext();
+ */
+Renderer.prototype.getScreenContext = function()  {
+    warning("getScreenContext", "getContext", "13.1.0");
+    return this.getContext();
+};
+
+/**
+ * @classdesc
+ * A very basic object to manage GUI elements
+ * @augments Sprite
+ * @deprecated since 14.0.0
+ * @see UISpriteElement
+ */
+ class GUI_Object extends UISpriteElement {
+    /**
+     * @param {number} x - the x coordinate of the GUI Object
+     * @param {number} y - the y coordinate of the GUI Object
+     * @param {object} settings - See {@link Sprite}
+     */
+    constructor(x, y, settings) {
+        warning("GUI_Object", "UISpriteElement", "14.0.0");
+        super(x, y, settings);
+    }
+}
+
+export { DraggableEntity, DroptargetEntity, GUI_Object, warning };

package/dist/melonjs.mjs/level/level.js

@@ -0,0 +1,297 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import utils from '../utils/utils.js';
+import { emit, LEVEL_LOADED } from '../system/event.js';
+import state from '../state/state.js';
+import loader from '../loader/loader.js';
+import game from '../game.js';
+import TMXTileMap from './tiled/TMXTileMap.js';
+
+// our levels
+var levels = {};
+// level index table
+var levelIdx = [];
+// current level index
+var currentLevelIdx = 0;
+
+/**
+ * @ignore
+ */
+function safeLoadLevel(levelId, options, restart) {
+    // clean the destination container
+    options.container.reset();
+
+    // reset the renderer
+    game.reset();
+
+    // clean the current (previous) level
+    if (levels[level.getCurrentLevelId()]) {
+        levels[level.getCurrentLevelId()].destroy();
+    }
+
+    // update current level index
+    currentLevelIdx = levelIdx.indexOf(levelId);
+
+    // add the specified level to the game world
+    loadTMXLevel(levelId, options.container, options.flatten, options.setViewportBounds);
+
+    // publish the corresponding message
+    emit(LEVEL_LOADED, levelId);
+
+    // fire the callback
+    options.onLoaded(levelId);
+
+    if (restart) {
+        // resume the game loop if it was previously running
+        state.restart();
+    }
+}
+
+/**
+ * Load a TMX level
+ * @name loadTMXLevel
+ * @memberof level
+ * @private
+ * @param {string} levelId - level id
+ * @param {Container} container - target container
+ * @param {boolean} [flatten=true] - if true, flatten all objects into the given container
+ * @param {boolean} [setViewportBounds=false] - if true, set the viewport bounds to the map size, this should be set to true especially if adding a level to the game world container.
+ * @ignore
+ */
+function loadTMXLevel(levelId, container, flatten, setViewportBounds) {
+    var level = levels[levelId];
+
+    // reset the GUID generator
+    // and pass the level id as parameter
+    utils.resetGUID(levelId, level.nextobjectid);
+
+    // Tiled use 0,0 anchor coordinates
+    container.anchorPoint.set(0, 0);
+
+    // add all level elements to the target container
+    level.addTo(container, flatten, setViewportBounds);
+}
+
+
+/**
+ * a level manager. once ressources loaded, the level manager contains all references of defined levels.
+ * @namespace level
+ */
+
+var level = {
+
+    /**
+     * add a level into the game manager (usually called by the preloader)
+     * @name add
+     * @memberof level
+     * @public
+     * @param {string} format - level format (only "tmx" supported)
+     * @param {string} levelId - the level id (or name)
+     * @param {Function} [callback] - a function to be called once the level is loaded
+     * @returns {boolean} true if the level was loaded
+     */
+    add(format, levelId, callback) {
+        switch (format) {
+            case "tmx" :
+                // just load the level with the XML stuff
+                if (levels[levelId] == null) {
+                    //console.log("loading "+ levelId);
+                    levels[levelId] = new TMXTileMap(levelId, loader.getTMX(levelId));
+                    // level index
+                    levelIdx.push(levelId);
+                }
+                else {
+                    //console.log("level %s already loaded", levelId);
+                    return false;
+                }
+
+                // call the callback if defined
+                if (callback) {
+                    callback();
+                }
+                // true if level loaded
+                return true;
+
+            default :
+                throw new Error("no level loader defined for format " + format);
+        }
+    },
+
+    /**
+     * load a level into the game manager<br>
+     * (will also create all level defined entities, etc..)
+     * @name load
+     * @memberof level
+     * @public
+     * @param {string} levelId - level id
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @param {boolean} [options.setViewportBounds=true] - if true, set the viewport bounds to the map size
+     * @returns {boolean} true if the level was successfully loaded
+     * @example
+     * // the game assets to be be preloaded
+     * // TMX maps
+     * var resources = [
+     *     {name: "a4_level1",   type: "tmx",   src: "data/level/a4_level1.tmx"},
+     *     {name: "a4_level2",   type: "tmx",   src: "data/level/a4_level2.tmx"},
+     *     {name: "a4_level3",   type: "tmx",   src: "data/level/a4_level3.tmx"},
+     *     // ...
+     * ];
+     *
+     * // ...
+     *
+     * // load a level into the game world
+     * me.level.load("a4_level1");
+     * ...
+     * ...
+     * // load a level into a specific container
+     * var levelContainer = new me.Container();
+     * me.level.load("a4_level2", {container:levelContainer});
+     * // add a simple transformation
+     * levelContainer.currentTransform.translate(levelContainer.width / 2, levelContainer.height / 2 );
+     * levelContainer.currentTransform.rotate(0.05);
+     * levelContainer.currentTransform.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
+     * // add it to the game world
+     * me.game.world.addChild(levelContainer);
+     */
+    load(levelId, options) {
+        options = Object.assign({
+            "container"         : game.world,
+            "onLoaded"          : game.onLevelLoaded,
+            "flatten"           : game.mergeGroup,
+            "setViewportBounds" : true
+        }, options || {});
+
+        // throw an exception if not existing
+        if (typeof(levels[levelId]) === "undefined") {
+            throw new Error("level " + levelId + " not found");
+        }
+
+        if (levels[levelId] instanceof TMXTileMap) {
+
+            // check the status of the state mngr
+            var wasRunning = state.isRunning();
+
+            if (wasRunning) {
+                // stop the game loop to avoid
+                // some silly side effects
+                state.stop();
+
+                utils.function.defer(safeLoadLevel, this, levelId, options, true);
+            }
+            else {
+                safeLoadLevel(levelId, options);
+            }
+        }
+        else {
+            throw new Error("no level loader defined");
+        }
+        return true;
+    },
+
+    /**
+     * return the current level id<br>
+     * @name getCurrentLevelId
+     * @memberof level
+     * @public
+     * @returns {string}
+     */
+    getCurrentLevelId() {
+        return levelIdx[currentLevelIdx];
+    },
+
+    /**
+     * return the current level definition.
+     * for a reference to the live instantiated level,
+     * rather use the container in which it was loaded (e.g. me.game.world)
+     * @name getCurrentLevel
+     * @memberof level
+     * @public
+     * @returns {TMXTileMap}
+     */
+    getCurrentLevel() {
+        return levels[this.getCurrentLevelId()];
+    },
+
+    /**
+     * reload the current level
+     * @name reload
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {object} the current level
+     */
+    reload(options) {
+        // reset the level to initial state
+        //levels[currentLevel].reset();
+        return this.load(this.getCurrentLevelId(), options);
+    },
+
+    /**
+     * load the next level
+     * @name next
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {boolean} true if the next level was successfully loaded
+     */
+    next(options) {
+        //go to the next level
+        if (currentLevelIdx + 1 < levelIdx.length) {
+            return this.load(levelIdx[currentLevelIdx + 1], options);
+        }
+        else {
+            return false;
+        }
+    },
+
+    /**
+     * load the previous level<br>
+     * @name previous
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {boolean} true if the previous level was successfully loaded
+     */
+    previous(options) {
+        // go to previous level
+        if (currentLevelIdx - 1 >= 0) {
+            return this.load(levelIdx[currentLevelIdx - 1], options);
+        }
+        else {
+            return false;
+        }
+    },
+
+    /**
+     * return the amount of level preloaded
+     * @name levelCount
+     * @memberof level
+     * @public
+     * @returns {number} the amount of level preloaded
+     */
+    levelCount() {
+        return levelIdx.length;
+    }
+
+};
+
+var level$1 = level;
+
+export { level$1 as default };

package/dist/melonjs.mjs/level/tiled/TMXGroup.js

@@ -0,0 +1,141 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { applyTMXProperties } from './TMXUtils.js';
+import TMXObject from './TMXObject.js';
+import TMXLayer from './TMXLayer.js';
+import { clamp } from '../../math/math.js';
+
+/**
+ * @classdesc
+ * object group definition as defined in Tiled.
+ * (group definition is translated into the virtual `me.game.world` using `me.Container`)
+ * @ignore
+ */
+class TMXGroup {
+
+    constructor(map, data, z) {
+
+        /**
+         * group name
+         * @public
+         * @type {string}
+         * @name name
+         * @memberof TMXGroup
+         */
+        this.name = data.name;
+
+        /**
+         * group width
+         * @public
+         * @type {number}
+         * @name width
+         * @memberof TMXGroup
+         */
+        this.width = data.width || 0;
+
+        /**
+         * group height
+         * @public
+         * @type {number}
+         * @name height
+         * @memberof TMXGroup
+         */
+        this.height = data.height || 0;
+
+        /**
+         * tint color
+         * @public
+         * @type {string}
+         * @name tintcolor
+         * @memberof TMXGroup
+         */
+        this.tintcolor = data.tintcolor;
+
+
+        /**
+         * the group class
+         * @public
+         * @type {string}
+         * @name class
+         * @memberof TMXGroup
+         */
+        this.class = data.class;
+
+        /**
+         * group z order
+         * @public
+         * @type {number}
+         * @name z
+         * @memberof TMXGroup
+         */
+        this.z = z;
+
+        /**
+         * group objects list definition
+         * @see TMXObject
+         * @public
+         * @type {object[]}
+         * @name name
+         * @memberof TMXGroup
+         */
+        this.objects = [];
+
+        var visible = typeof(data.visible) !== "undefined" ? data.visible : true;
+        this.opacity = (visible === true) ? clamp(+data.opacity || 1.0, 0.0, 1.0) : 0;
+
+        // check if we have any user-defined properties
+        applyTMXProperties(this, data);
+
+        // parse all child objects/layers
+        if (data.objects) {
+            data.objects.forEach((object) => {
+                object.tintcolor = this.tintcolor;
+                this.objects.push(new TMXObject(map, object, z));
+            });
+        }
+
+        if (data.layers) {
+            data.layers.forEach((data) => {
+                var layer = new TMXLayer(map, data, map.tilewidth, map.tileheight, map.orientation, map.tilesets, z++);
+                // set a renderer
+                layer.setRenderer(map.getRenderer());
+                // resize container accordingly
+                this.width = Math.max(this.width, layer.width);
+                this.height = Math.max(this.height, layer.height);
+                this.objects.push(layer);
+            });
+        }
+    }
+
+    /**
+     * reset function
+     * @ignore
+     */
+    destroy() {
+        // clear all allocated objects
+        this.objects = null;
+    }
+
+    /**
+     * return the object count
+     * @ignore
+     */
+    getObjectCount() {
+        return this.objects.length;
+    }
+
+    /**
+     * returns the object at the specified index
+     * @ignore
+     */
+    getObjectByIndex(idx) {
+        return this.objects[idx];
+    }
+}
+
+export { TMXGroup as default };