Enhanced logging efficiency.

README.md

@@ -120,6 +120,24 @@ When building for native platforms, it's much more convenient to trigger the Coc
 ```
 shell> cd <proj-root>
 shell> /path/to/CocosCreator.exe --path ./frontend --build "platform=win32;debug=true"
+shell> cd ./frontend/build/jsb-link/frameworks/runtime-src/proj.win32 && MSBUILD DelayNoMore.vcxproj -property:Configuration=Debug
+```
+or 
+```
+shell> cd <proj-root>
+shell> /path/to/CocosCreator.exe --path ./frontend --build "platform=win32;debug=false"
+shell> cd ./frontend/build/jsb-link/frameworks/runtime-src/proj.win32 && MSBUILD DelayNoMore.vcxproj -property:Configuration=Release
+```
+
+for release.
+
+If `MSBUILD` command is not yet added to `PATH`, Use `Get-Command MSBUILD` in `Developer Command Prompt for VS 2017/2019` to see where the command should come from and add it to `PATH`.
+
+Similarly for Android release build
+```
+shell> cd <proj-root>
+shell> /path/to/CocosCreator.exe --path ./frontend --build "platform=android;debug=false"
+shell> cd ./frontend/build/jsb-link/frameworks/runtime-src/proj.android-studio && ./gradlew assembleRelease
 ```
 
 ### 2.4 CococCreator native build reloading

frontend/assets/scenes/login.fire

@@ -461,7 +461,7 @@
       "array": [
         0,
         0,
-        216.65450766436658,
+        210.4441731196186,
         0,
         0,
         0,

frontend/assets/scenes/offline_map.fire

@@ -549,7 +549,7 @@
       "array": [
         0,
         0,
-        216.65450766436658,
+        210.4441731196186,
         0,
         0,
         0,

frontend/assets/scripts/Map.js

@@ -385,6 +385,7 @@ cc.Class({
     self.rdfIdToActuallyUsedInput = new Map();
 
     self.networkDoctor = new NetworkDoctor(20);
+    self.allowSkippingRenderFrameFlag = true;
     self.skipRenderFrameFlag = false;
 
     self.allowRollbackOnPeerUpsync = true;
@@ -443,7 +444,7 @@ cc.Class({
   },
 
   onLoad() {
-    cc.game.setFrameRate(59);
+    cc.game.setFrameRate(60);
     cc.view.setOrientation(cc.macro.ORIENTATION_LANDSCAPE);
     cc.view.enableAutoFullScreen(true);
 
@@ -902,12 +903,15 @@ cc.Class({
     --------------------------------------------------------
     */
     // The actual rollback-and-chase would later be executed in update(dt). 
-    console.log(`Mismatched input detected, resetting chaserRenderFrameId: ${self.chaserRenderFrameId}->${renderFrameId1} by 
+    if (CC_DEBUG) {
+      // Printing of this message might induce a performance impact.
+      console.log(`Mismatched input detected, resetting chaserRenderFrameId: ${self.chaserRenderFrameId}->${renderFrameId1} by 
 firstPredictedYetIncorrectInputFrameId: ${firstPredictedYetIncorrectInputFrameId}
 lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}
 recentInputCache=${self._stringifyRecentInputCache(false)}
 batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inputFrameId}]
 fromUDP=${fromUDP}`);
+    }
     self.chaserRenderFrameId = renderFrameId1;
     let rollbackFrames = (self.renderFrameId - self.chaserRenderFrameId);
     if (0 > rollbackFrames) {
@@ -965,7 +969,7 @@ fromUDP=${fromUDP}`);
       //console.log(`Updated encoded input of peerJoinIndex=${peerJoinIndex} to ${peerEncodedInput} for inputFrameId=${inputFrameId}/renderedInputFrameIdUpper=${renderedInputFrameIdUpper} from ${JSON.stringify(inputFrame)}; newInputFrameDownsyncLocal=${self.gopkgsInputFrameDownsyncStr(newInputFrameDownsyncLocal)}; existingInputFrame=${self.gopkgsInputFrameDownsyncStr(existingInputFrame)}`);
       self.recentInputCache.SetByFrameId(newInputFrameDownsyncLocal, inputFrameId);
 
-      if (self.allowRollbackOnPeerUpsync) {
+      if (true == self.allowRollbackOnPeerUpsync) {
         // Reaching here implies that "true == self.allowRollbackOnPeerUpsync".
         // Shall we update the "chaserRenderFrameId" if the rendered history was wrong? It doesn't seem to impact eventual correctness if we allow the update of "chaserRenderFrameId" upon "inputFrameId <= renderedInputFrameIdUpper" here, however UDP upsync doesn't reserve order from a same sender and there might be multiple other senders, hence it might result in unnecessarily frequent chasing.
         if (
@@ -1048,7 +1052,7 @@ fromUDP=${fromUDP}`);
 
       Kindly note that Significantly different network bandwidths or delay fluctuations would result in frequent [type#1 forceConfirmation] too, but CAUSE FROM DIFFERENT LOCAL "update(dt)" RATE SHOULD BE THE FIRST TO INVESTIGATE AND ELIMINATE -- because we have control on it, but no one has control on the internet. 
       */
-      if (self.skipRenderFrameFlag) {
+      if (self.allowSkippingRenderFrameFlag && self.skipRenderFrameFlag) {
         self.networkDoctor.logSkippedRenderFrameCnt();
         self.skipRenderFrameFlag = false;
         return;
@@ -1125,7 +1129,9 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
         self.lastRenderFrameIdTriggeredAt = performance.now();
         let t3 = performance.now();
         const [skipRenderFrameFlag, inputFrameIdFront, sendingFps, srvDownsyncFps, peerUpsyncFps, doctorRollbackFrames, skippedRenderFrameCnt] = self.networkDoctor.isTooFast(self);
-        self.skipRenderFrameFlag = skipRenderFrameFlag;
+        if (self.allowSkippingRenderFrameFlag) {
+          self.skipRenderFrameFlag = skipRenderFrameFlag;
+        }
         if (self.showNetworkDoctorInfo) {
           self.showNetworkDoctorLabels(inputFrameIdFront, sendingFps, srvDownsyncFps, peerUpsyncFps, doctorRollbackFrames, skippedRenderFrameCnt);
         }

frontend/assets/scripts/NetworkDoctor.js

@@ -89,23 +89,28 @@ NetworkDoctor.prototype.isTooFast = function(mapIns) {
   const [inputFrameIdFront, sendingFps, srvDownsyncFps, peerUpsyncFps, rollbackFrames, skippedRenderFrameCnt] = this.stats();
   if (sendingFps >= this.inputRateThreshold + 3) {
     // Don't send too fast
-    console.log(`Sending too fast, sendingFps=${sendingFps}`);
+    if (CC_DEBUG) {    
+      // Printing of this message might induce a performance impact.
+      console.log(`Sending too fast, sendingFps=${sendingFps}`);
+    }
     return [true, inputFrameIdFront, sendingFps, srvDownsyncFps, peerUpsyncFps, rollbackFrames, skippedRenderFrameCnt];
   } else {
     const sendingFpsNormal = (sendingFps >= this.inputRateThreshold);
     // An outstanding lag within the "inputFrameDownsyncQ" will reduce "srvDownsyncFps", HOWEVER, a constant lag wouldn't impact "srvDownsyncFps"! In native platforms we might use PING value might help as a supplement information to confirm that the "selfPlayer" is not lagged within the time accounted by "inputFrameDownsyncQ".  
     const recvFpsNormal = (srvDownsyncFps >= this.inputRateThreshold || peerUpsyncFps >= this.inputRateThreshold * (window.boundRoomCapacity - 1));
     if (sendingFpsNormal && recvFpsNormal) {
-      let selfInputFrameIdFront = gopkgs.ConvertToNoDelayInputFrameId(mapIns.renderFrameId);
       let minInputFrameIdFront = Number.MAX_VALUE;
       for (let k = 0; k < window.boundRoomCapacity; ++k) {
         if (k + 1 == mapIns.selfPlayerInfo.JoinIndex) continue;
         if (mapIns.lastIndividuallyConfirmedInputFrameId[k] >= minInputFrameIdFront) continue;
         minInputFrameIdFront = mapIns.lastIndividuallyConfirmedInputFrameId[k];
       }
-      if ((selfInputFrameIdFront > minInputFrameIdFront) && ((selfInputFrameIdFront - minInputFrameIdFront) > (mapIns.inputFrameUpsyncDelayTolerance + 1))) {
+      if ((inputFrameIdFront > minInputFrameIdFront) && ((inputFrameIdFront - minInputFrameIdFront) > (mapIns.inputFrameUpsyncDelayTolerance + 1))) {
         // first comparison condition is to avoid numeric overflow
-        console.log(`Game logic ticking too fast, selfInputFrameIdFront=${selfInputFrameIdFront}, minInputFrameIdFront=${minInputFrameIdFront}, inputFrameUpsyncDelayTolerance=${mapIns.inputFrameUpsyncDelayTolerance}`);
+        if (CC_DEBUG) {
+            // Printing of this message might induce a performance impact.
+            console.log(`Game logic ticking too fast, selfInputFrameIdFront=${inputFrameIdFront}, minInputFrameIdFront=${minInputFrameIdFront}, inputFrameUpsyncDelayTolerance=${mapIns.inputFrameUpsyncDelayTolerance}`);
+        }
         return [true, inputFrameIdFront, sendingFps, srvDownsyncFps, peerUpsyncFps, rollbackFrames, skippedRenderFrameCnt];
       }
     }

frontend/build-templates/jsb-link/frameworks/runtime-src/Classes/ring_buff.cpp

@@ -51,7 +51,7 @@ void RecvRingBuff::put(char* newBytes, size_t newBytesLen) {
     }
     slotEle->bytesLen = newBytesLen;
     memset(slotEle->ui8Arr, 0, sizeof slotEle->ui8Arr);
-    for (int i = 0; i < newBytesLen; i++) {
+    for (size_t i = 0; i < newBytesLen; i++) {
         *(slotEle->ui8Arr + i) = *(newBytes + i);
     }