Single functions to handle the data

Author: photonstorm

src/physics/arcade/CheckOverlap.js

@@ -0,0 +1,98 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2019 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var CollisionInfo = require('./CollisionInfo');
+var CONST = require('./const');
+
+/**
+ * Takes a CollisionInfo object and tests to see if the two bodies are still intersecting / touching.
+ *
+ * @function Phaser.Physics.Arcade.CheckOverlap
+ * @since 3.17.0
+ *
+ * @param {Phaser.Physics.Arcade.Body} body1 - The first Body to separate.
+ *
+ * @return {boolean} 
+ */
+var CheckOverlap = function (collisionInfo)
+{
+    collisionInfo = CollisionInfo.update(collisionInfo);
+
+    var face = collisionInfo.face;
+    var body1 = collisionInfo.body1;
+    var body2 = collisionInfo.body2;
+
+    switch (face)
+    {
+        case CONST.FACING_LEFT:
+            body1.setTouchingLeft();
+            body2.setTouchingRight();
+            body1.setBlockedLeft();
+            body2.setBlockedRight();
+            break;
+
+        case CONST.FACING_RIGHT:
+            body1.setTouchingRight();
+            body2.setTouchingLeft();
+            body1.setBlockedRight();
+            body2.setBlockedLeft();
+            break;
+
+        case CONST.FACING_UP:
+            body1.setTouchingUp();
+            body2.setTouchingDown();
+            body1.setBlockedUp();
+            body2.setBlockedDown();
+            break;
+
+        case CONST.FACING_DOWN:
+            body1.setTouchingDown();
+            body2.setTouchingUp();
+            body1.setBlockedDown();
+            body2.setBlockedUp();
+            break;
+    }
+
+    if (body1.isWorldBlockedLeft())
+    {
+        body2.setHardBlockedLeft();
+    }
+    else if (body2.isWorldBlockedLeft())
+    {
+        body1.setHardBlockedLeft();
+    }
+
+    if (body1.isWorldBlockedRight())
+    {
+        body2.setHardBlockedRight();
+    }
+    else if (body2.isWorldBlockedRight())
+    {
+        body1.setHardBlockedRight();
+    }
+
+    if (body1.isWorldBlockedUp())
+    {
+        body2.setHardBlockedUp();
+    }
+    else if (body2.isWorldBlockedUp())
+    {
+        body1.setHardBlockedUp();
+    }
+
+    if (body1.isWorldBlockedDown())
+    {
+        body2.setHardBlockedDown();
+    }
+    else if (body2.isWorldBlockedDown())
+    {
+        body1.setHardBlockedDown();
+    }
+
+    return collisionInfo.touching;
+};
+
+module.exports = CheckOverlap;

src/physics/arcade/GetOverlap.js

@@ -0,0 +1,111 @@
+/**
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    2019 Photon Storm Ltd.
+ * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+ */
+
+var CollisionInfo = require('./CollisionInfo');
+var CONST = require('./const');
+
+/**
+ * 
+ *
+ * @function Phaser.Physics.Arcade.GetOverlap
+ * @since 3.17.0
+ *
+ * @param {Phaser.Physics.Arcade.Body} body1 - The first Body to separate.
+ * @param {Phaser.Physics.Arcade.Body} body2 - The second Body to separate.
+ * @param {boolean} [overlapOnly] - Is this an overlap only check, or part of separation?
+ * @param {number} [bias] - A value added to the delta values during collision checks. Increase it to prevent sprite tunneling (sprites passing through each other instead of colliding).
+ *
+ * @return {CollisionInfo} A Collision Info object.
+ */
+var GetOverlap = function (body1, body2, overlapOnly, bias)
+{
+    if (overlapOnly === undefined) { overlapOnly = false; }
+    if (bias === undefined) { bias = 0; }
+
+    var collisionInfo = CollisionInfo.get(body1, body2, overlapOnly, bias);
+
+    if (overlapOnly)
+    {
+        return collisionInfo;
+    }
+
+    if (collisionInfo.face === CONST.FACING_LEFT)
+    {
+        console.log('GetOverlapX leftFace');
+
+        if (collisionInfo.body1 === body1)
+        {
+            body1.setTouchingLeft();
+            body2.setTouchingRight();
+
+            body1.setBlockedLeft(collisionInfo);
+            body2.setBlockedRight(collisionInfo);
+
+            if (body2.isWorldBlockedLeft())
+            {
+                body1.setHardBlockedLeft();
+            }
+        }
+    }
+    else if (collisionInfo.face === CONST.FACING_RIGHT)
+    {
+        console.log('GetOverlapX rightFace');
+
+        if (collisionInfo.body1 === body1)
+        {
+            body1.setTouchingRight();
+            body2.setTouchingLeft();
+
+            body1.setBlockedRight(collisionInfo);
+            body2.setBlockedLeft(collisionInfo);
+
+            if (body2.isWorldBlockedRight())
+            {
+                body1.setHardBlockedRight();
+            }
+        }
+    }
+    else if (collisionInfo.face === CONST.FACING_UP)
+    {
+        console.log('GetOverlapY topFace');
+
+        if (collisionInfo.body1 === body1)
+        {
+            body1.setTouchingUp();
+            body2.setTouchingDown();
+
+            body1.setBlockedUp(collisionInfo);
+            body2.setBlockedDown(collisionInfo);
+
+            if (body2.isWorldBlockedUp())
+            {
+                body1.setHardBlockedUp();
+            }
+        }
+    }
+    else if (collisionInfo.face === CONST.FACING_DOWN)
+    {
+        console.log('GetOverlapY bottomFace');
+
+        if (collisionInfo.body1 === body1)
+        {
+            body1.setTouchingDown();
+            body2.setTouchingUp();
+
+            body1.setBlockedDown(collisionInfo);
+            body2.setBlockedUp(collisionInfo);
+
+            if (body2.isWorldBlockedDown())
+            {
+                body1.setHardBlockedDown();
+            }
+        }
+    }
+
+    return collisionInfo;
+};
+
+module.exports = GetOverlap;