Refactored backend for convenience of unit-testing.

frontend/assets/scenes/login.fire

@@ -440,7 +440,7 @@
       "array": [
         0,
         0,
-        378.4531014537997,
+        372.39092362730867,
         0,
         0,
         0,

frontend/assets/scripts/Map.js

@@ -585,7 +585,7 @@ cc.Class({
     if (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START < rdf.id && window.RING_BUFF_CONSECUTIVE_SET == dumpRenderCacheRet) {
       /*
       Don't change 
-      - lastAllConfirmedRenderFrameId, it's updated only in "rollbackAndChase > _createRoomDownsyncFrameLocally" (except for when RING_BUFF_NON_CONSECUTIVE_SET) 
+      - lastAllConfirmedRenderFrameId, it's updated only in "rollbackAndChase > _createOrUpdateRoomDownsyncFrameLocally" (except for when RING_BUFF_NON_CONSECUTIVE_SET) 
       - chaserRenderFrameId, it's updated only in "onInputFrameDownsyncBatch" (except for when RING_BUFF_NON_CONSECUTIVE_SET)
       */
       return dumpRenderCacheRet;
@@ -945,7 +945,7 @@ cc.Class({
     }, 1500);
   },
 
-  _createRoomDownsyncFrameLocally(renderFrameId, collisionSys, collisionSysMap) {
+  _createOrUpdateRoomDownsyncFrameLocally(renderFrameId, collisionSys, collisionSysMap) {
     const self = this;
     const prevRenderFrameId = renderFrameId - 1;
     const inputFrameAppliedOnPrevRenderFrame = (
@@ -991,23 +991,6 @@ cc.Class({
       rdf.id > self.lastAllConfirmedRenderFrameId
     ) {
       // We got a more up-to-date "all-confirmed-render-frame".
-      let predictedRdf = self.recentRenderCache.getByFrameId(rdf.id);
-      if (null != predictedRdf) {
-        let renderFrameCorrectlyPredicted = true;
-        for (let playerId in predictedRdf.players) {
-          const predictedPlayer = predictedRdf.players[playerId];
-          const confirmedPlayer = rdf.players[playerId];
-          if (predictedPlayer.virtualGridX != confirmedPlayer.virtualGridX || predictedPlayer.virtualGridY != confirmedPlayer.virtualGridY) {
-            renderFrameCorrectlyPredicted = false;
-            break;
-          }
-        }
-
-        if (!renderFrameCorrectlyPredicted) {
-          // TODO: Can I also check whether the applied inputFrame on predictedRdf was "correctly predicted"? If it wasn't then a mismatch of positions is expected.
-          console.warn("render frame was incorrectly predicted\npredictedRdf=" + predictedRdf.toString() + "\nrdf=" + rdf.toString());
-        }
-      }
       self.lastAllConfirmedRenderFrameId = rdf.id;
       if (rdf.id > self.chaserRenderFrameId) {
         // it must be true that "chaserRenderFrameId >= lastAllConfirmedRenderFrameId"
@@ -1114,7 +1097,7 @@ cc.Class({
         }
       }
 
-      latestRdf = self._createRoomDownsyncFrameLocally(i + 1, collisionSys, collisionSysMap);
+      latestRdf = self._createOrUpdateRoomDownsyncFrameLocally(i + 1, collisionSys, collisionSysMap);
     }
 
     return latestRdf;

frontend/assets/scripts/TouchEventsManager.js

@@ -36,11 +36,11 @@ cc.Class({
       type: cc.Float
     },
     magicLeanLowerBound: {
-      default: 0.9, // Tangent of (PI/4) is 1.0.
+      default: 0.1,
       type: cc.Float
     },
     magicLeanUpperBound: {
-      default: 1.1,
+      default: 0.9,
       type: cc.Float
     },
     // For joystick ends.
@@ -265,16 +265,8 @@ cc.Class({
       return ret;
     }
 
-    if (Math.abs(continuousDx) < eps) {
-      ret.dx = 0;
-      if (0 < continuousDy) {
-        ret.dy = +2; // up
-        ret.encodedIdx = 1;
-      } else {
-        ret.dy = -2; // down
-        ret.encodedIdx = 2;
-      }
-    } else if (Math.abs(continuousDy) < eps) {
+    const criticalRatio = continuousDy / continuousDx;
+    if (Math.abs(criticalRatio) < this.magicLeanLowerBound) {
       ret.dy = 0;
       if (0 < continuousDx) {
         ret.dx = +2; // right 
@@ -283,50 +275,40 @@ cc.Class({
         ret.dx = -2; // left 
         ret.encodedIdx = 4;
       }
+    } else if (Math.abs(criticalRatio) > this.magicLeanUpperBound) {
+      ret.dx = 0;
+      if (0 < continuousDy) {
+        ret.dy = +2; // up
+        ret.encodedIdx = 1;
+      } else {
+        ret.dy = -2; // down
+        ret.encodedIdx = 2;
+      }
     } else {
-      const criticalRatio = continuousDy / continuousDx;
-      if (criticalRatio > this.magicLeanLowerBound && criticalRatio < this.magicLeanUpperBound) {
-        if (0 < continuousDx) {
+      if (0 < continuousDx) {
+        if (0 < continuousDy) {
           ret.dx = +1;
           ret.dy = +1;
           ret.encodedIdx = 5;
+        } else {
+          ret.dx = +1;
+          ret.dy = -1;
+          ret.encodedIdx = 7;
+        }
+      } else {
+        // 0 >= continuousDx
+        if (0 < continuousDy) {
+          ret.dx = -1;
+          ret.dy = +1;
+          ret.encodedIdx = 8;
         } else {
           ret.dx = -1;
           ret.dy = -1;
           ret.encodedIdx = 6;
         }
-      } else if (criticalRatio > -this.magicLeanUpperBound && criticalRatio < -this.magicLeanLowerBound) {
-        if (0 < continuousDx) {
-          ret.dx = +1;
-          ret.dy = -1;
-          ret.encodedIdx = 7;
-        } else {
-          ret.dx = -1;
-          ret.dy = +1;
-          ret.encodedIdx = 8;
-        }
-      } else {
-        if (Math.abs(criticalRatio) < 0.1) {
-          ret.dy = 0;
-          if (0 < continuousDx) {
-            ret.dx = +2; // right 
-            ret.encodedIdx = 3;
-          } else {
-            ret.dx = -2; // left 
-            ret.encodedIdx = 4;
-          }
-        } else if (Math.abs(criticalRatio) > 0.9) {
-          ret.dx = 0;
-          if (0 < continuousDy) {
-            ret.dy = +2; // up
-            ret.encodedIdx = 1;
-          } else {
-            ret.dy = -2; // down
-            ret.encodedIdx = 2;
-          }
-        }
       }
     }
+
     return ret;
   },