Minor update.

README.md

@@ -4,7 +4,7 @@ This project is a demo for a websocket-based rollback netcode inspired by [GGPO]
 
 As lots of feedbacks ask for a discussion on using UDP instead, I tried to summarize my personal opinion about it in [ConcerningEdgeCases](./ConcerningEdgeCases.md) -- **since v0.9.25, the project is actually equipped with UDP capabilities as follows**.
 - When using the so called `native apps` on `Android` and `Windows` (I'm working casually hard to support `iOS` next), the frontends will try to use UDP hole-punching w/ the help of backend as a registry. If UDP hole-punching is working, the rollback is often less than `turn-around frames to recover` and thus not noticeable, being much better than using websocket alone.
-- If UDP hole-punching is not working, e.g. for Symmetric NAT like in 4G/5G cellular network, the frontends will use backend as a UDP tunnel (or relay, whatever you like to call it). This video shows how the UDP tunnel performs for a [Phone-4G v.s. PC-Wifi (viewed by PC side)](https://pan.baidu.com/s/1wdUTvRiyrTLWy7mF6G7uyQ?pwd=icmp). 
+- If UDP hole-punching is not working, e.g. for Symmetric NAT like in 4G/5G cellular network, the frontends will use backend as a UDP tunnel (or relay, whatever you like to call it). This video shows how the UDP tunnel performs for a [Phone-4G v.s. PC-Wifi (viewed by PC side)](https://pan.baidu.com/s/1IZVa5wVgAdeH6D-xsZYFUw?pwd=dgkj). 
 - Browser vs `native app` is possible but in that case only websocket is used.
 
 The following video is recorded over INTERNET using an input delay of 4 frames and it feels SMOOTH when playing! Please also checkout these demo videos
@@ -27,7 +27,7 @@ _(how input delay roughly works)_
 
 ![input_delay_intro](./charts/InputDelayIntro.jpg)
 
-_(how rollback-and-chase in this project roughly works, kindly note that by the current implementation, each frontend only maintains a `lastAllConfirmedInputFrameId` for all the other peers, because the backend only downsyncs all-confirmed inputFrames, see [markConfirmationIfApplicable](https://github.com/genxium/DelayNoMore/blob/v0.9.14/battle_srv/models/room.go#L1085) for more information -- if a serverless peer-to-peer communication is seriously needed here, consider porting [markConfirmationIfApplicable](https://github.com/genxium/DelayNoMore/blob/v0.9.14/battle_srv/models/room.go#L1085) into frontend for maintaining `lastAllConfirmedInputFrameId` under chaotic reception order of inputFrames from peers)_
+_(how rollback-and-chase in this project roughly works)_
 
 ![server_clients](./charts/ServerClients.jpg)
 ![rollback_and_chase_intro](./charts/RollbackAndChase.jpg)

battle_srv/models/player.go

@@ -47,10 +47,11 @@ type Player struct {
 	TutorialStage int       `db:"tutorial_stage"`
 
 	// other in-battle info fields
-	LastReceivedInputFrameId int32
-	LastSentInputFrameId     int32
-	AckingFrameId            int32
-	AckingInputFrameId       int32
+	LastReceivedInputFrameId    int32
+	LastUdpReceivedInputFrameId int32
+	LastSentInputFrameId        int32
+	AckingFrameId               int32
+	AckingInputFrameId          int32
 
 	UdpAddr                *PeerUdpAddr
 	BattleUdpTunnelAddr    *net.UDPAddr // This addr is used by backend only, not visible to frontend

battle_srv/models/room.go

@@ -136,7 +136,7 @@ type Room struct {
 	EffectivePlayerCount                   int32
 	DismissalWaitGroup                     sync.WaitGroup
 	InputsBuffer                           *battle.RingBuffer // Indices are STRICTLY consecutive
-	InputsBufferLock                       sync.Mutex         // Guards [InputsBuffer, LatestPlayerUpsyncedInputFrameId, LastAllConfirmedInputFrameId, LastAllConfirmedInputList, LastAllConfirmedInputFrameIdWithChange, LastIndividuallyConfirmedInputList, player.LastReceivedInputFrameId]
+	InputsBufferLock                       sync.Mutex         // Guards [InputsBuffer, LatestPlayerUpsyncedInputFrameId, LastAllConfirmedInputFrameId, LastAllConfirmedInputList, LastAllConfirmedInputFrameIdWithChange, LastIndividuallyConfirmedInputList, player.LastReceivedInputFrameId, player.LastUdpReceivedInputFrameId]
 	RenderFrameBuffer                      *battle.RingBuffer // Indices are STRICTLY consecutive
 	LatestPlayerUpsyncedInputFrameId       int32
 	LastAllConfirmedInputFrameId           int32
@@ -189,6 +189,7 @@ func (pR *Room) AddPlayerIfPossible(pPlayerFromDbInit *Player, session *websocke
 	pPlayerFromDbInit.AckingInputFrameId = -1
 	pPlayerFromDbInit.LastSentInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_NORMAL_ADDED
 	pPlayerFromDbInit.LastReceivedInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_NORMAL_ADDED
+	pPlayerFromDbInit.LastUdpReceivedInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_NORMAL_ADDED
 	pPlayerFromDbInit.BattleState = PlayerBattleStateIns.ADDED_PENDING_BATTLE_COLLIDER_ACK
 
 	pPlayerFromDbInit.ColliderRadius = DEFAULT_PLAYER_RADIUS // Hardcoded
@@ -230,6 +231,7 @@ func (pR *Room) ReAddPlayerIfPossible(pTmpPlayerInstance *Player, session *webso
 	pEffectiveInRoomPlayerInstance.AckingFrameId = -1
 	pEffectiveInRoomPlayerInstance.AckingInputFrameId = -1
 	pEffectiveInRoomPlayerInstance.LastSentInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED
+	// [WARNING] DON'T reset "player.LastReceivedInputFrameId" & "player.LastUdpReceivedInputFrameId" upon reconnection!
 	pEffectiveInRoomPlayerInstance.BattleState = PlayerBattleStateIns.READDED_PENDING_BATTLE_COLLIDER_ACK
 
 	pEffectiveInRoomPlayerInstance.ColliderRadius = DEFAULT_PLAYER_RADIUS // Hardcoded
@@ -574,7 +576,7 @@ func (pR *Room) StartBattle() {
 	})
 }
 
-func (pR *Room) OnBattleCmdReceived(pReq *pb.WsReq) {
+func (pR *Room) OnBattleCmdReceived(pReq *pb.WsReq, fromUDP bool) {
 	/*
 	   [WARNING] This function "OnBattleCmdReceived" could be called by different ws sessions and thus from different threads!
 
@@ -619,7 +621,7 @@ func (pR *Room) OnBattleCmdReceived(pReq *pb.WsReq) {
 		//Logger.Debug(fmt.Sprintf("OnBattleCmdReceived-InputsBufferLock unlocked: roomId=%v, fromPlayerId=%v", pR.Id, playerId))
 	}()
 
-	inputsBufferSnapshot := pR.markConfirmationIfApplicable(inputFrameUpsyncBatch, playerId, player)
+	inputsBufferSnapshot := pR.markConfirmationIfApplicable(inputFrameUpsyncBatch, playerId, player, fromUDP)
 	if nil != inputsBufferSnapshot {
 		pR.downsyncToAllPlayers(inputsBufferSnapshot)
 	} /*else {
@@ -815,7 +817,7 @@ func (pR *Room) OnDismissed() {
 
 	pR.RenderFrameId = 0
 	pR.CurDynamicsRenderFrameId = 0
-	pR.NstDelayFrames = 16
+	pR.NstDelayFrames = 24
 
 	serverFps := 60
 	pR.RollbackEstimatedDtMillis = 16.667  // Use fixed-and-low-precision to mitigate the inconsistent floating-point-number issue between Golang and JavaScript
@@ -823,6 +825,7 @@ func (pR *Room) OnDismissed() {
 	dilutedServerFps := float64(58.0)      // Don't set this value too small, otherwise we might miss force confirmation needs for slow tickers!
 	pR.dilutedRollbackEstimatedDtNanos = int64(float64(pR.RollbackEstimatedDtNanos) * float64(serverFps) / dilutedServerFps)
 	pR.BattleDurationFrames = int32(60 * serverFps)
+	//pR.BattleDurationFrames = int32(20 * serverFps)
 	pR.BattleDurationNanos = int64(pR.BattleDurationFrames) * (pR.RollbackEstimatedDtNanos + 1)
 	pR.InputFrameUpsyncDelayTolerance = battle.ConvertToNoDelayInputFrameId(pR.NstDelayFrames) - 1 // this value should be strictly smaller than (NstDelayFrames >> InputScaleFrames), otherwise "type#1 forceConfirmation" might become a lag avalanche
 	pR.MaxChasingRenderFramesPerUpdate = 9                                                         // Don't set this value too high to avoid exhausting frontend CPU within a single frame, roughly as the "turn-around frames to recover" is empirically OK
@@ -1159,7 +1162,7 @@ func (pR *Room) getOrPrefabInputFrameDownsync(inputFrameId int32) *battle.InputF
 	return currInputFrameDownsync
 }
 
-func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*pb.InputFrameUpsync, playerId int32, player *Player) *pb.InputsBufferSnapshot {
+func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*pb.InputFrameUpsync, playerId int32, player *Player, fromUDP bool) *pb.InputsBufferSnapshot {
 	// [WARNING] This function MUST BE called while "pR.InputsBufferLock" is locked!
 	// Step#1, put the received "inputFrameUpsyncBatch" into "pR.InputsBuffer"
 	for _, inputFrameUpsync := range inputFrameUpsyncBatch {
@@ -1170,6 +1173,7 @@ func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*pb.InputFr
 			continue
 		}
 		if clientInputFrameId < player.LastReceivedInputFrameId {
+			// [WARNING] It's important for correctness that we use "player.LastReceivedInputFrameId" instead of "player.LastUdpReceivedInputFrameId" here!
 			Logger.Debug(fmt.Sprintf("Omitting obsolete inputFrameUpsync#2: roomId=%v, playerId=%v, clientInputFrameId=%v, playerLastReceivedInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, clientInputFrameId, player.LastReceivedInputFrameId, pR.InputsBufferString(false)))
 			continue
 		}
@@ -1182,11 +1186,25 @@ func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*pb.InputFr
 		targetInputFrameDownsync.InputList[player.JoinIndex-1] = inputFrameUpsync.Encoded
 		targetInputFrameDownsync.ConfirmedList |= uint64(1 << uint32(player.JoinIndex-1))
 
-		player.LastReceivedInputFrameId = clientInputFrameId
-		pR.LastIndividuallyConfirmedInputList[player.JoinIndex-1] = inputFrameUpsync.Encoded
+		if false == fromUDP {
+			/*
+							   [WARNING] We have to distinguish whether or not the incoming batch is from UDP here, otherwise "pR.LatestPlayerUpsyncedInputFrameId - pR.LastAllConfirmedInputFrameId" might become unexpectedly large in case of "UDP packet loss + slow ws session"!
 
-		if clientInputFrameId > pR.LatestPlayerUpsyncedInputFrameId {
-			pR.LatestPlayerUpsyncedInputFrameId = clientInputFrameId
+							   Moreover, only ws session upsyncs should advance "player.LastReceivedInputFrameId" & "pR.LatestPlayerUpsyncedInputFrameId".
+
+				               Kindly note that the updates of "player.LastReceivedInputFrameId" could be discrete before and after reconnection.
+			*/
+			player.LastReceivedInputFrameId = clientInputFrameId
+			if clientInputFrameId > pR.LatestPlayerUpsyncedInputFrameId {
+				pR.LatestPlayerUpsyncedInputFrameId = clientInputFrameId
+			}
+		}
+
+		if clientInputFrameId > player.LastUdpReceivedInputFrameId {
+			// No need to update "player.LastUdpReceivedInputFrameId" only when "true == fromUDP", we should keep "player.LastUdpReceivedInputFrameId >= player.LastReceivedInputFrameId" at any moment.
+			player.LastUdpReceivedInputFrameId = clientInputFrameId
+			// It's safe (in terms of getting an eventually correct "RenderFrameBuffer") to put the following update of "pR.LastIndividuallyConfirmedInputList" which is ONLY used for prediction in "InputsBuffer" out of "false == fromUDP" block.
+			pR.LastIndividuallyConfirmedInputList[player.JoinIndex-1] = inputFrameUpsync.Encoded
 		}
 	}
 
@@ -1253,6 +1271,7 @@ func (pR *Room) forceConfirmationIfApplicable(prevRenderFrameId int32) uint64 {
 	totPlayerCnt := uint32(pR.Capacity)
 	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
 	unconfirmedMask := uint64(0)
+	// As "pR.LastAllConfirmedInputFrameId" can be advanced by UDP but "pR.LatestPlayerUpsyncedInputFrameId" could only be advanced by ws session, when the following condition is met we know that the slow ticker is really in trouble!
 	if pR.LatestPlayerUpsyncedInputFrameId > (pR.LastAllConfirmedInputFrameId + pR.InputFrameUpsyncDelayTolerance + 1) {
 		// Type#1 check whether there's a significantly slow ticker among players
 		oldLastAllConfirmedInputFrameId := pR.LastAllConfirmedInputFrameId
@@ -1730,7 +1749,7 @@ func (pR *Room) startBattleUdpTunnel() {
 		pReq := new(pb.WsReq)
 		bytes := message[0:rlen]
 		if unmarshalErr := proto.Unmarshal(bytes, pReq); nil != unmarshalErr {
-			Logger.Warn("`BattleUdpTunnel` for roomId=%d failed to unmarshal", zap.Error(unmarshalErr))
+			Logger.Warn(fmt.Sprintf("`BattleUdpTunnel` for roomId=%d failed to unmarshal %d bytes", pR.Id, rlen), zap.Error(unmarshalErr))
 			continue
 		}
 		playerId := pReq.PlayerId
@@ -1760,7 +1779,7 @@ func (pR *Room) startBattleUdpTunnel() {
 								Logger.Warn(fmt.Sprintf("`BattleUdpTunnel` for roomId=%d failed to forward upsync from (playerId:%d, joinIndex:%d, addr:%s) to (otherPlayerId:%d, otherPlayerJoinIndex:%d, otherPlayerAddr:%s)\n", pR.Id, playerId, peerJoinIndex, remote, otherPlayer.Id, otherPlayer.JoinIndex, otherPlayer.BattleUdpTunnelAddr))
 							}
 						}
-						pR.OnBattleCmdReceived(pReq) // To help advance "pR.LastAllConfirmedInputFrameId" asap
+						pR.OnBattleCmdReceived(pReq, true) // To help advance "pR.LastAllConfirmedInputFrameId" asap, and even if "pR.LastAllConfirmedInputFrameId" is not advanced due to packet loss, these UDP packets would help prefill the "InputsBuffer" with correct player "future inputs (compared to ws session)" such that when "forceConfirmation" occurs we have as many correct predictions as possible
 					}
 
 				}

battle_srv/ws/serve.go

@@ -388,7 +388,7 @@ func Serve(c *gin.Context) {
 				startOrFeedHeartbeatWatchdog(conn)
 			case models.UPSYNC_MSG_ACT_PLAYER_CMD:
 				startOrFeedHeartbeatWatchdog(conn)
-				pRoom.OnBattleCmdReceived(pReq)
+				pRoom.OnBattleCmdReceived(pReq, false)
 			case models.UPSYNC_MSG_ACT_PLAYER_COLLIDER_ACK:
 				res := pRoom.OnPlayerBattleColliderAcked(int32(playerId))
 				if false == res {

frontend/assets/scenes/offline_map.fire

@@ -547,7 +547,7 @@
       "array": [
         0,
         0,
-        210.53572189052173,
+        209.73151519075364,
         0,
         0,
         0,

frontend/assets/scripts/CameraTracker.js

@@ -29,6 +29,15 @@ cc.Class({
     if (!selfPlayerRichInfo) return;
     const selfPlayerNode = selfPlayerRichInfo.node;
     if (!selfPlayerNode) return;
-    self.mapNode.setPosition(cc.v2().sub(selfPlayerNode.position));
+    const dst = cc.v2().sub(selfPlayerNode.position);
+    const pDiff = dst.sub(self.mapNode.position);
+    const stepLength = dt * self.speed;
+    if (stepLength > pDiff.mag()) {
+      self.mapNode.setPosition(dst);
+    } else {
+      pDiff.normalizeSelf();
+      const newMapPos = self.mapNode.position.add(pDiff.mul(dt * self.speed));
+      self.mapNode.setPosition(newMapPos);
+    }
   }
 });

frontend/assets/scripts/Map.js

@@ -43,10 +43,10 @@ window.onUdpMessage = (args) => {
     //cc.log(`#2 Js called back by CPP for upsync: onUdpMessage: ${JSON.stringify(req)}`);
     if (req.act && window.UPSYNC_MSG_ACT_PLAYER_CMD == req.act) {
       let effCnt = 0;
-      const renderedInputFrameIdUpper = gopkgs.ConvertToDelayedInputFrameId(self.renderFrameId);
       const peerJoinIndex = req.joinIndex;
+      if (peerJoinIndex == self.selfPlayerInfo.JoinIndex) return;
       const batch = req.inputFrameUpsyncBatch;
-      self.onPeerInputFrameUpsync(peerJoinIndex, batch);
+      self.onPeerInputFrameUpsync(peerJoinIndex, batch, true);
     }
   }
 };
@@ -144,7 +144,7 @@ cc.Class({
     return (confirmedList + 1) == (1 << this.playerRichInfoDict.size);
   },
 
-  getOrPrefabInputFrameUpsync(inputFrameId) {
+  getOrPrefabInputFrameUpsync(inputFrameId, canConfirmSelf) {
     // TODO: find some kind of synchronization mechanism against "onInputFrameDownsyncBatch"!
     const self = this;
     if (
@@ -157,33 +157,48 @@ cc.Class({
     let previousSelfInput = null,
       currSelfInput = null;
     const joinIndex = self.selfPlayerInfo.JoinIndex;
+    const selfJoinIndexMask = (1 << (joinIndex - 1));
     const existingInputFrame = self.recentInputCache.GetByFrameId(inputFrameId);
     const previousInputFrameDownsync = self.recentInputCache.GetByFrameId(inputFrameId - 1);
     previousSelfInput = (null == previousInputFrameDownsync ? null : previousInputFrameDownsync.InputList[joinIndex - 1]);
-    if (null != existingInputFrame) {
+    if (
+      null != existingInputFrame
+      &&
+      (true != canConfirmSelf)
+    ) {
       // This could happen upon either [type#1] or [type#2] forceConfirmation, where "refRenderFrame" is accompanied by some "inputFrameDownsyncs". The check here also guarantees that we don't override history 
       //console.log(`noDelayInputFrameId=${inputFrameId} already exists in recentInputCache: recentInputCache=${self._stringifyRecentInputCache(false)}`);
       return [previousSelfInput, existingInputFrame.InputList[joinIndex - 1]];
     }
 
-    const lastAllConfirmedInputFrame = self.recentInputCache.GetByFrameId(self.lastAllConfirmedInputFrameId);
     const prefabbedInputList = new Array(self.playerRichInfoDict.size).fill(0);
     // the returned "gopkgs.NewInputFrameDownsync.InputList" is immutable, thus we can only modify the values in "prefabbedInputList"
-    for (let k in prefabbedInputList) {
-      if (null != previousInputFrameDownsync) {
+    for (let k = 0; k < window.boundRoomCapacity; ++k) {
+      if (null != existingInputFrame) {
+        // When "null != existingInputFrame", it implies that "true == canConfirmSelf" here, we just have to assign "prefabbedInputList[(joinIndex-1)]" specifically and copy all others
+        prefabbedInputList[k] = existingInputFrame.InputList[k];
+      } else if (self.lastIndividuallyConfirmedInputFrameId[k] <= inputFrameId) {
+        prefabbedInputList[k] = self.lastIndividuallyConfirmedInputList[k];
+        // Don't predict "btnA & btnB"!
+        prefabbedInputList[k] = (prefabbedInputList[k] & 15);
+      } else if (null != previousInputFrameDownsync) {
+        // When "self.lastIndividuallyConfirmedInputFrameId[k] > inputFrameId", don't use it to predict a historical input!
         prefabbedInputList[k] = previousInputFrameDownsync.InputList[k];
+        // Don't predict "btnA & btnB"!
+        prefabbedInputList[k] = (prefabbedInputList[k] & 15);
       }
-      if (0 <= self.lastAllConfirmedInputFrameId && inputFrameId - 1 > self.lastAllConfirmedInputFrameId) {
-        prefabbedInputList[k] = lastAllConfirmedInputFrame.InputList[k];
-      }
-      // Don't predict "btnA & btnB"!
-      prefabbedInputList[k] = (prefabbedInputList[k] & 15);
+    }
+    let initConfirmedList = 0;
+    if (null != existingInputFrame) {
+      // When "null != existingInputFrame", it implies that "true == canConfirmSelf" here
+      initConfirmedList = (existingInputFrame.ConfirmedList | selfJoinIndexMask);
     }
     currSelfInput = self.ctrl.getEncodedInput(); // When "null == existingInputFrame", it'd be safe to say that the realtime "self.ctrl.getEncodedInput()" is for the requested "inputFrameId"
     prefabbedInputList[(joinIndex - 1)] = currSelfInput;
     while (self.recentInputCache.EdFrameId <= inputFrameId) {
       // Fill the gap
-      const prefabbedInputFrameDownsync = gopkgs.NewInputFrameDownsync(self.recentInputCache.EdFrameId, prefabbedInputList.slice(), (1 << (joinIndex - 1)));
+      // [WARNING] Do not blindly use "selfJoinIndexMask" here, as the "actuallyUsedInput for self" couldn't be confirmed while prefabbing, otherwise we'd have confirmed a wrong self input by "_markConfirmationIfApplicable()"!
+      const prefabbedInputFrameDownsync = gopkgs.NewInputFrameDownsync(self.recentInputCache.EdFrameId, prefabbedInputList.slice(), initConfirmedList);
       // console.log(`Prefabbed inputFrameId=${prefabbedInputFrameDownsync.InputFrameId}`);
       self.recentInputCache.Put(prefabbedInputFrameDownsync);
     }
@@ -355,6 +370,8 @@ cc.Class({
     self.lastUpsyncInputFrameId = -1;
     self.chaserRenderFrameId = -1; // at any moment, "chaserRenderFrameId <= renderFrameId", but "chaserRenderFrameId" would fluctuate according to "onInputFrameDownsyncBatch"
 
+    self.lastIndividuallyConfirmedInputFrameId = new Array(window.boundRoomCapacity).fill(-1);
+    self.lastIndividuallyConfirmedInputList = new Array(window.boundRoomCapacity).fill(0);
     self.recentRenderCache = new RingBuffer(self.renderCacheSize);
 
     self.recentInputCache = gopkgs.NewRingBufferJs((self.renderCacheSize >> 1) + 1);
@@ -814,6 +831,19 @@ cc.Class({
     return true;
   },
 
+  _markConfirmationIfApplicable() {
+    const self = this;
+    let newAllConfirmedCnt = 0;
+    while (self.recentInputCache.StFrameId <= self.lastAllConfirmedInputFrameId && self.lastAllConfirmedInputFrameId < self.recentInputCache.EdFrameId) {
+      const inputFrameDownsync = self.recentInputCache.GetByFrameId(self.lastAllConfirmedInputFrameId);
+      if (null == inputFrameDownsync) break;
+      if (self._allConfirmed(inputFrameDownsync.ConfirmedList)) break;
+      ++self.lastAllConfirmedInputFrameId;
+      ++newAllConfirmedCnt;
+    }
+    return newAllConfirmedCnt;
+  },
+
   onInputFrameDownsyncBatch(batch /* []*pb.InputFrameDownsync */ ) {
     // TODO: find some kind of synchronization mechanism against "getOrPrefabInputFrameUpsync"!
     if (null == batch) {
@@ -835,8 +865,9 @@ cc.Class({
       if (inputFrameDownsyncId <= self.lastAllConfirmedInputFrameId) {
         continue;
       }
-      // [WARNING] Take all "inputFrameDownsync" from backend as all-confirmed, it'll be later checked by "rollbackAndChase". 
+      // [WARNING] Now that "inputFrameDownsyncId > self.lastAllConfirmedInputFrameId", we should make an update immediately because unlike its backend counterpart "Room.LastAllConfirmedInputFrameId", the frontend "mapIns.lastAllConfirmedInputFrameId" might inevitably get gaps among discrete values due to "either type#1 or type#2 forceConfirmation" -- and only "onInputFrameDownsyncBatch" can catch this! 
       self.lastAllConfirmedInputFrameId = inputFrameDownsyncId;
+
       const localInputFrame = self.recentInputCache.GetByFrameId(inputFrameDownsyncId);
       if (null != localInputFrame
         &&
@@ -846,16 +877,29 @@ cc.Class({
       ) {
         firstPredictedYetIncorrectInputFrameId = inputFrameDownsyncId;
       }
+      // [WARNING] Take all "inputFrameDownsync" from backend as all-confirmed, it'll be later checked by "rollbackAndChase". 
       inputFrameDownsync.confirmedList = (1 << self.playerRichInfoDict.size) - 1;
       const inputFrameDownsyncLocal = gopkgs.NewInputFrameDownsync(inputFrameDownsync.inputFrameId, inputFrameDownsync.inputList, inputFrameDownsync.confirmedList); // "battle.InputFrameDownsync" in "jsexport"
+      for (let j in self.playerRichInfoArr) {
+        const jj = parseInt(j);
+        if (inputFrameDownsync.inputFrameId > self.lastIndividuallyConfirmedInputFrameId[jj]) {
+          self.lastIndividuallyConfirmedInputFrameId[jj] = inputFrameDownsync.inputFrameId;
+          self.lastIndividuallyConfirmedInputList[jj] = inputFrameDownsync.inputList[jj];
+        }
+      }
       //console.log(`Confirmed inputFrameId=${inputFrameDownsync.inputFrameId}`);
       const [ret, oldStFrameId, oldEdFrameId] = self.recentInputCache.SetByFrameId(inputFrameDownsyncLocal, inputFrameDownsync.inputFrameId);
       if (window.RING_BUFF_FAILED_TO_SET == ret) {
         throw `Failed to dump input cache (maybe recentInputCache too small)! inputFrameDownsync.inputFrameId=${inputFrameDownsync.inputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
       }
     }
+    self._markConfirmationIfApplicable();
+    self._handleIncorrectlyRenderedPrediction(firstPredictedYetIncorrectInputFrameId, batch, false);
+  },
 
+  _handleIncorrectlyRenderedPrediction(firstPredictedYetIncorrectInputFrameId, batch, fromUDP) {
     if (null == firstPredictedYetIncorrectInputFrameId) return;
+    const self = this;
     const renderFrameId1 = gopkgs.ConvertToFirstUsedRenderFrameId(firstPredictedYetIncorrectInputFrameId) - 1;
     if (renderFrameId1 >= self.chaserRenderFrameId) return;
 
@@ -871,15 +915,20 @@ 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 firstPredictedYetIncorrectInputFrameId: ${firstPredictedYetIncorrectInputFrameId}
+    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}]`);
+batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inputFrameId}]
+fromUDP=${fromUDP}`);
     self.chaserRenderFrameId = renderFrameId1;
-    self.networkDoctor.logRollbackFrames(self.renderFrameId - self.chaserRenderFrameId);
+    let rollbackFrames = (self.renderFrameId - self.chaserRenderFrameId);
+    if (0 > rollbackFrames)
+      rollbackFrames = 0;
+    self.networkDoctor.logRollbackFrames(rollbackFrames);
   },
 
-  onPeerInputFrameUpsync(peerJoinIndex, batch /* []*pb.InputFrameDownsync */ ) {
+  onPeerInputFrameUpsync(peerJoinIndex, batch, fromUDP) {
     // TODO: find some kind of synchronization mechanism against "getOrPrefabInputFrameUpsync"!
     // See `<proj-root>/ConcerningEdgeCases.md` for why this method exists.
     if (null == batch) {
@@ -895,36 +944,54 @@ batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inpu
 
     let effCnt = 0;
     //console.log(`Received peer inputFrameUpsync batch w/ inputFrameId in [${batch[0].inputFrameId}, ${batch[batch.length - 1].inputFrameId}] for prediction assistance`);
+    let firstPredictedYetIncorrectInputFrameId = null;
     const renderedInputFrameIdUpper = gopkgs.ConvertToDelayedInputFrameId(self.renderFrameId);
     for (let k in batch) {
-      const inputFrameDownsync = batch[k];
-      const inputFrameDownsyncId = inputFrameDownsync.inputFrameId;
-      if (inputFrameDownsyncId < renderedInputFrameIdUpper) {
-        // Avoid obfuscating already rendered history
+      const inputFrame = batch[k]; // could be either "pb.InputFrameDownsync" or "pb.InputFrameUpsync", depending on "fromUDP"
+      const inputFrameId = inputFrame.inputFrameId;
+      const peerEncodedInput = (true == fromUDP ? inputFrame.encoded : inputFrame.inputList[peerJoinIndex - 1]);
+      if (inputFrameId <= renderedInputFrameIdUpper) {
+        // [WARNING] Avoid obfuscating already rendered history, even at "inputFrameId == renderedInputFrameIdUpper", due to the use of "INPUT_SCALE_FRAMES" some previous render frames might already be rendered with "inputFrameId"!   
+        // TODO: 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.
+        const localInputFrame = self.recentInputCache.GetByFrameId(inputFrameId);
+        if (null != localInputFrame
+          &&
+          null == firstPredictedYetIncorrectInputFrameId
+          &&
+          localInputFrame.InputList[peerJoinIndex - 1] != peerEncodedInput
+        ) {
+          firstPredictedYetIncorrectInputFrameId = inputFrameId;
+        }
         continue;
       }
-      if (inputFrameDownsyncId <= self.lastAllConfirmedInputFrameId) {
+      if (inputFrameId <= self.lastAllConfirmedInputFrameId) {
+        // [WARNING] Don't reject it by "inputFrameId <= self.lastIndividuallyConfirmedInputFrameId[peerJoinIndex-1]", the arrival of UDP packets might not reserve their sending order!
         continue;
       }
-      self.getOrPrefabInputFrameUpsync(inputFrameDownsyncId); // Make sure that inputFrame exists locally
-      const existingInputFrame = self.recentInputCache.GetByFrameId(inputFrameDownsyncId);
-      if (0 < (existingInputFrame.ConfirmedList & (1 << (peerJoinIndex - 1)))) {
+      const peerJoinIndexMask = (1 << (peerJoinIndex - 1));
+      self.getOrPrefabInputFrameUpsync(inputFrameId, false); // Make sure that inputFrame exists locally
+      const existingInputFrame = self.recentInputCache.GetByFrameId(inputFrameId);
+      if (0 < (existingInputFrame.ConfirmedList & peerJoinIndexMask)) {
         continue;
       }
+      if (inputFrameId > self.lastIndividuallyConfirmedInputFrameId[peerJoinIndex - 1]) {
+        self.lastIndividuallyConfirmedInputFrameId[peerJoinIndex - 1] = inputFrameId;
+        self.lastIndividuallyConfirmedInputList[peerJoinIndex - 1] = peerEncodedInput;
+      }
       effCnt += 1;
       // the returned "gopkgs.NewInputFrameDownsync.InputList" is immutable, thus we can only modify the values in "newInputList" and "newConfirmedList"!
-      let newInputList = new Array(self.playerRichInfoDict.size).fill(0);
-      for (let i in existingInputFrame.InputList) {
-        newInputList[i] = existingInputFrame.InputList[i];
-      }
-      let newConfirmedList = (existingInputFrame.confirmedList | (1 << (peerJoinIndex - 1)));
-      // No need to change "lastAllConfirmedInputFrameId", leave it to "onInputFrameDownsyncBatch" -- we're just helping prediction here
-      const newInputFrameDownsyncLocal = gopkgs.NewInputFrameDownsync(inputFrameDownsyncId, newInputList, newConfirmedList);
-      self.recentInputCache.SetByFrameId(newInputFrameDownsyncLocal, inputFrameDownsyncId);
+      let newInputList = existingInputFrame.InputList.slice();
+      newInputList[peerJoinIndex - 1] = peerEncodedInput;
+      let newConfirmedList = (existingInputFrame.ConfirmedList | peerJoinIndex);
+      const newInputFrameDownsyncLocal = gopkgs.NewInputFrameDownsync(inputFrameId, newInputList, newConfirmedList);
+      //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 (0 < effCnt) {
+      //self._markConfirmationIfApplicable();
       self.networkDoctor.logPeerInputFrameUpsync(batch[0].inputFrameId, batch[batch.length - 1].inputFrameId);
     }
+    self._handleIncorrectlyRenderedPrediction(firstPredictedYetIncorrectInputFrameId, batch, fromUDP);
   },
 
   onPlayerAdded(rdf /* pb.RoomDownsyncFrame */ ) {
@@ -942,7 +1009,6 @@ batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inpu
     if (ALL_BATTLE_STATES.IN_BATTLE != self.battleState) {
       return;
     }
-    self._stringifyRdfIdToActuallyUsedInput();
     window.closeWSConnection(constants.RET_CODE.BATTLE_STOPPED, "");
     self.battleState = ALL_BATTLE_STATES.IN_SETTLEMENT;
     self.countdownNanos = null;
@@ -1009,13 +1075,13 @@ batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inpu
         let prevSelfInput = null,
           currSelfInput = null;
         if (gopkgs.ShouldGenerateInputFrameUpsync(self.renderFrameId)) {
-          [prevSelfInput, currSelfInput] = self.getOrPrefabInputFrameUpsync(noDelayInputFrameId);
+          [prevSelfInput, currSelfInput] = self.getOrPrefabInputFrameUpsync(noDelayInputFrameId, true);
         }
 
         const delayedInputFrameId = gopkgs.ConvertToDelayedInputFrameId(self.renderFrameId);
         if (null == self.recentInputCache.GetByFrameId(delayedInputFrameId)) {
           // Possible edge case after resync, kindly note that it's OK to prefab a "future inputFrame" here, because "sendInputFrameUpsyncBatch" would be capped by "noDelayInputFrameId from self.renderFrameId". 
-          self.getOrPrefabInputFrameUpsync(delayedInputFrameId);
+          self.getOrPrefabInputFrameUpsync(delayedInputFrameId, false);
         }
 
         let t0 = performance.now();
@@ -1070,7 +1136,7 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
         ++self.renderFrameId; // [WARNING] It's important to increment the renderFrameId AFTER all the operations above!!!
         self.lastRenderFrameIdTriggeredAt = performance.now();
         let t3 = performance.now();
-        self.skipRenderFrameFlag = self.networkDoctor.isTooFast();
+        self.skipRenderFrameFlag = self.networkDoctor.isTooFast(self);
       } catch (err) {
         console.error("Error during Map.update", err);
         self.onBattleStopped(); // TODO: Popup to ask player to refresh browser
@@ -1419,6 +1485,21 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
     return s.join(',');
   },
 
+  gopkgsInputFrameDownsyncStr(inputFrameDownsync) {
+    if (null == inputFrameDownsync) return "{}";
+    const self = this;
+    let s = [];
+    s.push(`InputFrameId:${inputFrameDownsync.InputFrameId}`);
+    let ss = [];
+    for (let k = 0; k < window.boundRoomCapacity; ++k) {
+      ss.push(`"${inputFrameDownsync.InputList[k]}"`);
+    }
+    s.push(`InputList:[${ss.join(',')}]`);
+    s.push(`ConfirmedList:${inputFrameDownsync.ConfirmedList}`);
+
+    return `{${s.join(',')}}`;
+  },
+
   _stringifyRdfIdToActuallyUsedInput() {
     const self = this;
     let s = [];

frontend/assets/scripts/NetworkDoctor.js

@@ -79,17 +79,29 @@ NetworkDoctor.prototype.logSkippedRenderFrameCnt = function() {
   this.skippedRenderFrameCnt += 1;
 }
 
-NetworkDoctor.prototype.isTooFast = function() {
-  return false;
+NetworkDoctor.prototype.isTooFast = function(mapIns) {
   const [sendingFps, srvDownsyncFps, peerUpsyncFps, rollbackFrames, skippedRenderFrameCnt] = this.stats();
-  if (sendingFps >= this.inputRateThreshold + 2) {
+  if (sendingFps >= this.inputRateThreshold + 3) {
     // Don't send too fast
+    console.log(`Sending too fast, sendingFps=${sendingFps}`);
     return true;
-  } else if (sendingFps >= this.inputRateThreshold && srvDownsyncFps >= this.inputRateThreshold) {
+  } 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".  
-    if (rollbackFrames >= this.rollbackFramesThreshold) {
-      // I got many frames rolled back while none of my peers effectively helped my preciction. Deliberately not using "peerUpsyncThreshold" here because when using UDP p2p upsync broadcasting, we expect to receive effective p2p upsyncs from every other player.   
-      return true;
+    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))) {
+        // first comparison condition is to avoid numeric overflow
+        console.log(`Game logic ticking too fast, selfInputFrameIdFront=${selfInputFrameIdFront}, minInputFrameIdFront=${minInputFrameIdFront}, inputFrameUpsyncDelayTolerance=${mapIns.inputFrameUpsyncDelayTolerance}`);
+        return true;
+      }
     }
   }
   return false;

frontend/assets/scripts/OfflineMap.js

@@ -189,7 +189,7 @@ cc.Class({
           currSelfInput = null;
         const noDelayInputFrameId = gopkgs.ConvertToNoDelayInputFrameId(self.renderFrameId); // It's important that "inputDelayFrames == 0" here 
         if (gopkgs.ShouldGenerateInputFrameUpsync(self.renderFrameId)) {
-          const prevAndCurrInputs = self.getOrPrefabInputFrameUpsync(noDelayInputFrameId);
+          const prevAndCurrInputs = self.getOrPrefabInputFrameUpsync(noDelayInputFrameId, true);
           prevSelfInput = prevAndCurrInputs[0];
           currSelfInput = prevAndCurrInputs[1];
         }

frontend/assets/scripts/WsSessionMgr.js

@@ -250,7 +250,8 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
     console.warn(`The WS clientSession is closed: evt=${JSON.stringify(evt)}, evt.code=${evt.code}`);
     if (cc.sys.isNative) {
       if (mapIns.frameDataLoggingEnabled) {
-        console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}`);
+        console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}
+`);
       }
       DelayNoMore.UdpSession.closeUdpSession();
     }
@@ -260,7 +261,8 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
       case constants.RET_CODE.BATTLE_STOPPED:
         // deliberately do nothing
         if (mapIns.frameDataLoggingEnabled) {
-          console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}`);
+          console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}
+`);
         }
         break;
       case constants.RET_CODE.PLAYER_NOT_ADDABLE_TO_ROOM:
@@ -277,7 +279,8 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
       case constants.RET_CODE.PLAYER_CHEATING:
       case 1006: // Peer(i.e. the backend) gone unexpectedly, but not working for "cc.sys.isNative" 
         if (mapIns.frameDataLoggingEnabled) {
-          console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}`);
+          console.warn(`${mapIns._stringifyRdfIdToActuallyUsedInput()}
+`);
         }
         window.clearLocalStorageAndBackToLoginScene(true);
         break;
@@ -335,7 +338,7 @@ window.initSecondarySession = function(onopenCb, boundRoomId) {
       //console.log(`Got non-empty onmessage decoded: resp.act=${resp.act}`);
       switch (resp.act) {
         case window.DOWNSYNC_MSG_ACT_PEER_INPUT_BATCH:
-          mapIns.onPeerInputFrameUpsync(resp.peerJoinIndex, resp.inputFrameDownsyncBatch);
+          mapIns.onPeerInputFrameUpsync(resp.peerJoinIndex, resp.inputFrameDownsyncBatch, false);
           break;
         default:
           break;

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

@@ -35,7 +35,7 @@ void _onRead(uv_udp_t* req, ssize_t nread, uv_buf_t const* buf, struct sockaddr
             struct sockaddr_in const* sockAddr = (struct sockaddr_in const*)addr;
             uv_inet_ntop(sockAddr->sin_family, &(sockAddr->sin_addr), ip, INET_ADDRSTRLEN);
             port = ntohs(sockAddr->sin_port);
-            //CCLOG("UDP received %d bytes from %s:%d", nread, ip, port);
+            CCLOG("UDP received %d bytes from %s:%d", nread, ip, port);
             break;
         }
         default:
@@ -325,6 +325,7 @@ bool DelayNoMore::UdpSession::openUdpSession(int port) {
 
     uv_udp_recv_start(udpSocket, _allocBuffer, _onRead);
 
+    // TODO: Currently "sending" is also done in the "receiving loop thread", shall I segregate it to another dedicated thread?
     uv_thread_create(&recvTid, startRecvLoop, loop);
 
     CCLOG("Finished opening UDP session at port=%d", port);
@@ -363,8 +364,15 @@ bool DelayNoMore::UdpSession::punchToServer(CHARC* const srvIp, int const srvPor
     SRV_PORT = srvPort;
     UDP_TUNNEL_SRV_PORT = udpTunnelSrvPort;
     PunchServerWork* work = new PunchServerWork(bytes, bytesLen, udpTunnelBytes, udpTunnelBytesBytesLen);
+
+    /*
+    TODO: Libuv is really inconvenient here, neither "uv_queue_work" nor "uv_async_init" is threadsafe(http ://docs.libuv.org/en/v1.x/threadpool.html#c.uv_queue_work)! What's the point of such a queue? It's even more difficult than writing my own implementation -- again a threadsafe RingBuff could be used to the rescue, yet I'd like to investigate more into how to make the following threadsafe APIs with minimum cross-platform C++ codes
+    - _sendMessage(...), should be both non-blocking & threadsafe, called from GameThread
+    - _onRead(...), should be called first in UvThread in an edge-triggered manner like idiomatic "epoll" or "kqueue", then dispatch the received message to GameThread by a threadsafe RingBuff
+    */ 
     uv_work_t* wrapper = (uv_work_t*)malloc(sizeof(uv_work_t));
     wrapper->data = work;
+
     uv_queue_work(loop, wrapper, _punchServerOnUvThread, _afterPunchServer);
 
     return true;

frontend/settings/project.json

@@ -71,7 +71,7 @@
     "shelter_z_reducer",
     "shelter"
   ],
-  "last-module-event-record-time": 1674632533161,
+  "last-module-event-record-time": 1675240036576,
   "simulator-orientation": false,
   "simulator-resolution": {
     "height": 640,

jsexport/battle/battle.go

@@ -24,7 +24,6 @@ const (
 
 	INPUT_DELAY_FRAMES = int32(6)  // in the count of render frames
 	INPUT_SCALE_FRAMES = uint32(2) // inputDelayedAndScaledFrameId = ((originalFrameId - InputDelayFrames) >> InputScaleFrames)
-	NST_DELAY_FRAMES   = int32(16) // network-single-trip delay in the count of render frames, proposed to be (InputDelayFrames >> 1) because we expect a round-trip delay to be exactly "InputDelayFrames"
 
 	SP_ATK_LOOKUP_FRAMES = int32(5)