melonjs 14.1.2 → 14.3.0

package/src/application/application.js

@@ -1,8 +1,32 @@
-import { renderer } from "./../video/video.js";
+import { autoDetectRenderer } from "../video/utils/autodetect.js";
+import CanvasRenderer from "./../video/canvas/canvas_renderer.js";
+import * as device from "./../system/device.js";
 import * as event from "./../system/event.js";
+import utils from "./../utils/utils.js";
 import timer from "./../system/timer.js";
 import state from "./../state/state.js";
 import World from "./../physics/world.js";
+import { onresize } from "./resize.js";
+import { defaultSettings } from "./settings.js";
+import { consoleHeader } from "./header.js";
+
+/**
+ * Select the HTML5 Canvas renderer
+ * @constant
+ */
+const CANVAS = 0;
+
+/**
+ * Select the WebGL renderer
+ * @constant
+ */
+const WEBGL = 1;
+
+/**
+ * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
+ * @constant
+ */
+const AUTO = 2;
 
 /**
  * @classdesc
@@ -11,10 +35,37 @@ import World from "./../physics/world.js";
  * @see game
  */
  export default class Application {
-    constructor() {
+    /**
+     * @param {number} width - The width of the canvas viewport
+     * @param {number} height - The height of the canvas viewport
+     * @param {object} [options] - The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
+     * @param {string|HTMLElement} [options.parent=document.body] - the DOM parent element to hold the canvas in the HTML file
+     * @param {number|Renderer} [options.renderer=video.AUTO] - renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO), or a custom renderer class
+     * @param {number|string} [options.scale=1.0] - enable scaling of the canvas ('auto' for automatic scaling)
+     * @param {string} [options.scaleMethod="fit"] - screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
+     * @param {boolean} [options.preferWebGL1=false] - if true the renderer will only use WebGL 1
+     * @param {string} [options.powerPreference="default"] - a hint to the user agent indicating what configuration of GPU is suitable for the WebGL context ("default", "high-performance", "low-power"). To be noted that Safari and Chrome (since version 80) both default to "low-power" to save battery life and improve the user experience on these dual-GPU machines.
+     * @param {boolean} [options.transparent=false] - whether to allow transparent pixels in the front buffer (screen).
+     * @param {boolean} [options.antiAlias=false] - whether to enable or not video scaling interpolation
+     * @param {boolean} [options.consoleHeader=true] - whether to display melonJS version and basic device information in the console
+     * @throws Will throw an exception if it fails to instantiate a renderer
+     */
+    constructor(width, height, options) {
+
+        /**
+         * the parent HTML element holding the main canvas of this application
+         * @type {HTMLElement}
+         */
+        this.parentElement = undefined;
+
         /**
-         * a reference to the current active stage "default" camera
-         * @public
+         * a reference to the active Canvas or WebGL active renderer renderer
+         * @type {CanvasRenderer|WebGLRenderer}
+         */
+        this.renderer = undefined;
+
+        /**
+         * the active stage "default" camera
          * @type {Camera2d}
          */
         this.viewport = undefined;
@@ -22,7 +73,6 @@ import World from "./../physics/world.js";
         /**
          * a reference to the game world, <br>
          * a world is a virtual environment containing all the game objects
-         * @public
          * @type {World}
          */
         this.world = undefined;
@@ -30,7 +80,6 @@ import World from "./../physics/world.js";
         /**
          * 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
          */
@@ -39,7 +88,6 @@ import World from "./../physics/world.js";
         /**
          * Specify the property to be used when sorting renderables.
          * Accepted values : "x", "y", "z"
-         * @public
          * @type {string}
          * @default "z"
          */
@@ -50,13 +98,23 @@ import World from "./../physics/world.js";
          * 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;
 
+        /**
+         * true when this app instance has been initialized
+         * @type {boolean}
+         * @default false
+         */
+        this.isInitialized = false;
+
+        /**
+         * the given settings used when creating this application
+         * @type {Object}
+         */
+        this.settings = undefined;
+
         // to know when we have to refresh the display
         this.isDirty = true;
 
@@ -78,17 +136,111 @@ import World from "./../physics/world.js";
         this.updateDelta = 0;
         this.lastUpdateStart = null;
         this.updateAverageDelta = 0;
+
+        // when using the default game application, legacy is set to true
+        // and init is called through the legacy video.init() call
+        if (options.legacy !== true) {
+            this.init(width, height, options);
+        }
     }
 
     /**
      * init the game instance (create a physic world, update starting time, etc..)
      */
-    init() {
+    init(width, height, options) {
+
+        this.settings = Object.assign(defaultSettings, options || {});
+
+        // sanitize potential given parameters
+        this.settings.width = width;
+        this.settings.height = height;
+        this.settings.transparent = !!(this.settings.transparent);
+        this.settings.antiAlias = !!(this.settings.antiAlias);
+        this.settings.failIfMajorPerformanceCaveat = !!(this.settings.failIfMajorPerformanceCaveat);
+        this.settings.subPixel = !!(this.settings.subPixel);
+        this.settings.verbose = !!(this.settings.verbose);
+        if (this.settings.scaleMethod.search(/^(fill-(min|max)|fit|flex(-(width|height))?|stretch)$/) !== -1) {
+            this.settings.autoScale = (this.settings.scale === "auto") || true;
+        } else {
+            // default scaling method
+            this.settings.scaleMethod = "fit";
+            this.settings.autoScale = (this.settings.scale === "auto") || false;
+        }
+
+        // override renderer settings if &webgl or &canvas is defined in the URL
+        var uriFragment = utils.getUriFragment();
+        if (uriFragment.webgl === true || uriFragment.webgl1 === true || uriFragment.webgl2 === true) {
+            this.settings.renderer = WEBGL;
+            if (uriFragment.webgl1 === true) {
+                this.settings.preferWebGL1 = true;
+            }
+        } else if (uriFragment.canvas === true) {
+            this.settings.renderer = CANVAS;
+        }
+
+        // normalize scale
+        this.settings.scale = (this.settings.autoScale) ? 1.0 : (+this.settings.scale || 1.0);
+
+        // default scaled size value
+        this.settings.zoomX = width * this.settings.scale;
+        this.settings.zoomY = height * this.settings.scale;
+
+        if (typeof this.settings.renderer === "number") {
+            switch (this.settings.renderer) {
+                case AUTO:
+                case WEBGL:
+                    this.renderer = autoDetectRenderer(this.settings);
+                    break;
+                default:
+                    this.renderer = new CanvasRenderer(this.settings);
+                    break;
+            }
+        } else {
+            var CustomRenderer = this.settings.renderer;
+            // a renderer class
+            this.renderer = new CustomRenderer(this.settings);
+        }
+
+        // register to the channel
+        event.on(event.WINDOW_ONRESIZE, () => { onresize(this); }, this);
+        event.on(event.WINDOW_ONORIENTATION_CHANGE, () => { onresize(this); }, this);
+
+        // add our canvas (default to document.body if settings.parent is undefined)
+        this.parentElement = device.getElement(this.settings.parent);
+        this.parentElement.appendChild(this.renderer.getCanvas());
+
+        // Mobile browser hacks
+        if (device.platform.isMobile) {
+            // Prevent the webview from moving on a swipe
+            device.enableSwipe(false);
+        }
+
+        // trigger an initial resize();
+        onresize(this);
+
+        // add an observer to detect when the dom tree is modified
+        if ("MutationObserver" in globalThis) {
+            // Create an observer instance linked to the callback function
+            var observer = new MutationObserver(onresize.bind(this, this));
+
+            // Start observing the target node for configured mutations
+            observer.observe(this.parentElement, {
+                attributes: false, childList: true, subtree: true
+            });
+        }
+
+        if (this.settings.consoleHeader !== false) {
+            consoleHeader(this);
+        }
+
         // 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();
+
+        this.isInitialized = true;
+
         event.emit(event.GAME_INIT, this);
     }
 
@@ -140,12 +292,11 @@ import World from "./../physics/world.js";
     }
 
     /**
-     * Returns the parent container of the specified Child in the game world
-     * @param {Renderable} child
-     * @returns {Container}
+     * Returns the parent HTML Element holding the main canvas of this application
+     * @returns {HTMLElement}
      */
-    getParentContainer(child) {
-        return child.ancestor;
+    getParentElement() {
+        return this.parentElement;
     }
 
     /**
@@ -206,21 +357,21 @@ import World from "./../physics/world.js";
      * @param {Stage} stage - the current stage
      */
     draw(stage) {
-        if (renderer.isContextValid === true && (this.isDirty || this.isAlwaysDirty)) {
+        if (this.renderer.isContextValid === true && (this.isDirty || this.isAlwaysDirty)) {
             // publish notification
             event.emit(event.GAME_BEFORE_DRAW, globalThis.performance.now());
 
             // prepare renderer to draw a new frame
-            renderer.clear();
+            this.renderer.clear();
 
             // render the stage
-            stage.draw(renderer);
+            stage.draw(this.renderer);
 
             // set back to flag
             this.isDirty = false;
 
             // flush/render our frame
-            renderer.flush();
+            this.renderer.flush();
 
             // publish notification
             event.emit(event.GAME_AFTER_DRAW, globalThis.performance.now());

package/src/application/header.js

@@ -0,0 +1,25 @@
+import * as device from "../system/device";
+
+/**
+ * display information
+ * @param {Application} game - the game application instance calling this function
+ */
+export function consoleHeader(app) {
+    var renderType = app.renderer.type;
+    var gpu_renderer = (typeof app.renderer.GPURenderer === "string") ? " (" + app.renderer.GPURenderer + ")" : "";
+    var audioType = device.hasWebAudio ? "Web Audio" : "HTML5 Audio";
+
+    // output video information in the console
+    console.log(
+        renderType + " renderer" + gpu_renderer + " | " +
+        audioType + " | " +
+        "pixel ratio " + device.devicePixelRatio + " | " +
+        (device.platform.nodeJS ? "node.js" : device.platform.isMobile ? "mobile" : "desktop") + " | " +
+        device.getScreenOrientation() + " | " +
+        device.language
+    );
+
+    console.log( "resolution: " + "requested " + app.settings.width + "x" + app.settings.height +
+        ", got " + app.renderer.getWidth() + "x" + app.renderer.getHeight()
+    );
+}

package/src/application/resize.js

@@ -0,0 +1,110 @@
+import * as device from "./../system/device";
+
+/**
+ * scale the "displayed" canvas by the given scalar.
+ * this will modify the size of canvas element directly.
+ * Only use this if you are not using the automatic scaling feature.
+ * @param {Application} game - the game application instance triggering the resize
+ * @param {number} x - x scaling multiplier
+ * @param {number} y - y scaling multiplier
+ */
+function scale(game, x, y) {
+    var renderer = game.renderer;
+    var canvas = renderer.getCanvas();
+    var context = renderer.getContext();
+    var settings = renderer.settings;
+    var pixelRatio = device.devicePixelRatio;
+
+    var w = settings.zoomX = canvas.width * x * pixelRatio;
+    var h = settings.zoomY = canvas.height * y * pixelRatio;
+
+    // update the global scale variable
+    renderer.scaleRatio.set(x * pixelRatio, y * pixelRatio);
+
+    // adjust CSS style based on device pixel ratio
+    canvas.style.width = (w / pixelRatio) + "px";
+    canvas.style.height = (h / pixelRatio) + "px";
+
+    // if anti-alias and blend mode were resetted (e.g. Canvas mode)
+    renderer.setAntiAlias(context, settings.antiAlias);
+    renderer.setBlendMode(settings.blendMode, context);
+
+    // force repaint
+    game.repaint();
+}
+
+/**
+ * callback for window resize event
+ * @param {Application} game - the game application instance triggering the resize
+ */
+export function onresize(game) {
+    var renderer = game.renderer;
+    var settings = renderer.settings;
+    var scaleX = 1, scaleY = 1;
+
+    if (settings.autoScale) {
+
+        // set max the canvas max size if CSS values are defined
+        var canvasMaxWidth = Infinity;
+        var canvasMaxHeight = Infinity;
+
+        if (globalThis.getComputedStyle) {
+            var style = globalThis.getComputedStyle(renderer.getCanvas(), null);
+            canvasMaxWidth = parseInt(style.maxWidth, 10) || Infinity;
+            canvasMaxHeight = parseInt(style.maxHeight, 10) || Infinity;
+        }
+
+        // get the maximum canvas size within the parent div containing the canvas container
+        var nodeBounds = device.getParentBounds(game.getParentElement());
+
+        var _max_width = Math.min(canvasMaxWidth, nodeBounds.width);
+        var _max_height = Math.min(canvasMaxHeight, nodeBounds.height);
+
+        // calculate final canvas width & height
+        var screenRatio = _max_width / _max_height;
+
+        if ((settings.scaleMethod === "fill-min" && screenRatio > renderer.designRatio) ||
+            (settings.scaleMethod === "fill-max" && screenRatio < renderer.designRatio) ||
+            (settings.scaleMethod === "flex-width")
+        ) {
+            // resize the display canvas to fill the parent container
+            var sWidth = Math.min(canvasMaxWidth, settings.height * screenRatio);
+            scaleX = scaleY = _max_width / sWidth;
+            renderer.resize(Math.floor(sWidth), settings.height);
+        }
+        else if ((settings.scaleMethod === "fill-min" && screenRatio < renderer.designRatio) ||
+                 (settings.scaleMethod === "fill-max" && screenRatio > renderer.designRatio) ||
+                 (settings.scaleMethod === "flex-height")
+        ) {
+            // resize the display canvas to fill the parent container
+            var sHeight = Math.min(canvasMaxHeight, settings.width * (_max_height / _max_width));
+            scaleX = scaleY = _max_height / sHeight;
+            renderer.resize(settings.width, Math.floor(sHeight));
+        }
+        else if (settings.scaleMethod === "flex") {
+            // resize the display canvas to fill the parent container
+            renderer.resize(Math.floor(_max_width), Math.floor(_max_height));
+        }
+        else if (settings.scaleMethod === "stretch") {
+            // scale the display canvas to fit with the parent container
+            scaleX = _max_width / settings.width;
+            scaleY = _max_height / settings.height;
+        }
+        else {
+            // scale the display canvas to fit the parent container
+            // make sure we maintain the original aspect ratio
+            if (screenRatio < renderer.designRatio) {
+                scaleX = scaleY = _max_width / settings.width;
+            }
+            else {
+                scaleX = scaleY = _max_height / settings.height;
+            }
+        }
+
+        // adjust scaling ratio based on the new scaling ratio
+        scale(game, scaleX, scaleY);
+    } else {
+        // adjust scaling ratio based on the given settings
+        scale(game, settings.scale, settings.scale);
+    }
+}

package/src/application/settings.js

@@ -0,0 +1,19 @@
+// default settings
+export const defaultSettings = {
+    parent : undefined,
+    renderer : 2, // AUTO
+    autoScale : false,
+    scale : 1.0,
+    scaleMethod : "manual",
+    transparent : false,
+    premultipliedAlpha: true,
+    blendMode : "normal",
+    antiAlias : false,
+    failIfMajorPerformanceCaveat : true,
+    subPixel : false,
+    preferWebGL1 : false,
+    powerPreference : "default",
+    verbose : false,
+    consoleHeader : true,
+    legacy : false
+};

package/src/camera/camera2d.js

@@ -10,7 +10,7 @@ import * as event from "./../system/event.js";
 import pool from "./../system/pooling.js";
 import Renderable from "./../renderable/renderable.js";
 import {clamp, toBeCloseTo} from "./../math/math.js";
-import game from "./../game.js";
+import { game } from "../index.js";
 
 
 // some ref shortcut

package/src/index.js

@@ -1,24 +1,6 @@
 // ES5/ES6 polyfills
 import "./polyfill/index.js";
 
-// utility classes
-import * as audio from "./audio/audio.js";
-import collision from "./physics/collision.js";
-import * as event from "./system/event.js";
-import * as device from "./system/device.js";
-import game from "./game.js";
-import loader from "./loader/loader.js";
-import * as Math from "./math/math.js";
-import utils from "./utils/utils.js";
-import * as input from "./input/input.js";
-import { plugin, plugins } from "./plugin/plugin.js";
-import * as video from "./video/video.js";
-import save from "./system/save.js";
-import timer from "./system/timer.js";
-import pool from "./system/pooling.js";
-import state from "./state/state.js";
-import level from "./level/level.js";
-
 // class definition
 import Color from "./math/color.js";
 import Vector2d from "./math/vector2.js";
@@ -45,9 +27,6 @@ import CanvasRenderer from "./video/canvas/canvas_renderer.js";
 import CanvasTexture from "./video/texture/canvas_texture.js";
 import { TextureAtlas } from "./video/texture/atlas.js";
 import Renderable from "./renderable/renderable.js";
-import Text from "./text/text.js";
-import BitmapText from "./text/bitmaptext.js";
-import BitmapTextData from "./text/bitmaptextdata.js";
 import ColorLayer from "./renderable/colorlayer.js";
 import ImageLayer from "./renderable/imagelayer.js";
 import Sprite from "./renderable/sprite.js";
@@ -58,6 +37,9 @@ import UISpriteElement from "./renderable/ui/uispriteelement.js";
 import Collectable from "./renderable/collectable.js";
 import Trigger from "./renderable/trigger.js";
 import Light2d from "./renderable/light2d.js";
+import Text from "./text/text.js";
+import BitmapText from "./text/bitmaptext.js";
+import BitmapTextData from "./text/bitmaptextdata.js";
 import { Draggable, DropTarget } from "./renderable/dragndrop.js";
 import TMXRenderer from "./level/tiled/renderer/TMXRenderer.js";
 import TMXOrthogonalRenderer from "./level/tiled/renderer/TMXOrthogonalRenderer.js";
@@ -78,6 +60,24 @@ import ParticleEmitterSettings from "./particles/settings.js";
 import ParticleEmitter from "./particles/emitter.js";
 import Particle from "./particles/particle.js";
 import Entity from "./entity/entity.js";
+import Application from "./application/application.js";
+
+// utility classes
+import * as audio from "./audio/audio.js";
+import collision from "./physics/collision.js";
+import * as event from "./system/event.js";
+import * as device from "./system/device.js";
+import loader from "./loader/loader.js";
+import * as Math from "./math/math.js";
+import utils from "./utils/utils.js";
+import * as input from "./input/input.js";
+import { plugin, plugins } from "./plugin/plugin.js";
+import * as video from "./video/video.js";
+import save from "./system/save.js";
+import timer from "./system/timer.js";
+import pool from "./system/pooling.js";
+import state from "./state/state.js";
+import level from "./level/level.js";
 
 
 /**
@@ -95,7 +95,6 @@ export {
     collision,
     device,
     event,
-    game,
     loader,
     level,
     input,
@@ -169,7 +168,8 @@ export {
     ParticleEmitter,
     ParticleEmitterSettings,
     Particle,
-    Entity
+    Entity,
+    Application
 };
 
 // Backward compatibility for deprecated method or properties
@@ -192,6 +192,14 @@ export var initialized = false;
  */
 export var skipAutoInit = false;
 
+/*
+ * game is a default instance of a melonJS Application and represents your current game,
+ * it contains all the objects, tilemap layers, current viewport, collision map, etc...<br>
+ * @namespace game
+ * @see Application
+ */
+export const game = new Application(0, 0, {legacy:true});
+
 /**
  * initialize the melonJS library.
  * this is automatically called unless me.skipAutoInit is set to true,
@@ -206,6 +214,9 @@ export function boot() {
         return;
     }
 
+    // output melonJS version in the console
+    console.log("melonJS 2 (v" + version + ") | http://melonjs.org" );
+
     // register all built-ins objects into the object pool
     pool.register("me.Entity", Entity);
     pool.register("me.Collectable", Collectable);

package/src/input/pointer.js

@@ -1,6 +1,6 @@
 import Vector2d from "./../math/vector2.js";
 import Bounds from "./../physics/bounds.js";
-import game from "./../game.js";
+import { game } from "../index.js";
 import { globalToLocal } from "./input.js";
 import { locked } from "./pointerevent.js";
 

package/src/input/pointerevent.js

@@ -1,6 +1,6 @@
 import {preventDefault} from "./input.js";
 import {getBindingKey, triggerKeyEvent} from "./keyboard.js";
-import { renderer, scaleRatio, getParent } from "./../video/video.js";
+import { renderer } from "./../video/video.js";
 import { throttle } from "./../utils/function.js";
 import { remove } from "./../utils/array.js";
 import * as event from "./../system/event.js";
@@ -9,8 +9,7 @@ import pool from "./../system/pooling.js";
 import * as device from "./../system/device.js";
 import Pointer from "./pointer.js";
 import Rect from "./../geometries/rectangle.js";
-import Container from "./../renderable/container.js";
-import game from "./../game.js";
+import { game } from "../index.js";
 
 /**
  * A pool of `Pointer` objects to cache pointer/touch event coordinates.
@@ -195,7 +194,7 @@ function enablePointerEvent() {
         if (device.hasPointerLockSupport) {
             document.addEventListener("pointerlockchange", () => {
                 // change the locked status accordingly
-                locked = document.pointerLockElement === getParent();
+                locked = document.pointerLockElement === game.getParentElement();
                 // emit the corresponding internal event
                 event.emit(event.POINTERLOCKCHANGE, locked);
             }, true);
@@ -287,7 +286,7 @@ function dispatchEvent(normalizedEvents) {
         }
 
         // fetch valid candiates from the game world container
-        var candidates = game.world.broadphase.retrieve(currentPointer, Container.prototype._sortReverseZ);
+        var candidates = game.world.broadphase.retrieve(currentPointer, game.world._sortReverseZ);
 
         // add the main game viewport to the list of candidates
         candidates = candidates.concat([ game.viewport ]);
@@ -560,7 +559,7 @@ export function globalToLocal(x, y, v) {
     var pixelRatio = globalThis.devicePixelRatio || 1;
     x -= rect.left + (globalThis.pageXOffset || 0);
     y -= rect.top + (globalThis.pageYOffset || 0);
-    var scale = scaleRatio;
+    var scale = renderer.scaleRatio;
     if (scale.x !== 1.0 || scale.y !== 1.0) {
         x /= scale.x;
         y /= scale.y;
@@ -786,7 +785,7 @@ export function releaseAllPointerEvents(region) {
  */
 export function requestPointerLock() {
     if (device.hasPointerLockSupport) {
-        var element = getParent();
+        var element = game.getParentElement();
         element.requestPointerLock();
         return true;
     }

package/src/level/level.js

@@ -2,7 +2,7 @@ import utils from "./../utils/utils.js";
 import * as event from "./../system/event.js";
 import state from "./../state/state.js";
 import loader from "./../loader/loader.js";
-import game from "./../game.js";
+import { game } from "../index.js";
 import TMXTileMap from "./tiled/TMXTileMap.js";
 
 

package/src/level/tiled/TMXLayer.js

@@ -4,7 +4,7 @@ import * as TMXUtils from "./TMXUtils.js";
 import Tile from "./TMXTile.js";
 import Renderable from "./../../renderable/renderable.js";
 import CanvasRenderer from "./../../video/canvas/canvas_renderer";
-import game from "./../../game.js";
+import { game } from "../../index.js";
 
 /**
  * Create required arrays for the given layer object

package/src/level/tiled/TMXTileMap.js

@@ -1,6 +1,6 @@
 import pool from "./../../system/pooling.js";
 import * as event from "./../../system/event.js";
-import game from "./../../game.js";
+import { game } from "../../index.js";
 import collision from "./../../physics/collision.js";
 import Body from "./../../physics/body.js";
 import TMXOrthogonalRenderer from "./renderer/TMXOrthogonalRenderer.js";
@@ -12,7 +12,7 @@ import TMXTilesetGroup from "./TMXTilesetGroup.js";
 import TMXGroup from "./TMXGroup.js";
 import TMXLayer from "./TMXLayer.js";
 import { applyTMXProperties } from "./TMXUtils.js";
-import Container from "./../../renderable/container.js";
+import Container from "../../renderable/container.js";
 
 // constant to identify the collision object layer
 const COLLISION_GROUP = "collision";

package/src/loader/loadingscreen.js

@@ -1,4 +1,4 @@
-import game from "./../game.js";
+import { game } from "../index.js";
 import { renderer } from "./../video/video.js";
 import * as event from "./../system/event.js";
 import Sprite from "./../renderable/sprite.js";