Fixed multi-barrier collision handling in backend.

README.md

@@ -1,11 +1,25 @@
 # Preface 
 
-This project is a demo for a websocket-based input synchronization method inspired by [GGPO](https://www.ggpo.net/).   
-![screenshot-1](./screenshot-1.png)
+This project is a demo for a websocket-based input synchronization method inspired by [GGPO](https://www.ggpo.net/).
 
-Please checkout [this demo video](https://pan.baidu.com/s/1aM6e8IWaJszFCYAsRjt19g?pwd=z02c) to see whether the source codes are doing what you expect for synchronization.
+_(how input delay roughly works)_
 
-The video mainly shows the following feature (yet I'm not surprised if they're not obvious): when a player didn't have its input arrived at the backend in time (e.g. due to local lag, network delay or reconnection), backend forces confirmation of a prediction of its own and sends the confirmed input together w/ a reference render frame to that player.
+![input_delay_intro](./charts/InputDelayIntro.jpg)
+
+_(how rollback-and-chase in this project roughly works)_
+
+![rollback_and_chase_intro](./charts/RollbackAndChase.jpg)
+
+_(in game screenshot)_
+
+![screenshot-1](./charts/screenshot-1.png)
+
+Please checkout [this demo video](https://pan.baidu.com/s/123LlWcT9X-wbcYybqYnvmA?pwd=qrlw) to see whether the source codes are doing what you expect for synchronization.
+
+The video mainly shows the following features.
+- The backend receives inputs from frontend peers and [by a GGPO-alike manner](https://github.com/pond3r/ggpo/blob/master/doc/README.md) broadcasts back for synchronization.
+- The game is recovered for a player upon reconnection.
+- Both backend(Golang) and frontend(JavaScript) execute collision detection and handle collision contacts by the same algorithm. The backend dynamics can be toggled off by [Room.BackendDynamicsEnabled](https://github.com/genxium/DelayNoMore/blob/v0.5.2/battle_srv/models/room.go#L813), but **when turned off the game couldn't support recovery upon reconnection**.
 
 # 1. Building & running
 
@@ -19,7 +33,7 @@ The video mainly shows the following feature (yet I'm not surprised if they're n
 - [protobuf CLI](https://developers.google.com/protocol-buffers/docs/downloads) (optional, only for development)
 
 ### Frontend
-- [CocosCreator v2.2.1](https://www.cocos.com/en/cocos-creator-2-2-1-released-with-performance-improvements) (mandatory, **ONLY AVAILABLE on Windows or OSX and should be exactly this version**, DON'T use any other version because CocosCreator is well-known for new versions not being backward incompatible)
+- [CocosCreator v2.2.1](https://www.cocos.com/en/cocos-creator-2-2-1-released-with-performance-improvements) (mandatory, **ONLY AVAILABLE on Windows or OSX and should be exactly this version**, DON'T use any other version because CocosCreator is well-known for new versions not being backward compatible)
 - [protojs](https://www.npmjs.com/package/protojs) (optional, only for development)
 
 ## 1.2 Provisioning
@@ -64,7 +78,7 @@ The easy way is to try out 2 players with test accounts on a same machine.
 - Open one browser instance, visit _http://localhost:7456?expectedRoomId=1_, input `add`on the username box and click to request a captcha, this is a test account so a captcha would be returned by the backend and filled automatically (as shown in the figure below), then click and click to proceed to a matching scene.
 - Open another browser instance, visit _http://localhost:7456?expectedRoomId=1_, input `bdd`on the username box and click to request a captcha, this is another test account so a captcha would be returned by the backend and filled automatically, then click and click to proceed, when matched a `battle`(but no competition rule yet) would start.
 - Try out the onscreen virtual joysticks to move the cars and see if their movements are in-sync.
-![screenshot-2](./screenshot-2.png)
+![screenshot-2](./charts/screenshot-2.png)
 
 ## 2 Troubleshooting
 

battle_srv/models/room.go

@@ -2,12 +2,17 @@ package models
 
 import (
 	. "dnmshared"
+	"encoding/xml"
 	"fmt"
 	"github.com/golang/protobuf/proto"
 	"github.com/gorilla/websocket"
 	"github.com/solarlune/resolv"
 	"go.uber.org/zap"
+	"io/ioutil"
+	"math"
 	"math/rand"
+	"os"
+	"path/filepath"
 	. "server/common"
 	"server/common/utils"
 	pb "server/pb_output"
@@ -15,11 +20,6 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
-
-	"encoding/xml"
-	"io/ioutil"
-	"os"
-	"path/filepath"
 )
 
 const (
@@ -188,7 +188,7 @@ type Room struct {
 	StageTileH                     int32
 	RawBattleStrToVec2DListMap     StrToVec2DListMap
 	RawBattleStrToPolygon2DListMap StrToPolygon2DListMap
-    BackendDynamicsEnabled         bool
+	BackendDynamicsEnabled         bool
 }
 
 const (
@@ -459,13 +459,13 @@ func (pR *Room) StartBattle() {
 				pR.prefabInputFrameDownsync(noDelayInputFrameId)
 			}
 
-			// Force setting all-confirmed of buffered inputFrames periodically
 			unconfirmedMask := uint64(0)
-            if pR.BackendDynamicsEnabled {
-               unconfirmedMask = pR.forceConfirmationIfApplicable()
-            } else {
-               pR.markConfirmationIfApplicable()
-            }
+			if pR.BackendDynamicsEnabled {
+				// Force setting all-confirmed of buffered inputFrames periodically
+				unconfirmedMask = pR.forceConfirmationIfApplicable()
+			} else {
+				pR.markConfirmationIfApplicable()
+			}
 
 			upperToSendInputFrameId := atomic.LoadInt32(&(pR.LastAllConfirmedInputFrameId))
 			/*
@@ -474,29 +474,29 @@ func (pR *Room) StartBattle() {
 
 			   If "NstDelayFrames" becomes larger, "pR.RenderFrameId - refRenderFrameId" possibly becomes larger because the force confirmation is delayed more.
 
-			   Hence even upon resync, it's still possible that "refRenderFrameId < frontend.chaserRenderFrameId".
+			   Upon resync, it's still possible that "refRenderFrameId < frontend.chaserRenderFrameId" -- and this is allowed.
 			*/
 			refRenderFrameId := pR.ConvertToGeneratingRenderFrameId(upperToSendInputFrameId) + (1 << pR.InputScaleFrames) - 1
 			if refRenderFrameId > pR.RenderFrameId {
 				refRenderFrameId = pR.RenderFrameId
 			}
 
-            dynamicsDuration := int64(0)
-            if pR.BackendDynamicsEnabled {
-                if 0 <= pR.LastAllConfirmedInputFrameId {
-                    dynamicsStartedAt := utils.UnixtimeNano()
-                    // Apply "all-confirmed inputFrames" to move forward "pR.CurDynamicsRenderFrameId"
-                    nextDynamicsRenderFrameId := pR.ConvertToLastUsedRenderFrameId(pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames)
-                    Logger.Debug(fmt.Sprintf("roomId=%v, room.RenderFrameId=%v, LastAllConfirmedInputFrameId=%v, InputDelayFrames=%v, nextDynamicsRenderFrameId=%v", pR.Id, pR.RenderFrameId, pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames, nextDynamicsRenderFrameId))
-                    pR.applyInputFrameDownsyncDynamics(pR.CurDynamicsRenderFrameId, nextDynamicsRenderFrameId)
-                    dynamicsDuration = utils.UnixtimeNano() - dynamicsStartedAt
-                }
+			dynamicsDuration := int64(0)
+			if pR.BackendDynamicsEnabled {
+				if 0 <= pR.LastAllConfirmedInputFrameId {
+					dynamicsStartedAt := utils.UnixtimeNano()
+					// Apply "all-confirmed inputFrames" to move forward "pR.CurDynamicsRenderFrameId"
+					nextDynamicsRenderFrameId := pR.ConvertToLastUsedRenderFrameId(pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames)
+					Logger.Debug(fmt.Sprintf("roomId=%v, room.RenderFrameId=%v, LastAllConfirmedInputFrameId=%v, InputDelayFrames=%v, nextDynamicsRenderFrameId=%v", pR.Id, pR.RenderFrameId, pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames, nextDynamicsRenderFrameId))
+					pR.applyInputFrameDownsyncDynamics(pR.CurDynamicsRenderFrameId, nextDynamicsRenderFrameId)
+					dynamicsDuration = utils.UnixtimeNano() - dynamicsStartedAt
+				}
 
-                // [WARNING] The following inequality are seldom true, but just to avoid that in good network condition the frontend resyncs itself to a "too advanced frontend.renderFrameId", and then starts upsyncing "too advanced inputFrameId".
-                if refRenderFrameId > pR.CurDynamicsRenderFrameId {
-                    refRenderFrameId = pR.CurDynamicsRenderFrameId
-                }
-            }  
+				// [WARNING] The following inequality are seldom true, but just to avoid that in good network condition the frontend resyncs itself to a "too advanced frontend.renderFrameId", and then starts upsyncing "too advanced inputFrameId".
+				if refRenderFrameId > pR.CurDynamicsRenderFrameId {
+					refRenderFrameId = pR.CurDynamicsRenderFrameId
+				}
+			}
 			for playerId, player := range pR.Players {
 				if swapped := atomic.CompareAndSwapInt32(&player.BattleState, PlayerBattleStateIns.ACTIVE, PlayerBattleStateIns.ACTIVE); !swapped {
 					// [WARNING] DON'T send anything if the player is disconnected, because it could jam the channel and cause significant delay upon "battle recovery for reconnected player".
@@ -539,7 +539,7 @@ func (pR *Room) StartBattle() {
 						// [WARNING] When sending DOWNSYNC_MSG_ACT_FORCED_RESYNC, there MUST BE accompanying "toSendInputFrames" for calculating "refRenderFrameId"!
 
 						if MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED == player.LastSentInputFrameId {
-							Logger.Warn(fmt.Sprintf("Not sending due to empty toSendInputFrames: roomId=%v, playerId=%v, refRenderFrameId=%v, candidateToSendInputFrameId=%v, upperToSendInputFrameId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v", pR.Id, playerId, refRenderFrameId, candidateToSendInputFrameId, upperToSendInputFrameId, player.LastSentInputFrameId, player.AckingInputFrameId))
+							Logger.Warn(fmt.Sprintf("Not sending due to empty toSendInputFrames: roomId=%v, playerId=%v, refRenderFrameId=%v, upperToSendInputFrameId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v", pR.Id, playerId, refRenderFrameId, upperToSendInputFrameId, player.LastSentInputFrameId, player.AckingInputFrameId))
 						}
 						continue
 					}
@@ -567,6 +567,17 @@ func (pR *Room) StartBattle() {
 			}
 
 			toApplyInputFrameId := pR.ConvertToInputFrameId(refRenderFrameId, pR.InputDelayFrames)
+			if false == pR.BackendDynamicsEnabled {
+				// When "false == pR.BackendDynamicsEnabled", the variable "refRenderFrameId" is not well defined
+				minLastSentInputFrameId := int32(math.MaxInt32)
+				for _, player := range pR.Players {
+					if player.LastSentInputFrameId >= minLastSentInputFrameId {
+						continue
+					}
+					minLastSentInputFrameId = player.LastSentInputFrameId
+				}
+				toApplyInputFrameId = minLastSentInputFrameId
+			}
 			for pR.InputsBuffer.N < pR.InputsBuffer.Cnt || (0 < pR.InputsBuffer.Cnt && pR.InputsBuffer.StFrameId < toApplyInputFrameId) {
 				f := pR.InputsBuffer.Pop().(*pb.InputFrameDownsync)
 				if pR.inputFrameIdDebuggable(f.InputFrameId) {
@@ -810,7 +821,7 @@ func (pR *Room) OnDismissed() {
 	pR.InputFrameUpsyncDelayTolerance = 2
 	pR.MaxChasingRenderFramesPerUpdate = 10
 
-    pR.BackendDynamicsEnabled = true // [WARNING] When "false", recovery upon reconnection wouldn't work!
+	pR.BackendDynamicsEnabled = true // [WARNING] When "false", recovery upon reconnection wouldn't work!
 
 	pR.ChooseStage()
 	pR.EffectivePlayerCount = 0
@@ -1080,40 +1091,40 @@ func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *pb.InputFrameDowns
 }
 
 func (pR *Room) markConfirmationIfApplicable() {
-	inputFrameId1 := pR.LastAllConfirmedInputFrameId+1
-    gap := int32(4) // This value is hardcoded and doesn't need be much bigger, because the backend side is supposed to never lag when "false == BackendDynamicsEnabled". 
-	inputFrameId2 := inputFrameId1+gap 
-    if inputFrameId2 > pR.InputsBuffer.EdFrameId {
-        inputFrameId2 = pR.InputsBuffer.EdFrameId
-    }
+	inputFrameId1 := pR.LastAllConfirmedInputFrameId + 1
+	gap := int32(4) // This value is hardcoded and doesn't need be much bigger, because the backend side is supposed to never lag when "false == BackendDynamicsEnabled".
+	inputFrameId2 := inputFrameId1 + gap
+	if inputFrameId2 > pR.InputsBuffer.EdFrameId {
+		inputFrameId2 = pR.InputsBuffer.EdFrameId
+	}
 
-    totPlayerCnt := uint32(pR.Capacity)
-    allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
-    for inputFrameId := inputFrameId1; inputFrameId < inputFrameId2; inputFrameId++ {
-        tmp := pR.InputsBuffer.GetByFrameId(inputFrameId)
-        if nil == tmp {
-            panic(fmt.Sprintf("inputFrameId=%v doesn't exist for roomId=%v, this is abnormal because the server should prefab inputFrameDownsync in a most advanced pace, check the prefab logic! InputsBuffer=%v", inputFrameId, pR.Id, pR.InputsBufferString(false)))
-        }
-        inputFrameDownsync := tmp.(*pb.InputFrameDownsync)
-        for _, player := range pR.Players {
-            bufIndex := pR.toDiscreteInputsBufferIndex(inputFrameId, player.JoinIndex)
-            tmp, loaded := pR.DiscreteInputsBuffer.LoadAndDelete(bufIndex) // It's safe to "LoadAndDelete" here because the "inputFrameUpsync" of this player is already remembered by the corresponding "inputFrameDown". 
-            if !loaded {
-                continue
-            }
-            inputFrameUpsync := tmp.(*pb.InputFrameUpsync)
-            indiceInJoinIndexBooleanArr := uint32(player.JoinIndex - 1)
-            inputFrameDownsync.InputList[indiceInJoinIndexBooleanArr] = pR.EncodeUpsyncCmd(inputFrameUpsync)
-            inputFrameDownsync.ConfirmedList |= (1 << indiceInJoinIndexBooleanArr)
-        }
+	totPlayerCnt := uint32(pR.Capacity)
+	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
+	for inputFrameId := inputFrameId1; inputFrameId < inputFrameId2; inputFrameId++ {
+		tmp := pR.InputsBuffer.GetByFrameId(inputFrameId)
+		if nil == tmp {
+			panic(fmt.Sprintf("inputFrameId=%v doesn't exist for roomId=%v, this is abnormal because the server should prefab inputFrameDownsync in a most advanced pace, check the prefab logic! InputsBuffer=%v", inputFrameId, pR.Id, pR.InputsBufferString(false)))
+		}
+		inputFrameDownsync := tmp.(*pb.InputFrameDownsync)
+		for _, player := range pR.Players {
+			bufIndex := pR.toDiscreteInputsBufferIndex(inputFrameId, player.JoinIndex)
+			tmp, loaded := pR.DiscreteInputsBuffer.LoadAndDelete(bufIndex) // It's safe to "LoadAndDelete" here because the "inputFrameUpsync" of this player is already remembered by the corresponding "inputFrameDown".
+			if !loaded {
+				continue
+			}
+			inputFrameUpsync := tmp.(*pb.InputFrameUpsync)
+			indiceInJoinIndexBooleanArr := uint32(player.JoinIndex - 1)
+			inputFrameDownsync.InputList[indiceInJoinIndexBooleanArr] = pR.EncodeUpsyncCmd(inputFrameUpsync)
+			inputFrameDownsync.ConfirmedList |= (1 << indiceInJoinIndexBooleanArr)
+		}
 
-        // Force confirmation of "inputFrame2"
-        if allConfirmedMask == inputFrameDownsync.ConfirmedList {     
-            pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
-        } else {
-            break
-        }
-    }
+		// Force confirmation of "inputFrame2"
+		if allConfirmedMask == inputFrameDownsync.ConfirmedList {
+			pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
+		} else {
+			break
+		}
+	}
 }
 
 func (pR *Room) forceConfirmationIfApplicable() uint64 {
@@ -1205,14 +1216,16 @@ func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRende
 				playerCollider := pR.CollisionSysMap[collisionPlayerIndex]
 				if collision := playerCollider.Check(oldDx, oldDy, "Barrier"); collision != nil {
 					playerShape := playerCollider.Shape.(*resolv.ConvexPolygon)
-					barrierShape := collision.Objects[0].Shape.(*resolv.ConvexPolygon)
-					if overlapped, pushbackX, pushbackY := CalcPushbacks(oldDx, oldDy, playerShape, barrierShape); overlapped {
-						Logger.Debug(fmt.Sprintf("Collided & overlapped: player.X=%v, player.Y=%v, oldDx=%v, oldDy=%v, playerShape=%v, toCheckBarrier=%v, pushbackX=%v, pushbackY=%v", playerCollider.X, playerCollider.Y, oldDx, oldDy, ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), pushbackX, pushbackY))
-						dx -= pushbackX
-						dy -= pushbackY
-					} else {
-						Logger.Debug(fmt.Sprintf("Collider BUT not overlapped: player.X=%v, player.Y=%v, oldDx=%v, oldDy=%v, playerShape=%v, toCheckBarrier=%v", playerCollider.X, playerCollider.Y, oldDx, oldDy, ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape)))
-					}
+                    for _, obj := range collision.Objects {
+                        barrierShape := obj.Shape.(*resolv.ConvexPolygon)
+                        if overlapped, pushbackX, pushbackY := CalcPushbacks(oldDx, oldDy, playerShape, barrierShape); overlapped {
+                            Logger.Debug(fmt.Sprintf("Collided & overlapped: player.X=%v, player.Y=%v, oldDx=%v, oldDy=%v, playerShape=%v, toCheckBarrier=%v, pushbackX=%v, pushbackY=%v", playerCollider.X, playerCollider.Y, oldDx, oldDy, ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), pushbackX, pushbackY))
+                            dx -= pushbackX
+                            dy -= pushbackY
+                        } else {
+                            Logger.Debug(fmt.Sprintf("Collided BUT not overlapped: player.X=%v, player.Y=%v, oldDx=%v, oldDy=%v, playerShape=%v, toCheckBarrier=%v", playerCollider.X, playerCollider.Y, oldDx, oldDy, ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape)))
+                        }
+                    } 
 				}
 				playerCollider.X += dx
 				playerCollider.Y += dy

frontend/assets/scenes/login.fire

@@ -440,7 +440,7 @@
       "array": [
         0,
         0,
-        344.75930058781137,
+        209.73151519075364,
         0,
         0,
         0,

frontend/assets/scripts/Map.js

@@ -382,7 +382,8 @@ cc.Class({
       window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
       window.initPersistentSessionClient(self.initAfterWSConnected, null /* Deliberately NOT passing in any `expectedRoomId`. -- YFLu */ );
     };
-    resultPanelScriptIns.onCloseDelegate = () => {};
+    resultPanelScriptIns.onCloseDelegate = () => {
+    };
 
     self.gameRuleNode = cc.instantiate(self.gameRulePrefab);
     self.gameRuleNode.width = self.canvasNode.width;
@@ -740,10 +741,12 @@ cc.Class({
     newPlayerNode.setPosition(cc.v2(x, y));
     newPlayerNode.getComponent("SelfPlayer").mapNode = self.node;
     const currentSelfColliderCircle = newPlayerNode.getComponent(cc.CircleCollider);
-	const r = currentSelfColliderCircle.radius, d = 2*r;
-	// The collision box of an individual player is a polygon instead of a circle, because the backend collision engine doesn't handle circle alignment well.
-	const x0 = x-r, y0 = y-r;
-	let pts = [[0, 0], [d, 0], [d, d], [0, d]]; 
+    const r = currentSelfColliderCircle.radius,
+      d = 2 * r;
+    // The collision box of an individual player is a polygon instead of a circle, because the backend collision engine doesn't handle circle alignment well.
+    const x0 = x - r,
+      y0 = y - r;
+    let pts = [[0, 0], [d, 0], [d, d], [0, d]];
 
     const newPlayerColliderLatest = self.latestCollisionSys.createPolygon(x0, y0, pts);
     const newPlayerColliderChaser = self.chaserCollisionSys.createPolygon(x0, y0, pts);
@@ -957,7 +960,7 @@ cc.Class({
       const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
       const playerCollider = collisionSysMap.get(collisionPlayerIndex);
       const currentSelfColliderCircle = playerRichInfo.node.getComponent(cc.CircleCollider);
-	  const r = currentSelfColliderCircle.radius;
+      const r = currentSelfColliderCircle.radius;
       rdf.players[playerRichInfo.id] = {
         id: playerRichInfo.id,
         x: playerCollider.x + r, // [WARNING] the (x, y) of "playerCollider" is offset to the anchor (i.e. first point of all points) of the polygon shape
@@ -1033,7 +1036,7 @@ cc.Class({
       const player = latestRdf.players[playerId];
 
       const currentSelfColliderCircle = playerRichInfo.node.getComponent(cc.CircleCollider);
-	  const r = currentSelfColliderCircle.radius;
+      const r = currentSelfColliderCircle.radius;
       playerCollider.x = player.x - r;
       playerCollider.y = player.y - r;
     });

frontend/assets/scripts/WsSessionMgr.js

@@ -111,9 +111,9 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
     }
     return;
   }
- 
+
   const selfPlayerStr = cc.sys.localStorage.getItem("selfPlayer");
-  const selfPlayer = null == selfPlayerStr ? null : JSON.parse(selfPlayerStr);  
+  const selfPlayer = null == selfPlayerStr ? null : JSON.parse(selfPlayerStr);
   const intAuthToken = null == selfPlayer ? "" : selfPlayer.intAuthToken;
 
   let urlToConnect = backendAddress.PROTOCOL.replace('http', 'ws') + '://' + backendAddress.HOST + ":" + backendAddress.PORT + backendAddress.WS_PATH_PREFIX + "?intAuthToken=" + intAuthToken;
@@ -224,10 +224,10 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
         case constants.RET_CODE.MYSQL_ERROR:
         case constants.RET_CODE.PLAYER_NOT_FOUND:
         case constants.RET_CODE.PLAYER_CHEATING:
-		case 1006: // Peer(i.e. the backend) gone unexpectedly 
+        case 1006: // Peer(i.e. the backend) gone unexpectedly 
           if (window.handleClientSessionError) {
             window.handleClientSessionError();
-          }  
+          }
           break;
         default:
           break;