melonjs 14.0.2 → 14.1.1

package/README.md

@@ -161,6 +161,7 @@ melonJS 2 now only provides an ES6 Bundle :
 | build               | description |
 | ------------------- | ----------- |
 | `melonjs.module.js` | the ES6 Module (ESM) Bundle |
+| `melonjs.mjs` | a tree-shakeable ES6 Module Directory |
 | `melonjs.module.d.ts` | typescript declaration file for the ES6 Module (ESM) Bundle |
 
 >Note: if you need your application to be compatible with ES5, refer to our [boilerplate](https://github.com/melonjs/es6-boilerplate) that provides automatic transpiling to ES5.
@@ -203,6 +204,7 @@ Then build the melonJS source by running:
 
 The generated files will be available under the `build` directory :
 - `melonjs.module.js` : plain ES6 module
+- `melonjs.module.js` : a ES6 chunk directory used for tree-shaking
 - `melonjs.module.d.ts` : typescript declaration for the ES6 Module
 
 To run the melonJS test suite simply use the following:

package/dist/melonjs.mjs/_virtual/_commonjsHelpers.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export { commonjsGlobal };

package/dist/melonjs.mjs/_virtual/arraymultimap.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var arraymultimap = {};
+
+export { arraymultimap as __exports };

package/dist/melonjs.mjs/_virtual/earcut.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var earcut = {exports: {}};
+
+export { earcut as e };

package/dist/melonjs.mjs/_virtual/howler.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var howler = {};
+
+export { howler as __exports };

package/dist/melonjs.mjs/_virtual/index.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var src = {};
+
+export { src as __exports };

package/dist/melonjs.mjs/_virtual/index2.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var eventemitter3 = {exports: {}};
+
+export { eventemitter3 as e };

package/dist/melonjs.mjs/_virtual/multimap.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var multimap = {};
+
+export { multimap as __exports };

package/dist/melonjs.mjs/_virtual/setmultimap.js

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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)
+ */
+var setmultimap = {};
+
+export { setmultimap as __exports };

package/dist/melonjs.mjs/application/application.js

@@ -0,0 +1,238 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * 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 { renderer } from '../video/video.js';
+import { emit, GAME_INIT, GAME_RESET, GAME_BEFORE_UPDATE, GAME_UPDATE, GAME_AFTER_UPDATE, GAME_BEFORE_DRAW, GAME_AFTER_DRAW } from '../system/event.js';
+import timer from '../system/timer.js';
+import state from '../state/state.js';
+import World from '../physics/world.js';
+
+/**
+ * @classdesc
+ * An Application represents a single melonJS game.
+ * An Application is responsible for updating (each frame) all the related object status and draw them.
+ * @see game
+ */
+ class Application {
+    constructor() {
+        /**
+         * a reference to the current active stage "default" camera
+         * @public
+         * @type {Camera2d}
+         */
+        this.viewport = undefined;
+
+        /**
+         * a reference to the game world, <br>
+         * a world is a virtual environment containing all the game objects
+         * @public
+         * @type {World}
+         */
+        this.world = undefined;
+
+        /**
+         * when true, all objects will be added under the root world container.<br>
+         * When false, a `me.Container` object will be created for each corresponding groups
+         * @public
+         * @type {boolean}
+         * @default true
+         */
+        this.mergeGroup = true;
+
+        /**
+         * Specify the property to be used when sorting renderables.
+         * Accepted values : "x", "y", "z"
+         * @public
+         * @type {string}
+         * @default "z"
+         */
+        this.sortOn = "z";
+
+        /**
+         * Last time the game update loop was executed. <br>
+         * Use this value to implement frame prediction in drawing events,
+         * for creating smooth motion while running game update logic at
+         * a lower fps.
+         * @public
+         * @type {DOMHighResTimeStamp}
+         * @name lastUpdate
+         * @memberof Application
+         */
+        this.lastUpdate = 0;
+
+        // to know when we have to refresh the display
+        this.isDirty = true;
+
+        // always refresh the display when updatesPerSecond are lower than fps
+        this.isAlwaysDirty = false;
+
+        // frame counter for frameSkipping
+        // reset the frame counter
+        this.frameCounter = 0;
+        this.frameRate = 1;
+
+        // time accumulation for multiple update calls
+        this.accumulator = 0.0;
+        this.accumulatorMax = 0.0;
+        this.accumulatorUpdateDelta = 0;
+
+        // min update step size
+        this.stepSize = 1000 / 60;
+        this.updateDelta = 0;
+        this.lastUpdateStart = null;
+        this.updateAverageDelta = 0;
+    }
+
+    /**
+     * init the game instance (create a physic world, update starting time, etc..)
+     */
+    init() {
+        // create a new physic world
+        this.world = new World();
+        // set the reference to this application instance
+        this.world.app = this;
+        this.lastUpdate = globalThis.performance.now();
+        emit(GAME_INIT, this);
+    }
+
+    /**
+     * reset the game Object manager
+     * destroy all current objects
+     */
+    reset() {
+        // point to the current active stage "default" camera
+        var current = state.get();
+        if (typeof current !== "undefined") {
+            this.viewport = current.cameras.get("default");
+        }
+
+        // publish reset notification
+        emit(GAME_RESET);
+
+        // Refresh internal variables for framerate  limiting
+        this.updateFrameRate();
+    }
+
+    /**
+     * Fired when a level is fully loaded and all renderable instantiated. <br>
+     * Additionnaly the level id will also be passed to the called function.
+     * @example
+     * // call myFunction () everytime a level is loaded
+     * me.game.onLevelLoaded = this.myFunction.bind(this);
+     */
+    onLevelLoaded() {}
+
+    /**
+     * Update the renderer framerate using the system config variables.
+     * @see timer.maxfps
+     * @see World.fps
+     */
+    updateFrameRate() {
+        // reset the frame counter
+        this.frameCounter = 0;
+        this.frameRate = ~~(0.5 + 60 / timer.maxfps);
+
+        // set step size based on the updatesPerSecond
+        this.stepSize = (1000 / this.world.fps);
+        this.accumulator = 0.0;
+        this.accumulatorMax = this.stepSize * 10;
+
+        // display should always re-draw when update speed doesn't match fps
+        // this means the user intends to write position prediction drawing logic
+        this.isAlwaysDirty = (timer.maxfps > this.world.fps);
+    }
+
+    /**
+     * Returns the parent container of the specified Child in the game world
+     * @param {Renderable} child
+     * @returns {Container}
+     */
+    getParentContainer(child) {
+        return child.ancestor;
+    }
+
+    /**
+     * force the redraw (not update) of all objects
+     */
+    repaint() {
+        this.isDirty = true;
+    }
+
+    /**
+     * update all objects related to this game active scene/stage
+     * @param {number} time - current timestamp as provided by the RAF callback
+     * @param {Stage} stage - the current stage
+     */
+    update(time, stage) {
+        // handle frame skipping if required
+        if ((++this.frameCounter % this.frameRate) === 0) {
+            // reset the frame counter
+            this.frameCounter = 0;
+
+            // publish notification
+            emit(GAME_BEFORE_UPDATE, time);
+
+            this.accumulator += timer.getDelta();
+            this.accumulator = Math.min(this.accumulator, this.accumulatorMax);
+
+            this.updateDelta = (timer.interpolation) ? timer.getDelta() : this.stepSize;
+            this.accumulatorUpdateDelta = (timer.interpolation) ? this.updateDelta : Math.max(this.updateDelta, this.updateAverageDelta);
+
+            while (this.accumulator >= this.accumulatorUpdateDelta || timer.interpolation) {
+                this.lastUpdateStart = globalThis.performance.now();
+
+                // game update event
+                if (state.isPaused() !== true) {
+                    emit(GAME_UPDATE, time);
+                }
+
+                // update all objects (and pass the elapsed time since last frame)
+                this.isDirty = stage.update(this.updateDelta) || this.isDirty;
+
+                this.lastUpdate = globalThis.performance.now();
+                this.updateAverageDelta = this.lastUpdate - this.lastUpdateStart;
+
+                this.accumulator -= this.accumulatorUpdateDelta;
+                if (timer.interpolation) {
+                    this.accumulator = 0;
+                    break;
+                }
+            }
+
+            // publish notification
+            emit(GAME_AFTER_UPDATE, this.lastUpdate);
+        }
+    }
+
+    /**
+     * draw the active scene/stage associated to this game
+     * @param {Stage} stage - the current stage
+     */
+    draw(stage) {
+        if (renderer.isContextValid === true && (this.isDirty || this.isAlwaysDirty)) {
+            // publish notification
+            emit(GAME_BEFORE_DRAW, globalThis.performance.now());
+
+            // prepare renderer to draw a new frame
+            renderer.clear();
+
+            // render the stage
+            stage.draw(renderer);
+
+            // set back to flag
+            this.isDirty = false;
+
+            // flush/render our frame
+            renderer.flush();
+
+            // publish notification
+            emit(GAME_AFTER_DRAW, globalThis.performance.now());
+        }
+    }
+}
+
+export { Application as default };