[#1091] World physic implementation is now properly tight to its corresponding parent application/game

obiot · obiot · commit 6db8b8e610e0 · 2022-07-12T09:22:30.000+08:00
no more direct reference to the global namespace:
- world is now properly attached to an "Application"
- Body are now properly updated based on their "parent" world gravity
- Quadtree also now refers to its parent World when required
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - Core: full ES6 refactoring of `me.device`, and API clean-up (@see https://github.com/melonjs/melonJS/wiki/Upgrade-Guide#120x-to-130x-stable)
 - Loader: `onload` and `onerror` callbacks are now optionals when directly loading assets (easier with base64 encoded assets)
 - Game: refactoring of the global `game` into an instantiable `Application` object, with `game` now being the default instance of it (@see #1091)
+- Physic: World physic implementation is now properly tight to its corresponding parent application/game (@see #1091)
 
 ### Fixed
 - Loader: fix loading/preloading of base64 audio assets, and base64 encoded FontFace
diff --git a/src/application/application.js b/src/application/application.js
@@ -84,7 +84,10 @@ class Application {
      * 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();
         event.emit(event.GAME_INIT, this);
     }
diff --git a/src/physics/body.js b/src/physics/body.js
@@ -7,8 +7,6 @@ import collision from "./collision.js";
 import * as arrayUtil from "./../utils/array.js";
 import timer from "./../system/timer.js";
 import { clamp } from "./../math/math.js";
-import game from "./../game.js";
-
 
 /**
  * @classdesc
@@ -463,10 +461,12 @@ class Body {
                 this.vel.y *= -this.bounce;
             }
 
-            // cancel the falling an jumping flags if necessary
-            var dir = Math.sign(game.world.gravity.y * this.gravityScale) || 1;
-            this.falling = overlap.y >= dir;
-            this.jumping = overlap.y <= -dir;
+            if (!this.ignoreGravity) {
+                // cancel the falling an jumping flags if necessary
+                var dir = this.falling === true ? 1 : this.jumping === true ? -1 : 0;
+                this.falling = overlap.y >= dir;
+                this.jumping = overlap.y <= -dir;
+            }
         }
     }
 
@@ -507,14 +507,12 @@ class Body {
         }
     }
 
-
     /**
      * Returns true if the any of the shape composing the body contains the given point.
      * @method Body#contains
      * @param {Vector2d} point
      * @returns {boolean} true if contains
      */
-
     /**
      * Returns true if the any of the shape composing the body contains the given point.
      * @param  {number} x x coordinate
@@ -591,27 +589,23 @@ class Body {
     }
 
     /**
-     * compute the new velocity value
-     * @ignore
+     * Updates the parent's position as well as computes the new body's velocity based
+     * on the values of force/friction.  Velocity chages are proportional to the
+     * me.timer.tick value (which can be used to scale velocities).  The approach to moving the
+     * parent renderable is to compute new values of the Body.vel property then add them to
+     * the parent.pos value thus changing the postion the amount of Body.vel each time the
+     * update call is made. <br>
+     * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
+     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
+     * @protected
+     * @param {number} dt time since the last update in milliseconds.
+     * @returns {boolean} true if resulting velocity is different than 0
      */
-    computeVelocity(/* dt */) {
+    update(dt) { // eslint-disable-line no-unused-vars
         // apply timer.tick to delta time for linear interpolation (when enabled)
         // #761 add delta time in body update
         var deltaTime = /* dt * */ timer.tick;
 
-        // apply gravity to the current velocity
-        if (!this.ignoreGravity) {
-            var worldGravity = game.world.gravity;
-
-            // apply gravity if defined
-            this.vel.x += worldGravity.x * this.gravityScale * deltaTime;
-            this.vel.y += worldGravity.y * this.gravityScale * deltaTime;
-
-            // check if falling / jumping
-            this.falling = (this.vel.y * Math.sign(worldGravity.y * this.gravityScale)) > 0;
-            this.jumping = (this.falling ? false : this.jumping);
-        }
-
         // apply force if defined
         if (this.force.x !== 0) {
             this.vel.x += this.force.x * deltaTime;
@@ -649,28 +643,6 @@ class Body {
         if (this.vel.x !== 0) {
             this.vel.x = clamp(this.vel.x, -this.maxVel.x, this.maxVel.x);
         }
-    }
-
-    /**
-     * Updates the parent's position as well as computes the new body's velocity based
-     * on the values of force/friction/gravity.  Velocity chages are proportional to the
-     * me.timer.tick value (which can be used to scale velocities).  The approach to moving the
-     * parent renderable is to compute new values of the Body.vel property then add them to
-     * the parent.pos value thus changing the postion the amount of Body.vel each time the
-     * update call is made. <br>
-     * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
-     *
-     * In addition, when the gravity calcuation is made, if the Body.vel.y > 0 then the Body.falling
-     * property is set to true and Body.jumping is set to !Body.falling.
-     *
-     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
-     * @protected
-     * @param {number} dt time since the last update in milliseconds.
-     * @returns {boolean} true if resulting velocity is different than 0
-     */
-    update(dt) {
-        // update the velocity
-        this.computeVelocity(dt);
 
         // update the body ancestor position
         this.ancestor.pos.add(this.vel);
diff --git a/src/physics/quadtree.js b/src/physics/quadtree.js
@@ -1,7 +1,6 @@
 import Vector2d from "./../math/vector2.js";
 import Container from "./../renderable/container.js";
 import * as arrayUtil from "./../utils/array.js";
-import game from "./../game.js";
 
 /*
  * A QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
@@ -21,16 +20,17 @@ var QT_ARRAY = [];
  * or create a new one if the array is empty
  * @ignore
  */
-function QT_ARRAY_POP(bounds, max_objects = 4, max_levels = 4, level = 0) {
+function QT_ARRAY_POP(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
     if (QT_ARRAY.length > 0) {
         var _qt =  QT_ARRAY.pop();
+        _qt.world = world;
         _qt.bounds = bounds;
         _qt.max_objects = max_objects;
         _qt.max_levels  = max_levels;
         _qt.level = level;
         return _qt;
     } else {
-        return new QuadTree(bounds, max_objects, max_levels, level);
+        return new QuadTree(world, bounds, max_objects, max_levels, level);
     }
 };
 
@@ -55,12 +55,17 @@ var QT_VECTOR = new Vector2d();
  */
 class QuadTree {
     /**
+     * @param {World} world the physic world this QuadTree belongs to
      * @param {Bounds} bounds bounds of the node
      * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
      * @param {number} [max_levels=4] total max levels inside root Quadtree
      * @param {number} [level] deepth level, required for subnodes
      */
-    constructor(bounds, max_objects = 4, max_levels = 4, level = 0) {
+    constructor(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
+
+        this.world = world;
+        this.bounds = bounds;
+
         this.max_objects = max_objects;
         this.max_levels  = max_levels;
 
@@ -82,36 +87,60 @@ class QuadTree {
             top = this.bounds.top;
 
          //top right node
-        this.nodes[0] = QT_ARRAY_POP({
-            left : left + subWidth,
-            top : top,
-            width : subWidth,
-            height : subHeight
-        }, this.max_objects, this.max_levels, nextLevel);
+        this.nodes[0] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left + subWidth,
+                top : top,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels,
+            nextLevel
+        );
 
         //top left node
-        this.nodes[1] = QT_ARRAY_POP({
-            left : left,
-            top: top,
-            width : subWidth,
-            height : subHeight
-        }, this.max_objects, this.max_levels, nextLevel);
+        this.nodes[1] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left,
+                top: top,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels,
+            nextLevel
+        );
 
         //bottom left node
-        this.nodes[2] = QT_ARRAY_POP({
-            left : left,
-            top : top + subHeight,
-            width : subWidth,
-            height : subHeight
-        }, this.max_objects, this.max_levels, nextLevel);
+        this.nodes[2] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left,
+                top : top + subHeight,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels,
+            nextLevel
+        );
 
         //bottom right node
-        this.nodes[3] = QT_ARRAY_POP({
-            left : left + subWidth,
-            top : top + subHeight,
-            width : subWidth,
-            height : subHeight
-        }, this.max_objects, this.max_levels, nextLevel);
+        this.nodes[3] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left + subWidth,
+                top : top + subHeight,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels,
+            nextLevel
+        );
     }
 
     /*
@@ -125,7 +154,7 @@ class QuadTree {
 
         // use game world coordinates for floating items
         if (item.isFloating === true) {
-            pos = game.viewport.localToWorld(bounds.left, bounds.top, QT_VECTOR);
+            pos = this.world.app.viewport.localToWorld(bounds.left, bounds.top, QT_VECTOR);
         } else {
             pos = QT_VECTOR.set(item.left, item.top);
         }
diff --git a/src/physics/world.js b/src/physics/world.js
@@ -5,6 +5,7 @@ import Container from "./../renderable/container.js";
 import collision from "./collision.js";
 import { collisionCheck } from "./detector.js";
 import state from "./../state/state.js";
+import timer from "./../system/timer.js";
 
 /**
  * @classdesc
@@ -28,6 +29,13 @@ class World extends Container {
         // to mimic the previous behavior
         this.anchorPoint.set(0, 0);
 
+        /**
+         * the application (game) this physic world belong to
+         * @public
+         * @type {Application}
+         */
+        this.app = null;
+
         /**
          * the rate at which the game world is updated,
          * may be greater than or lower than the display fps
@@ -80,7 +88,7 @@ class World extends Container {
          * @public
          * @type {QuadTree}
          */
-        this.broadphase = new QuadTree(this.getBounds().clone(), collision.maxChildren, collision.maxDepth);
+        this.broadphase = new QuadTree(this, this.getBounds().clone(), collision.maxChildren, collision.maxDepth);
 
         // reset the world container on the game reset signal
         event.on(event.GAME_RESET, this.reset, this);
@@ -140,14 +148,41 @@ class World extends Container {
         return this;
     }
 
+    /**
+     * Apply gravity to the given body
+     * @name bodyApplyVelocity
+     * @memberof World
+     * @private
+     * @param {Body} body
+     * @param {number} dt the time passed since the last frame update
+     */
+    bodyApplyGravity(body, dt) { // eslint-disable-line no-unused-vars
+        // apply timer.tick to delta time for linear interpolation (when enabled)
+        // #761 add delta time in body update
+        var deltaTime = /*dt * */ timer.tick;
+
+        // apply gravity to the current velocity
+        if (!body.ignoreGravity) {
+            var worldGravity = this.gravity;
+
+            // apply gravity if defined
+            body.vel.x += worldGravity.x * body.gravityScale * deltaTime;
+            body.vel.y += worldGravity.y * body.gravityScale * deltaTime;
+
+            // check if falling / jumping
+            body.falling = (body.vel.y * Math.sign(worldGravity.y * body.gravityScale)) > 0;
+            body.jumping = (body.falling ? false : body.jumping);
+        }
+    }
+
     /**
      * update the game world
      * @name reset
      * @memberof World
      * @param {number} dt the time passed since the last frame update
      * @returns {boolean} true if the word is dirty
      */
-    update (dt) {
+    update(dt) {
         var isPaused = state.isPaused();
 
         // clear the quadtree
@@ -163,7 +198,9 @@ class World extends Container {
                 // if the game is not paused, and ancestor can be updated
                 if (!(isPaused && (!ancestor.updateWhenPaused)) &&
                    (ancestor.inViewport || ancestor.alwaysUpdate)) {
-                    // apply physics to the body (this moves it)
+                    // apply gravity to this body
+                    this.bodyApplyGravity(body, dt);
+                    // body update function (this moves it)
                     if (body.update(dt) === true) {
                         // mark ancestor as dirty
                         ancestor.isDirty = true;
