Fixes for frontend chaser.

ConcerningEdgeCases.md

@@ -2,16 +2,16 @@
 1. Server received too late (solution: force confirmation)
 2. Client received too late (solution: prediction and frame chasing, big impact on user experience because the graphics will be inconsistent if mismatches occur too often)
 
-# Potential avalanche from local lag
+# Potential avalanche from `ACTIVE SLOW TICKER`
 Under the current "input delay" algorithm, the lag of a single player would cause all the other players to receive outdated commands, e.g. when at a certain moment   
-- player#1: renderFrameId = 100, significantly lagged due to local CPU overheated
+- player#1: renderFrameId = 100, **still active in battle but significantly lagged** due to local CPU overheated
 - player#2: renderFrameId = 240
 - player#3: renderFrameId = 239
 - player#4: renderFrameId = 242
 
 players #2, #3 #4 would receive "outdated(in their subjective feelings) but all-confirmed commands" from then on, thus forced to rollback and chase many frames - the lag due to "large range of frame-chasing" would then further deteriorate the situation - like an avalanche.   
 
-**BE CAUTIOUS, THIS SITUATION HAPPENS QUITE OFTEN FOR REAL DEVICES** where different operating systems and temporary CPU overheat cause different lags for different player in a same battle! If not properly handled, slow tickers would be `inputing in the "history" of other players`, resulting in too frequent prediction mismatch and thus inconsistent graphics for other players!
+**BE CAUTIOUS, THIS `ACTIVE SLOW TICKER` SITUATION HAPPENS QUITE OFTEN FOR REAL DEVICES** where different operating systems and temporary CPU overheat cause different lags for different player in a same battle! If not properly handled, slow tickers would be `inputing in the "history" of other players`, resulting in too frequent prediction mismatch and thus inconsistent graphics for other players!
 
 In a "no-server & p2p" setup, I couldn't think of a proper way to cope with such edge case. Solely on the frontend we could only mitigate the impact to players #2, #3, #4, e.g. a potential lag due to "large range of frame-chasing" is proactively avoided in `<proj-root>/frontend/assets/scripts/Map.js, function update(dt)`. 
 

battle_srv/Makefile

@@ -1,6 +1,7 @@
 PROJECTNAME=server.exe
 ROOT_DIR=.
-GOPROXY=https://mirrors.aliyun.com/goproxy 
+#GOPROXY=https://mirrors.aliyun.com/goproxy 
+GOPROXY=https://goproxy.io
 all: help
 
 gen-constants:

battle_srv/common/constants.json

@@ -1,28 +1,29 @@
 {
   "RET_CODE": {
-    "__comment__":"基础",
+    "__comment__": "Websocket",
-    "OK": 9000,
+    "OK": 3000,
-    "UNKNOWN_ERROR": 9001,
+    "UNKNOWN_ERROR": 3001,
-    "INVALID_REQUEST_PARAM": 9002,
+    "INVALID_REQUEST_PARAM": 3002,
-    "IS_TEST_ACC": 9003,
+    "IS_TEST_ACC": 3003,
-    "MYSQL_ERROR": 9004,
+    "MYSQL_ERROR": 3004,
-    "NONEXISTENT_ACT": 9005,
+    "NONEXISTENT_ACT": 3005,
-    "LACK_OF_DIAMOND": 9006,
+    "LACK_OF_DIAMOND": 3006,
-    "LACK_OF_GOLD": 9007,
+    "LACK_OF_GOLD": 3007,
-    "LACK_OF_ENERGY": 9008,
+    "LACK_OF_ENERGY": 3008,
-    "NONEXISTENT_ACT_HANDLER": 9009,
+    "NONEXISTENT_ACT_HANDLER": 3009,
-    "LOCALLY_NO_AVAILABLE_ROOM": 9010,
+    "LOCALLY_NO_AVAILABLE_ROOM": 3010,
-    "LOCALLY_NO_SPECIFIED_ROOM": 9011,
+    "LOCALLY_NO_SPECIFIED_ROOM": 3011,
-    "PLAYER_NOT_ADDABLE_TO_ROOM": 9012,
+    "PLAYER_NOT_ADDABLE_TO_ROOM": 3012,
-    "PLAYER_NOT_READDABLE_TO_ROOM": 9013,
+    "PLAYER_NOT_READDABLE_TO_ROOM": 3013,
-    "PLAYER_NOT_FOUND": 9014,
+    "PLAYER_NOT_FOUND": 3014,
-    "PLAYER_CHEATING": 9015,
+    "PLAYER_CHEATING": 3015,
-    "WECHAT_SERVER_ERROR": 9016,
+    "WECHAT_SERVER_ERROR": 3016,
-    "IS_BOT_ACC": 9017,
+    "IS_BOT_ACC": 3017,
+    "ACTIVE_WATCHDOG": 3018,
+    "BATTLE_STOPPED": 3019,
+    "CLIENT_MISMATCHED_RENDER_FRAME": 3020,
 
-    "__comment__":"SMS",
+    "__comment__": "OTHERS",
-    "SMS_CAPTCHA_REQUESTED_TOO_FREQUENTLY": 5001,
-    "SMS_CAPTCHA_NOT_MATCH": 5002,
     "INVALID_TOKEN": 2001,
 
     "DUPLICATED": 2002,
@@ -39,12 +40,15 @@
     "FAILED_TO_DELETE": 2015,
     "FAILED_TO_CREATE": 2016,
     "INCORRECT_PHONE_NUMBER": 2018,
-    "INSUFFICIENT_MEM_TO_ALLOCATE_CONNECTION": 3001,
+    "INSUFFICIENT_MEM_TO_ALLOCATE_CONNECTION": 2019,
-    "PASSWORD_RESET_CODE_GENERATION_PER_EMAIL_TOO_FREQUENTLY": 4000,
+    "PASSWORD_RESET_CODE_GENERATION_PER_EMAIL_TOO_FREQUENTLY": 2020,
-    "TRADE_CREATION_TOO_FREQUENTLY": 4002,
+    "TRADE_CREATION_TOO_FREQUENTLY": 2021,
-    "MAP_NOT_UNLOCKED": 4003,
+    "MAP_NOT_UNLOCKED": 2022,
+
+    "GET_SMS_CAPTCHA_RESP_ERROR_CODE": 2023,
+    "SMS_CAPTCHA_REQUESTED_TOO_FREQUENTLY": 2024,
+    "SMS_CAPTCHA_NOT_MATCH": 2025,
 
-    "GET_SMS_CAPTCHA_RESP_ERROR_CODE": 5003,
     "NOT_IMPLEMENTED_YET": 65535
   },
   "AUTH_CHANNEL": {
@@ -62,6 +66,6 @@
   },
   "WS": {
     "INTERVAL_TO_PING": 2000,
-    "WILL_KICK_IF_INACTIVE_FOR": 6000
+    "WILL_KICK_IF_INACTIVE_FOR": 4000
   }
 }

battle_srv/common/constants_struct.go

@@ -15,10 +15,13 @@ type constants struct {
 		SmsValidResendPeriodSeconds int `json:"SMS_VALID_RESEND_PERIOD_SECONDS"`
 	} `json:"PLAYER"`
 	RetCode struct {
+		ActiveWatchdog                                   int    `json:"ACTIVE_WATCHDOG"`
+		BattleStopped                                    int    `json:"BATTLE_STOPPED"`
 		Duplicated                                       int    `json:"DUPLICATED"`
 		FailedToCreate                                   int    `json:"FAILED_TO_CREATE"`
 		FailedToDelete                                   int    `json:"FAILED_TO_DELETE"`
 		FailedToUpdate                                   int    `json:"FAILED_TO_UPDATE"`
+		GetSmsCaptchaRespErrorCode                       int    `json:"GET_SMS_CAPTCHA_RESP_ERROR_CODE"`
 		IncorrectCaptcha                                 int    `json:"INCORRECT_CAPTCHA"`
 		IncorrectHandle                                  int    `json:"INCORRECT_HANDLE"`
 		IncorrectPassword                                int    `json:"INCORRECT_PASSWORD"`
@@ -28,27 +31,26 @@ type constants struct {
 		InvalidEmailLiteral                              int    `json:"INVALID_EMAIL_LITERAL"`
 		InvalidRequestParam                              int    `json:"INVALID_REQUEST_PARAM"`
 		InvalidToken                                     int    `json:"INVALID_TOKEN"`
-		IsTestAcc                                        int    `json:"IS_TEST_ACC"`
 		IsBotAcc                                         int    `json:"IS_BOT_ACC"`
+		IsTestAcc                                        int    `json:"IS_TEST_ACC"`
 		LackOfDiamond                                    int    `json:"LACK_OF_DIAMOND"`
 		LackOfEnergy                                     int    `json:"LACK_OF_ENERGY"`
 		LackOfGold                                       int    `json:"LACK_OF_GOLD"`
+		LocallyNoAvailableRoom                           int    `json:"LOCALLY_NO_AVAILABLE_ROOM"`
+		LocallyNoSpecifiedRoom                           int    `json:"LOCALLY_NO_SPECIFIED_ROOM"`
 		MapNotUnlocked                                   int    `json:"MAP_NOT_UNLOCKED"`
 		MysqlError                                       int    `json:"MYSQL_ERROR"`
-		GetSmsCaptchaRespErrorCode                       int    `json:"GET_SMS_CAPTCHA_RESP_ERROR_CODE"`
 		NewHandleConflict                                int    `json:"NEW_HANDLE_CONFLICT"`
 		NonexistentAct                                   int    `json:"NONEXISTENT_ACT"`
 		NonexistentActHandler                            int    `json:"NONEXISTENT_ACT_HANDLER"`
-		LocallyNoAvailableRoom                           int    `json:"LOCALLY_NO_AVAILABLE_ROOM"`
-		LocallyNoSpecifiedRoom                           int    `json:"LOCALLY_NO_SPECIFIED_ROOM"`
-		PlayerNotAddableToRoom                           int    `json:"PLAYER_NOT_ADDABLE_TO_ROOM"`
-		PlayerNotReAddableToRoom                         int    `json:"PLAYER_NOT_READDABLE_TO_ROOM"`
-		PlayerNotFound                                   int    `json:"PLAYER_NOT_FOUND"`
-		PlayerCheating                                   int    `json:"PLAYER_CHEATING"`
 		NotImplementedYet                                int    `json:"NOT_IMPLEMENTED_YET"`
 		NoAssociatedEmail                                int    `json:"NO_ASSOCIATED_EMAIL"`
 		Ok                                               int    `json:"OK"`
 		PasswordResetCodeGenerationPerEmailTooFrequently int    `json:"PASSWORD_RESET_CODE_GENERATION_PER_EMAIL_TOO_FREQUENTLY"`
+		PlayerCheating                                   int    `json:"PLAYER_CHEATING"`
+		PlayerNotAddableToRoom                           int    `json:"PLAYER_NOT_ADDABLE_TO_ROOM"`
+		PlayerNotFound                                   int    `json:"PLAYER_NOT_FOUND"`
+		PlayerNotReaddableToRoom                         int    `json:"PLAYER_NOT_READDABLE_TO_ROOM"`
 		SendEmailTimeout                                 int    `json:"SEND_EMAIL_TIMEOUT"`
 		SmsCaptchaNotMatch                               int    `json:"SMS_CAPTCHA_NOT_MATCH"`
 		SmsCaptchaRequestedTooFrequently                 int    `json:"SMS_CAPTCHA_REQUESTED_TOO_FREQUENTLY"`

battle_srv/models/room.go

@@ -151,6 +151,7 @@ type Room struct {
 	*/
 	PlayerDownsyncSessionDict              map[int32]*websocket.Conn
 	PlayerDownsyncChanDict                 map[int32](chan InputsBufferSnapshot)
+	PlayerActiveWatchdogDict               map[int32](*Watchdog)
 	PlayerSignalToCloseDict                map[int32]SignalToCloseConnCbType
 	Score                                  float32
 	State                                  int32
@@ -169,9 +170,10 @@ type Room struct {
 	LastAllConfirmedInputList              []uint64
 	JoinIndexBooleanArr                    []bool
 
-	BackendDynamicsEnabled       bool
+	BackendDynamicsEnabled              bool
-	LastRenderFrameIdTriggeredAt int64
+	ForceAllResyncOnAnyActiveSlowTicker bool
-	PlayerDefaultSpeed           int32
+	LastRenderFrameIdTriggeredAt        int64
+	PlayerDefaultSpeed                  int32
 
 	BulletBattleLocalIdCounter      int32
 	dilutedRollbackEstimatedDtNanos int64
@@ -207,6 +209,12 @@ func (pR *Room) AddPlayerIfPossible(pPlayerFromDbInit *Player, session *websocke
 	pR.Players[playerId] = pPlayerFromDbInit
 	pR.PlayerDownsyncSessionDict[playerId] = session
 	pR.PlayerSignalToCloseDict[playerId] = signalToCloseConnOfThisPlayer
+	newWatchdog := NewWatchdog(ConstVals.Ws.WillKickIfInactiveFor, func() {
+		Logger.Warn("Conn inactive watchdog triggered#1:", zap.Any("playerId", playerId), zap.Any("roomId", pR.Id), zap.Any("roomState", pR.State), zap.Any("roomEffectivePlayerCount", pR.EffectivePlayerCount))
+		signalToCloseConnOfThisPlayer(Constants.RetCode.ActiveWatchdog, "")
+	})
+	newWatchdog.Stop()
+	pR.PlayerActiveWatchdogDict[playerId] = newWatchdog
 	return true
 }
 
@@ -238,6 +246,10 @@ func (pR *Room) ReAddPlayerIfPossible(pTmpPlayerInstance *Player, session *webso
 
 	pR.PlayerDownsyncSessionDict[playerId] = session
 	pR.PlayerSignalToCloseDict[playerId] = signalToCloseConnOfThisPlayer
+	pR.PlayerActiveWatchdogDict[playerId] = NewWatchdog(ConstVals.Ws.WillKickIfInactiveFor, func() {
+		Logger.Warn("Conn inactive watchdog triggered#2:", zap.Any("playerId", playerId), zap.Any("roomId", pR.Id), zap.Any("roomState", pR.State), zap.Any("roomEffectivePlayerCount", pR.EffectivePlayerCount))
+		signalToCloseConnOfThisPlayer(Constants.RetCode.ActiveWatchdog, "")
+	}) // For ReAdded player the new watchdog starts immediately
 
 	Logger.Warn("ReAddPlayerIfPossible finished.", zap.Any("roomId", pR.Id), zap.Any("playerId", playerId), zap.Any("joinIndex", pEffectiveInRoomPlayerInstance.JoinIndex), zap.Any("playerBattleState", pEffectiveInRoomPlayerInstance.BattleState), zap.Any("roomState", pR.State), zap.Any("roomEffectivePlayerCount", pR.EffectivePlayerCount), zap.Any("AckingFrameId", pEffectiveInRoomPlayerInstance.AckingFrameId), zap.Any("AckingInputFrameId", pEffectiveInRoomPlayerInstance.AckingInputFrameId), zap.Any("LastSentInputFrameId", pEffectiveInRoomPlayerInstance.LastSentInputFrameId))
 	return true
@@ -368,11 +380,10 @@ func (pR *Room) InputsBufferString(allDetails bool) string {
 				break
 			}
 			f := tmp.(*InputFrameDownsync)
-			//s = append(s, fmt.Sprintf("{inputFrameId: %v, inputList: %v, &inputList: %p, confirmedList: %v}", f.InputFrameId, f.InputList, &(f.InputList), f.ConfirmedList))
+			s = append(s, fmt.Sprintf("{\"inputFrameId\":%d,\"inputList\":%v,\"confirmedList\":\"%d\"}", f.InputFrameId, f.InputList, f.ConfirmedList))
-			s = append(s, fmt.Sprintf("{inputFrameId: %v, inputList: %v, confirmedList: %v}", f.InputFrameId, f.InputList, f.ConfirmedList))
 		}
 
-		return strings.Join(s, "; ")
+		return strings.Join(s, "\n")
 	} else {
 		return fmt.Sprintf("{renderFrameId: %d, stInputFrameId: %d, edInputFrameId: %d, lastAllConfirmedInputFrameIdWithChange: %d, lastAllConfirmedInputFrameId: %d}", pR.RenderFrameId, pR.InputsBuffer.StFrameId, pR.InputsBuffer.EdFrameId, pR.LastAllConfirmedInputFrameIdWithChange, pR.LastAllConfirmedInputFrameId)
 	}
@@ -421,6 +432,9 @@ func (pR *Room) StartBattle() {
 		pR.LastRenderFrameIdTriggeredAt = utils.UnixtimeNano()
 		battleStartedAt := utils.UnixtimeNano()
 		Logger.Info("The `battleMainLoop` is started for:", zap.Any("roomId", pR.Id))
+		for _, watchdog := range pR.PlayerActiveWatchdogDict {
+			watchdog.Kick()
+		}
 		for {
 			stCalculation := utils.UnixtimeNano()
 			elapsedNanosSinceLastFrameIdTriggered := stCalculation - pR.LastRenderFrameIdTriggeredAt
@@ -559,6 +573,10 @@ func (pR *Room) OnBattleCmdReceived(pReq *WsReq) {
 		return
 	}
 
+	if watchdog, existent := pR.PlayerActiveWatchdogDict[playerId]; existent {
+		watchdog.Kick()
+	}
+
 	atomic.StoreInt32(&(player.AckingFrameId), ackingFrameId)
 	atomic.StoreInt32(&(player.AckingInputFrameId), ackingInputFrameId)
 
@@ -723,6 +741,10 @@ func (pR *Room) OnDismissed() {
 	pR.PlayersArr = make([]*Player, pR.Capacity)
 	pR.CollisionSysMap = make(map[int32]*resolv.Object)
 	pR.PlayerDownsyncSessionDict = make(map[int32]*websocket.Conn)
+	for _, oldWatchdog := range pR.PlayerActiveWatchdogDict {
+		oldWatchdog.Stop()
+	}
+	pR.PlayerActiveWatchdogDict = make(map[int32]*Watchdog)
 	for _, oldChan := range pR.PlayerDownsyncChanDict {
 		close(oldChan)
 	}
@@ -742,19 +764,20 @@ func (pR *Room) OnDismissed() {
 	pR.RenderFrameId = 0
 	pR.CurDynamicsRenderFrameId = 0
 	pR.InputDelayFrames = 8
-	pR.NstDelayFrames = 8
+	pR.NstDelayFrames = 16
 	pR.InputScaleFrames = uint32(2)
 	pR.ServerFps = 60
 	pR.RollbackEstimatedDtMillis = 16.667  // Use fixed-and-low-precision to mitigate the inconsistent floating-point-number issue between Golang and JavaScript
 	pR.RollbackEstimatedDtNanos = 16666666 // A little smaller than the actual per frame time, just for logging FAST FRAME
 	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(pR.ServerFps) / dilutedServerFps)
-	pR.BattleDurationFrames = 90 * pR.ServerFps
+	pR.BattleDurationFrames = 60 * pR.ServerFps
 	pR.BattleDurationNanos = int64(pR.BattleDurationFrames) * (pR.RollbackEstimatedDtNanos + 1)
-	pR.InputFrameUpsyncDelayTolerance = 2
+	pR.InputFrameUpsyncDelayTolerance = (pR.NstDelayFrames >> pR.InputScaleFrames) - 1 // this value should be strictly smaller than (NstDelayFrames >> InputScaleFrames), otherwise "type#1 forceConfirmation" might become a lag avalanche
-	pR.MaxChasingRenderFramesPerUpdate = 8
+	pR.MaxChasingRenderFramesPerUpdate = 12                                            // Don't set this value too high to avoid exhausting frontend CPU within a single frame
 
-	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.ForceAllResyncOnAnyActiveSlowTicker = true // See tradeoff discussion in "downsyncToAllPlayers"
 	punchSkillId := int32(1)
 	pR.MeleeSkillConfig = make(map[int32]*MeleeBullet, 0)
 	pR.MeleeSkillConfig[punchSkillId] = &MeleeBullet{
@@ -855,7 +878,7 @@ func (pR *Room) OnPlayerDisconnected(playerId int32) {
 	default:
 		atomic.StoreInt32(&(pR.Players[playerId].BattleState), PlayerBattleStateIns.DISCONNECTED)
 		pR.clearPlayerNetworkSession(playerId) // Still need clear the network session pointers, because "OnPlayerDisconnected" is only triggered from "signalToCloseConnOfThisPlayer" in "ws/serve.go", when the same player reconnects the network session pointers will be re-assigned
-		Logger.Warn("OnPlayerDisconnected finished:", zap.Any("roomId", pR.Id), zap.Any("playerId", playerId), zap.Any("playerBattleState", pR.Players[playerId].BattleState), zap.Any("nowRoomBattleState", pR.State), zap.Any("nowRoomEffectivePlayerCount", pR.EffectivePlayerCount))
+		Logger.Warn("OnPlayerDisconnected finished:", zap.Any("roomId", pR.Id), zap.Any("playerId", playerId), zap.Any("playerBattleState", pR.Players[playerId].BattleState), zap.Any("nowRoomBattleState", pR.State), zap.Any("nowRoomEffectivePlayerCount", pR.EffectivePlayerCount), zap.Any("now InputsBuffer", pR.InputsBufferString(true)))
 	}
 }
 
@@ -884,6 +907,8 @@ func (pR *Room) clearPlayerNetworkSession(playerId int32) {
 	if _, y := pR.PlayerDownsyncSessionDict[playerId]; y {
 		Logger.Debug("clearPlayerNetworkSession:", zap.Any("roomId", pR.Id), zap.Any("playerId", playerId))
 		// [WARNING] No need to close "pR.PlayerDownsyncChanDict[playerId]" immediately!
+		pR.PlayerActiveWatchdogDict[playerId].Stop()
+		delete(pR.PlayerActiveWatchdogDict, playerId)
 		delete(pR.PlayerDownsyncSessionDict, playerId)
 		delete(pR.PlayerSignalToCloseDict, playerId)
 	}
@@ -946,7 +971,6 @@ func (pR *Room) OnPlayerBattleColliderAcked(playerId int32) bool {
 	if false == existing {
 		return false
 	}
-
 	shouldTryToStartBattle := true
 	Logger.Debug(fmt.Sprintf("OnPlayerBattleColliderAcked-before: roomId=%v, roomState=%v, targetPlayerId=%v, targetPlayerBattleState=%v, capacity=%v, EffectivePlayerCount=%v", pR.Id, pR.State, targetPlayer.Id, targetPlayer.BattleState, pR.Capacity, pR.EffectivePlayerCount))
 	targetPlayerBattleState := atomic.LoadInt32(&(targetPlayer.BattleState))
@@ -1040,7 +1064,7 @@ func (pR *Room) shouldPrefabInputFrameDownsync(prevRenderFrameId int32, renderFr
 	return false, -1
 }
 
-func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *InputFrameDownsync {
+func (pR *Room) getOrPrefabInputFrameDownsync(inputFrameId int32) *InputFrameDownsync {
 	/*
 	   [WARNING] This function MUST BE called while "pR.InputsBufferLock" is locked.
 
@@ -1060,7 +1084,11 @@ func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *InputFrameDownsync
 				ConfirmedList: uint64(0),
 			}
 
-			tmp2 := pR.InputsBuffer.GetByFrameId(j - 1) // There's no need for the backend to find the "lastAllConfirmed inputs" for prefabbing, either "BackendDynamicsEnabled" is true or false
+			j2 := j - 1
+			if 0 <= pR.LastAllConfirmedInputFrameId && j2 >= pR.LastAllConfirmedInputFrameId {
+				j2 = pR.LastAllConfirmedInputFrameId
+			}
+			tmp2 := pR.InputsBuffer.GetByFrameId(j2)
 			if nil != tmp2 {
 				prevInputFrameDownsync := tmp2.(*InputFrameDownsync)
 				for i, _ := range currInputFrameDownsync.InputList {
@@ -1079,6 +1107,7 @@ func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *InputFrameDownsync
 
 func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*InputFrameUpsync, playerId int32, player *Player) *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 {
 		clientInputFrameId := inputFrameUpsync.InputFrameId
 		if clientInputFrameId < pR.InputsBuffer.StFrameId {
@@ -1087,29 +1116,24 @@ func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*InputFrame
 			continue
 		}
 		if clientInputFrameId < pR.LastAllConfirmedInputFrameId {
-			Logger.Info(fmt.Sprintf("Omitting obsolete inputFrameUpsync#2: roomId=%v, playerId=%v, clientInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, clientInputFrameId, pR.InputsBufferString(false)))
+			Logger.Debug(fmt.Sprintf("Omitting obsolete inputFrameUpsync#2: roomId=%v, playerId=%v, clientInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, clientInputFrameId, pR.InputsBufferString(false)))
 			continue
 		}
 		if clientInputFrameId > pR.InputsBuffer.EdFrameId {
 			Logger.Warn(fmt.Sprintf("Dropping too advanced inputFrameUpsync: roomId=%v, playerId=%v, clientInputFrameId=%v, InputsBuffer=%v; is this player cheating?", pR.Id, playerId, clientInputFrameId, pR.InputsBufferString(false)))
 			continue
 		}
-		var targetInputFrameDownsync *InputFrameDownsync = nil
+		// by now "clientInputFrameId <= pR.InputsBuffer.EdFrameId"
-		if clientInputFrameId == pR.InputsBuffer.EdFrameId {
+		targetInputFrameDownsync := pR.getOrPrefabInputFrameDownsync(clientInputFrameId)
-			targetInputFrameDownsync = pR.prefabInputFrameDownsync(clientInputFrameId)
-			Logger.Debug(fmt.Sprintf("OnBattleCmdReceived-Prefabbed new inputFrameDownsync from inputFrameUpsync: roomId=%v, playerId=%v, clientInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, clientInputFrameId, pR.InputsBufferString(false)))
-		} else {
-			targetInputFrameDownsync = pR.InputsBuffer.GetByFrameId(clientInputFrameId).(*InputFrameDownsync)
-			Logger.Debug(fmt.Sprintf("OnBattleCmdReceived-stuffing inputFrameDownsync from inputFrameUpsync: roomId=%v, playerId=%v, clientInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, clientInputFrameId, pR.InputsBufferString(false)))
-		}
 		targetInputFrameDownsync.InputList[player.JoinIndex-1] = inputFrameUpsync.Encoded
 		targetInputFrameDownsync.ConfirmedList |= uint64(1 << uint32(player.JoinIndex-1))
 
-		if inputFrameUpsync.InputFrameId > pR.LatestPlayerUpsyncedInputFrameId {
+		if clientInputFrameId > pR.LatestPlayerUpsyncedInputFrameId {
-			pR.LatestPlayerUpsyncedInputFrameId = inputFrameUpsync.InputFrameId
+			pR.LatestPlayerUpsyncedInputFrameId = clientInputFrameId
 		}
 	}
 
+	// Step#2, mark confirmation without forcing
 	newAllConfirmedCount := int32(0)
 	inputFrameId1 := pR.LastAllConfirmedInputFrameId + 1
 	totPlayerCnt := uint32(pR.Capacity)
@@ -1127,122 +1151,100 @@ func (pR *Room) markConfirmationIfApplicable(inputFrameUpsyncBatch []*InputFrame
 			for _, player := range pR.PlayersArr {
 				thatPlayerBattleState := atomic.LoadInt32(&(player.BattleState))
 				thatPlayerJoinMask := uint64(1 << uint32(player.JoinIndex-1))
-				if 0 == (inputFrameDownsync.ConfirmedList & thatPlayerJoinMask) {
+				isSlowTicker := (0 == (inputFrameDownsync.ConfirmedList & thatPlayerJoinMask))
-					if thatPlayerBattleState == PlayerBattleStateIns.ACTIVE {
+				isActiveSlowTicker := (isSlowTicker && thatPlayerBattleState == PlayerBattleStateIns.ACTIVE)
-						shouldBreakConfirmation = true
+				if isActiveSlowTicker {
-						break
+					shouldBreakConfirmation = true // Could be an `ACTIVE SLOW TICKER` here, but no action needed for now
-					} else {
+					break
-						Logger.Debug(fmt.Sprintf("markConfirmationIfApplicable for roomId=%v, skipping UNCONFIRMED BUT INACTIVE player(id:%v, joinIndex:%v) while checking inputFrameId=[%v, %v): InputsBuffer=%v", pR.Id, player.Id, player.JoinIndex, inputFrameId1, pR.InputsBuffer.EdFrameId, pR.InputsBufferString(false)))
-					}
 				}
+				Logger.Debug(fmt.Sprintf("markConfirmationIfApplicable for roomId=%v, skipping UNCONFIRMED BUT INACTIVE player(id:%v, joinIndex:%v) while checking inputFrameId=[%v, %v): InputsBuffer=%v", pR.Id, player.Id, player.JoinIndex, inputFrameId1, pR.InputsBuffer.EdFrameId, pR.InputsBufferString(false)))
 			}
 		}
 
 		if shouldBreakConfirmation {
 			break
-		} else {
-			newAllConfirmedCount += 1
-			pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
 		}
+		newAllConfirmedCount += 1
+		pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
 	}
 
 	if 0 < newAllConfirmedCount {
-		refRenderFrameIdIfNeeded := pR.CurDynamicsRenderFrameId - 1
 		/*
-		   [WARNING]
+					   [WARNING]
 
-		   If "pR.InputsBufferLock" was previously held by "doBattleMainLoopPerTickBackendDynamicsWithProperLocking", then this value would be just (pR.LastAllConfirmedInputFrameId - newAllConfirmedCount).
+					   If "pR.InputsBufferLock" was previously held by "doBattleMainLoopPerTickBackendDynamicsWithProperLocking", then "snapshotStFrameId" would be just (LastAllConfirmedInputFrameId - newAllConfirmedCount).
 
-		   However if "pR.InputsBufferLock" was previously held by another "OnBattleCmdReceived", this value might be smaller than (pR.LastAllConfirmedInputFrameId - newAllConfirmedCount)!
+					   However if "pR.InputsBufferLock" was previously held by another "OnBattleCmdReceived", the proper value for "snapshotStFrameId" might be smaller than (pR.LastAllConfirmedInputFrameId - newAllConfirmedCount) -- but why? Especially when we've already wrapped this whole function in "InputsBufferLock", the order of "markConfirmationIfApplicable" generated snapshots is preserved for sending, isn't (LastAllConfirmedInputFrameId - newAllConfirmedCount) good enough here?
+
+			           Unfortunately no, for a reconnected player to get recovered asap (of course with BackendDynamicsEnabled), we put a check of READDED_BATTLE_COLLIDER_ACKED in "downsyncToSinglePlayer" -- which could be called right after "markConfirmationIfApplicable" yet without going through "forceConfirmationIfApplicable" -- and if a READDED_BATTLE_COLLIDER_ACKED player is found there we need a proper "(refRenderFrameId, snapshotStFrameId)" pair for that player!
 		*/
-		snapshotStFrameId := pR.ConvertToInputFrameId(refRenderFrameIdIfNeeded, pR.InputDelayFrames)
+		snapshotStFrameId := (pR.LastAllConfirmedInputFrameId - newAllConfirmedCount)
-		// Duplicate downsynced inputFrameIds will be filtered out by frontend.
+		refRenderFrameIdIfNeeded := pR.CurDynamicsRenderFrameId - 1
-		toSendInputFrameDownsyncs := pR.cloneInputsBuffer(snapshotStFrameId, pR.LastAllConfirmedInputFrameId+1)
+		refSnapshotStFrameId := pR.ConvertToInputFrameId(refRenderFrameIdIfNeeded, pR.InputDelayFrames)
-		Logger.Debug(fmt.Sprintf("markConfirmationIfApplicable for roomId=%v returning newAllConfirmedCount=%d: InputsBuffer=%v", pR.Id, newAllConfirmedCount, pR.InputsBufferString(false)))
+		if refSnapshotStFrameId < snapshotStFrameId {
-		return &InputsBufferSnapshot{
+			snapshotStFrameId = refSnapshotStFrameId
-			RefRenderFrameId:          refRenderFrameIdIfNeeded,
-			UnconfirmedMask:           uint64(0),
-			ToSendInputFrameDownsyncs: toSendInputFrameDownsyncs,
 		}
+		Logger.Debug(fmt.Sprintf("markConfirmationIfApplicable for roomId=%v returning newAllConfirmedCount=%d: InputsBuffer=%v", pR.Id, newAllConfirmedCount, pR.InputsBufferString(false)))
+		return pR.produceInputsBufferSnapshotWithCurDynamicsRenderFrameAsRef(uint64(0), snapshotStFrameId, pR.LastAllConfirmedInputFrameId+1)
 	} else {
 		return nil
 	}
 }
 
-func (pR *Room) forceConfirmationIfApplicable(prevRenderFrameId int32) *InputsBufferSnapshot {
+func (pR *Room) forceConfirmationIfApplicable(prevRenderFrameId int32) uint64 {
 	// [WARNING] This function MUST BE called while "pR.InputsBufferLock" is locked!
-	// Force confirmation of non-all-confirmed inputFrame EXACTLY ONE AT A TIME, returns the non-confirmed mask of players, e.g. in a 4-player-battle returning 1001 means that players with JoinIndex=1 and JoinIndex=4 are non-confirmed for inputFrameId2
-
-	inputFrameId2 := int32(-1)
-	if pR.LatestPlayerUpsyncedInputFrameId > (pR.LastAllConfirmedInputFrameId + (pR.NstDelayFrames >> pR.InputScaleFrames)) {
-		// Type#1 check whether there's a significantly slow ticker among players
-		Logger.Warn(fmt.Sprintf("[type#1 forceConfirmation]For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, LatestPlayerUpsyncedInputFrameId:%d, LastAllConfirmedInputFrameId:%d, (pR.NstDelayFrames >> pR.InputScaleFrames):%d; there's a slow ticker suspect, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LatestPlayerUpsyncedInputFrameId, pR.LastAllConfirmedInputFrameId, (pR.NstDelayFrames >> pR.InputScaleFrames)))
-		inputFrameId2 = pR.LastAllConfirmedInputFrameId + 1
-	} else {
-		// Type#2 check whether there's a significantly slow ticker w.r.t. BackendDynamics, this applies when all players are disconnected temporarily
-		renderFrameId1 := (pR.RenderFrameId - pR.NstDelayFrames) // the "renderFrameId" which should've been rendered on frontend
-		if 0 > renderFrameId1 {
-			// Battle is still in an early stage, no action needed even if there were slow tickers
-			return nil
-		}
-		if ok, renderFrameId2 := pR.shouldPrefabInputFrameDownsync(prevRenderFrameId-pR.NstDelayFrames, renderFrameId1); ok {
-			/*
-			   The backend "shouldPrefabInputFrameDownsync" shares the same rule as frontend "shouldGenerateInputFrameUpsync".
-
-			   It's also important that "forceConfirmationIfApplicable" is NOT EXECUTED for every renderFrame, such that when a player is forced to resync, it has some time, i.e. (1 << InputScaleFrames) renderFrames, to upsync again.
-			*/
-			inputFrameId2 = pR.ConvertToInputFrameId(renderFrameId2, 0) // The inputFrame to force confirmation (if necessary)
-			if inputFrameId2 > pR.LastAllConfirmedInputFrameId {
-				Logger.Debug(fmt.Sprintf("[type#2 forceConfirmation]For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, renderFrameId1:%d, renderFrameId2:%d, NstDelayFrames:%d, inputFrameId2:%d, LastAllConfirmedInputFrameId:%d; there's a slow ticker suspect, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, renderFrameId1, renderFrameId2, pR.NstDelayFrames, inputFrameId2, pR.LastAllConfirmedInputFrameId))
-			}
-		}
-	}
-
-	if pR.LastAllConfirmedInputFrameId >= inputFrameId2 {
-		// No need to force confirmation for either type
-		Logger.Debug(fmt.Sprintf("inputFrameId2=%v is already all-confirmed for roomId=%v, no need to force confirmation", inputFrameId2, pR.Id))
-		return nil
-	}
-
-	tmp := pR.InputsBuffer.GetByFrameId(inputFrameId2)
-	if nil == tmp {
-		panic(fmt.Sprintf("For roomId=%d, inputFrameId2=%v doesn't exist, this is abnormal because the server should prefab inputFrameDownsync in a most advanced pace, check the prefab logic! InputsBuffer=%v", pR.Id, inputFrameId2, pR.InputsBufferString(false)))
-	}
-
 	totPlayerCnt := uint32(pR.Capacity)
 	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
-
+	unconfirmedMask := uint64(0)
-	// Force confirmation of "inputFrame2"
+	if pR.LatestPlayerUpsyncedInputFrameId > (pR.LastAllConfirmedInputFrameId + (pR.NstDelayFrames >> pR.InputScaleFrames)) {
-	inputFrame2 := tmp.(*InputFrameDownsync)
+		// Type#1 check whether there's a significantly slow ticker among players
-	oldConfirmedList := inputFrame2.ConfirmedList
+		oldLastAllConfirmedInputFrameId := pR.LastAllConfirmedInputFrameId
-	unconfirmedMask := (oldConfirmedList ^ allConfirmedMask)
+		for j := pR.LastAllConfirmedInputFrameId + 1; j <= pR.LatestPlayerUpsyncedInputFrameId; j++ {
-	inputFrame2.ConfirmedList = allConfirmedMask
+			tmp := pR.InputsBuffer.GetByFrameId(j)
-	pR.onInputFrameDownsyncAllConfirmed(inputFrame2, -1)
+			if nil == tmp {
-
+				panic(fmt.Sprintf("inputFrameId=%v doesn't exist for roomId=%v! InputsBuffer=%v", j, pR.Id, pR.InputsBufferString(false)))
-	if 0 < unconfirmedMask {
+			}
-		// This condition should be rarely met!
+			inputFrameDownsync := tmp.(*InputFrameDownsync)
-		/*
+			unconfirmedMask |= (allConfirmedMask ^ inputFrameDownsync.ConfirmedList)
-		   Upon resynced on frontend, "refRenderFrameId" is now set to as advanced as possible, and it's the frontend's responsibility now to pave way for the "gap inputFrames"
+			inputFrameDownsync.ConfirmedList = allConfirmedMask
-
+			pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
-		   If "NstDelayFrames" becomes larger, "pR.RenderFrameId - refRenderFrameId" possibly becomes larger because the force confirmation is delayed more.
-
-		   Upon resync, it's still possible that "refRenderFrameId < frontend.chaserRenderFrameId" -- and this is allowed.
-		*/
-		refRenderFrameIdIfNeeded := pR.ConvertToLastUsedRenderFrameId(pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames)
-		if 0 > refRenderFrameIdIfNeeded {
-			// Without a "refRenderFrame", there's no point to force confirmation, i.e. nothing to downsync to the "ACTIVE but slowly ticking frontend(s)"
-			return nil
 		}
-		snapshotStFrameId := pR.ConvertToInputFrameId(refRenderFrameIdIfNeeded, pR.InputDelayFrames)
+		if 0 < unconfirmedMask {
-		toSendInputFrameDownsyncs := pR.cloneInputsBuffer(snapshotStFrameId, pR.LastAllConfirmedInputFrameId+1)
+			Logger.Debug(fmt.Sprintf("[type#1 forceConfirmation] For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, LatestPlayerUpsyncedInputFrameId:%d, LastAllConfirmedInputFrameId:%d, (pR.NstDelayFrames >> pR.InputScaleFrames):%d, InputFrameUpsyncDelayTolerance:%d, unconfirmedMask=%d; there's a slow ticker suspect, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LatestPlayerUpsyncedInputFrameId, oldLastAllConfirmedInputFrameId, (pR.NstDelayFrames >> pR.InputScaleFrames), pR.InputFrameUpsyncDelayTolerance, unconfirmedMask))
-		return &InputsBufferSnapshot{
-			RefRenderFrameId:          refRenderFrameIdIfNeeded,
-			UnconfirmedMask:           unconfirmedMask,
-			ToSendInputFrameDownsyncs: toSendInputFrameDownsyncs,
 		}
 	} else {
+		// Type#2 helps resolve the edge case when all players are disconnected temporarily
+		shouldForceResync := false
+		for _, player := range pR.PlayersArr {
+			playerBattleState := atomic.LoadInt32(&(player.BattleState))
+			if PlayerBattleStateIns.READDED_BATTLE_COLLIDER_ACKED == playerBattleState {
+				shouldForceResync = true
+				break
+			}
+		}
+		if shouldForceResync {
+			Logger.Warn(fmt.Sprintf("[type#2 forceConfirmation] For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, LatestPlayerUpsyncedInputFrameId:%d, LastAllConfirmedInputFrameId:%d; there's at least one reconnected player, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LatestPlayerUpsyncedInputFrameId, pR.LastAllConfirmedInputFrameId))
+			unconfirmedMask = allConfirmedMask
+		}
+	}
+
+	return unconfirmedMask
+}
+
+func (pR *Room) produceInputsBufferSnapshotWithCurDynamicsRenderFrameAsRef(unconfirmedMask uint64, snapshotStFrameId, snapshotEdFrameId int32) *InputsBufferSnapshot {
+	// [WARNING] This function MUST BE called while "pR.InputsBufferLock" is locked!
+	refRenderFrameIdIfNeeded := pR.CurDynamicsRenderFrameId - 1
+	if 0 > refRenderFrameIdIfNeeded {
 		return nil
 	}
+	// Duplicate downsynced inputFrameIds will be filtered out by frontend.
+	toSendInputFrameDownsyncs := pR.cloneInputsBuffer(snapshotStFrameId, snapshotEdFrameId)
+
+	return &InputsBufferSnapshot{
+		RefRenderFrameId:          refRenderFrameIdIfNeeded,
+		UnconfirmedMask:           unconfirmedMask,
+		ToSendInputFrameDownsyncs: toSendInputFrameDownsyncs,
+	}
 }
 
 func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRenderFrameId int32, spaceOffsetX, spaceOffsetY float64) {
@@ -1351,9 +1353,9 @@ func (pR *Room) applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputF
 				}
 				if !characStateAlreadyInAir && characStateIsInterruptWaivable {
 					thatPlayerInNextFrame.VelY = pR.JumpingInitVelY
-					// if 1 == currPlayerDownsync.JoinIndex {
+					if 1 == currPlayerDownsync.JoinIndex {
-					// 	Logger.Info(fmt.Sprintf("playerId=%v, joinIndex=%v jumped at {renderFrame.id: %d, virtualX: %d, virtualY: %d, nextVelX: %d, nextVelY: %d, nextCharacterState=%d, inAir=%v}, delayedInputFrame.id=%d", playerId, joinIndex, currRenderFrame.Id, currPlayerDownsync.VirtualGridX, currPlayerDownsync.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, thatPlayerInNextFrame.CharacterState, currPlayerDownsync.InAir, delayedInputFrame.InputFrameId))
+						Logger.Info(fmt.Sprintf("playerId=%v, joinIndex=%v jumped at {renderFrame.id: %d, virtualX: %d, virtualY: %d, nextVelX: %d, nextVelY: %d, nextCharacterState=%d, inAir=%v}, delayedInputFrame.id=%d", playerId, joinIndex, currRenderFrame.Id, currPlayerDownsync.VirtualGridX, currPlayerDownsync.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, thatPlayerInNextFrame.CharacterState, currPlayerDownsync.InAir, delayedInputFrame.InputFrameId))
-					// }
+					}
 				}
 			}
 
@@ -1557,7 +1559,7 @@ func (pR *Room) applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputF
 							for _, hardPushbackNorm := range hardPushbackNorms[joinIndex-1] {
 								projectedMagnitude := pushbackX*hardPushbackNorm.X + pushbackY*hardPushbackNorm.Y
 								if 0 > projectedMagnitude {
-									Logger.Info(fmt.Sprintf("defenderPlayerId=%d, joinIndex=%d reducing bullet pushback={%.3f, %.3f} by {%.3f, %.3f} where hardPushbackNorm={%.3f, %.3f}, projectedMagnitude=%.3f at renderFrame.id=%d", t.Id, joinIndex, pushbackX, pushbackY, projectedMagnitude*hardPushbackNorm.X, projectedMagnitude*hardPushbackNorm.Y, hardPushbackNorm.X, hardPushbackNorm.Y, projectedMagnitude, currRenderFrame.Id))
+									//Logger.Debug(fmt.Sprintf("defenderPlayerId=%d, joinIndex=%d reducing bullet pushback={%.3f, %.3f} by {%.3f, %.3f} where hardPushbackNorm={%.3f, %.3f}, projectedMagnitude=%.3f at renderFrame.id=%d", t.Id, joinIndex, pushbackX, pushbackY, projectedMagnitude*hardPushbackNorm.X, projectedMagnitude*hardPushbackNorm.Y, hardPushbackNorm.X, hardPushbackNorm.Y, projectedMagnitude, currRenderFrame.Id))
 									pushbackX -= projectedMagnitude * hardPushbackNorm.X
 									pushbackY -= projectedMagnitude * hardPushbackNorm.Y
 								}
@@ -1614,9 +1616,9 @@ func (pR *Room) applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputF
 
 		if 1 == thatPlayerInNextFrame.JoinIndex {
 			if currPlayerDownsync.InAir && !thatPlayerInNextFrame.InAir {
-				//Logger.Warn(fmt.Sprintf("playerId=%d, joinIndex=%d fallStopping#2:\n{nextRenderFrame.id: %d, nextVirtualX: %d, nextVirtualY: %d, nextVelX: %d, nextVelY: %d}\n\tcalculated from <- playerColliderPos=%v, effPushback={%.3f, %.3f}", playerId, joinIndex, currRenderFrame.Id+1, thatPlayerInNextFrame.VirtualGridX, thatPlayerInNextFrame.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, RectCenterStr(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY), effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y))
+				Logger.Warn(fmt.Sprintf("playerId=%d, joinIndex=%d fallStopping#2:\n{nextRenderFrame.id: %d, nextVirtualX: %d, nextVirtualY: %d, nextVelX: %d, nextVelY: %d}\n\tcalculated from <- playerColliderPos=%v, effPushback={%.3f, %.3f}", playerId, joinIndex, currRenderFrame.Id+1, thatPlayerInNextFrame.VirtualGridX, thatPlayerInNextFrame.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, RectCenterStr(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY), effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y))
 			} else if !currPlayerDownsync.InAir && thatPlayerInNextFrame.InAir {
-				//Logger.Warn(fmt.Sprintf("playerId=%d, joinIndex=%d took off:\n{nextRenderFrame.id: %d, nextVirtualX: %d, nextVirtualY: %d, nextVelX: %d, nextVelY: %d}\n\tcalculated from <- playerColliderPos=%v, effPushback={%.3f, %.3f}", playerId, joinIndex, currRenderFrame.Id+1, thatPlayerInNextFrame.VirtualGridX, thatPlayerInNextFrame.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, RectCenterStr(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY), effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y))
+				Logger.Warn(fmt.Sprintf("playerId=%d, joinIndex=%d took off:\n{nextRenderFrame.id: %d, nextVirtualX: %d, nextVirtualY: %d, nextVelX: %d, nextVelY: %d}\n\tcalculated from <- playerColliderPos=%v, effPushback={%.3f, %.3f}", playerId, joinIndex, currRenderFrame.Id+1, thatPlayerInNextFrame.VirtualGridX, thatPlayerInNextFrame.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, RectCenterStr(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY), effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y))
 			} else if thatPlayerInNextFrame.InAir && (0 != thatPlayerInNextFrame.VelY) {
 				//Logger.Info(fmt.Sprintf("playerId=%d, joinIndex=%d inAir trajectory:\n{nextRenderFrame.id: %d, nextVirtualX: %d, nextVirtualY: %d, nextVelX: %d, nextVelY: %d}\n\tcalculated from <- playerColliderPos=%v, effPushback={%.3f, %.3f}", playerId, joinIndex, currRenderFrame.Id+1, thatPlayerInNextFrame.VirtualGridX, thatPlayerInNextFrame.VirtualGridY, thatPlayerInNextFrame.VelX, thatPlayerInNextFrame.VelY, RectCenterStr(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY), effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y))
 			}
@@ -1652,7 +1654,7 @@ func (pR *Room) refreshColliders(spaceW, spaceH int32) {
 
 	topPadding, bottomPadding, leftPadding, rightPadding := pR.SnapIntoPlatformOverlap, pR.SnapIntoPlatformOverlap, pR.SnapIntoPlatformOverlap, pR.SnapIntoPlatformOverlap
 
-	minStep := (int(float64(pR.PlayerDefaultSpeed)*pR.VirtualGridToWorldRatio) << 2) // the approx minimum distance a player can move per frame in world coordinate
+	minStep := (int(float64(pR.PlayerDefaultSpeed)*pR.VirtualGridToWorldRatio) << 3) // the approx minimum distance a player can move per frame in world coordinate
 	pR.Space = resolv.NewSpace(int(spaceW), int(spaceH), minStep, minStep)           // allocate a new collision space everytime after a battle is settled
 	for _, player := range pR.Players {
 		wx, wy := VirtualGridToWorldPos(player.VirtualGridX, player.VirtualGridY, pR.VirtualGridToWorldRatio)
@@ -1691,13 +1693,12 @@ func (pR *Room) doBattleMainLoopPerTickBackendDynamicsWithProperLocking(prevRend
 
 	if ok, thatRenderFrameId := pR.shouldPrefabInputFrameDownsync(prevRenderFrameId, pR.RenderFrameId); ok {
 		noDelayInputFrameId := pR.ConvertToInputFrameId(thatRenderFrameId, 0)
-		if existingInputFrame := pR.InputsBuffer.GetByFrameId(noDelayInputFrameId); nil == existingInputFrame {
+		pR.getOrPrefabInputFrameDownsync(noDelayInputFrameId)
-			pR.prefabInputFrameDownsync(noDelayInputFrameId)
-		}
 	}
 
 	// Force setting all-confirmed of buffered inputFrames periodically, kindly note that if "pR.BackendDynamicsEnabled", what we want to achieve is "recovery upon reconnection", which certainly requires "forceConfirmationIfApplicable" to move "pR.LastAllConfirmedInputFrameId" forward as much as possible
-	inputsBufferSnapshot := pR.forceConfirmationIfApplicable(prevRenderFrameId)
+	oldLastAllConfirmedInputFrameId := pR.LastAllConfirmedInputFrameId
+	unconfirmedMask := pR.forceConfirmationIfApplicable(prevRenderFrameId)
 
 	if 0 <= pR.LastAllConfirmedInputFrameId {
 		dynamicsStartedAt := utils.UnixtimeNano()
@@ -1708,8 +1709,25 @@ func (pR *Room) doBattleMainLoopPerTickBackendDynamicsWithProperLocking(prevRend
 		*pDynamicsDuration = utils.UnixtimeNano() - dynamicsStartedAt
 	}
 
-	if nil != inputsBufferSnapshot {
+	/*
-		Logger.Warn(fmt.Sprintf("roomId=%v, room.RenderFrameId=%v, room.CurDynamicsRenderFrameId=%v, room.LastAllConfirmedInputFrameId=%v, unconfirmedMask=%v", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LastAllConfirmedInputFrameId, inputsBufferSnapshot.UnconfirmedMask))
+	   [WARNING]
+
+	   It's critical to create the snapshot AFTER "applyInputFrameDownsyncDynamics" for `ACTIVE SLOW TICKER` to avoid lag avalanche (see `<proj-root>/ConcerningEdgeCases.md` for introduction).
+
+	   Consider that in a 4-player battle, player#1 is once disconnected but soon reconnected in 2 seconds, during its absence, "markConfirmationIfApplicable" would skip it and increment "LastAllConfirmedInputFrameId" and when backend is sending "DOWNSYNC_MSG_ACT_FORCED_RESYNC" it'd be always based on "LatestPlayerUpsyncedInputFrameId == LastAllConfirmedInputFrameId" thus NOT triggering "[type#1 forceConfirmation]".
+
+	   However, if player#1 remains connected but ticks very slowly (i.e. an "ACTIVE SLOW TICKER"), "markConfirmationIfApplicable" couldn't increment "LastAllConfirmedInputFrameId", thus "[type#1 forceConfirmation]" will be triggered, but what's worse is that after "[type#1 forceConfirmation]" if the "refRenderFrameId" is not advanced enough, player#1 could never catch up even if it resumed from slow ticking!
+	*/
+
+	if 0 < unconfirmedMask {
+		// [WARNING] As "pR.CurDynamicsRenderFrameId" was just incremented above, "refSnapshotStFrameId" is most possibly larger than "oldLastAllConfirmedInputFrameId + 1", therefore this initial assignment is critical for `ACTIVE NORMAL TICKER`s to receive consecutive ids of inputFrameDownsync.
+		snapshotStFrameId := oldLastAllConfirmedInputFrameId + 1
+		refSnapshotStFrameId := pR.ConvertToInputFrameId(pR.CurDynamicsRenderFrameId-1, pR.InputDelayFrames)
+		if refSnapshotStFrameId < snapshotStFrameId {
+			snapshotStFrameId = refSnapshotStFrameId
+		}
+		inputsBufferSnapshot := pR.produceInputsBufferSnapshotWithCurDynamicsRenderFrameAsRef(unconfirmedMask, snapshotStFrameId, pR.LastAllConfirmedInputFrameId+1)
+		Logger.Debug(fmt.Sprintf("[forceConfirmation] roomId=%v, room.RenderFrameId=%v, room.CurDynamicsRenderFrameId=%v, room.LastAllConfirmedInputFrameId=%v, unconfirmedMask=%v", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LastAllConfirmedInputFrameId, unconfirmedMask))
 		pR.downsyncToAllPlayers(inputsBufferSnapshot)
 	}
 }
@@ -1741,14 +1759,21 @@ func (pR *Room) downsyncToAllPlayers(inputsBufferSnapshot *InputsBufferSnapshot)
 			   That said, we ensured that if "false == BackendDynamicsEnabled" and noone ever disconnects & reconnects, the frontend collision handling results are always consistent.
 			*/
 			playerBattleState := atomic.LoadInt32(&(player.BattleState))
-			thatPlayerJoinMask := uint64(1 << uint32(player.JoinIndex-1))
 			if PlayerBattleStateIns.READDED_BATTLE_COLLIDER_ACKED == playerBattleState {
 				inputsBufferSnapshot.ShouldForceResync = true
 				break
-			} else if PlayerBattleStateIns.ACTIVE == playerBattleState && 0 < (inputsBufferSnapshot.UnconfirmedMask&thatPlayerJoinMask) {
+			}
-				/*
+			/*
-				   [WARNING] Whenever there's an ACTIVE SLOW TICKER, all players should also be resynced to avoid inconsistent display. See `<proj-root>/ConcerningEdgeCases.md` for more information.
+			   [WARNING] There's a tradeoff for setting/unsetting "ForceAllResyncOnAnyActiveSlowTicker" here, if the `ACTIVE SLOW TICKER` doesn't resume for a long period of time, the current approach is to kick it out by "connWatchdog" instead of forcing resync of all players in the same battle all the way along.
-				*/
+
+			   [FIXME]
+			   In practice, I tested in internet environment by toggling player#1 "CPU throttling: 1x -> 4x -> 1x -> 6x -> 1x" and checked the logs of all players which showed that "all received inputFrameIds are consecutive for all players", yet not forcing resync of all players here still result in occasional inconsistent graphics for the `ACTIVE NORMAL TICKER`s.
+
+			   More investigation into this issue is needed, it's possible that the inconsistent graphics is just a result of difference of backend/frontend collision calculations, yet before it's totally resolved we'd keep forcing resync here.
+			*/
+			thatPlayerJoinMask := uint64(1 << uint32(player.JoinIndex-1))
+			isActiveSlowTicker := (0 < (thatPlayerJoinMask & inputsBufferSnapshot.UnconfirmedMask)) && (PlayerBattleStateIns.ACTIVE == playerBattleState)
+			if pR.ForceAllResyncOnAnyActiveSlowTicker && isActiveSlowTicker {
 				inputsBufferSnapshot.ShouldForceResync = true
 				break
 			}
@@ -1790,9 +1815,9 @@ func (pR *Room) downsyncToSinglePlayer(playerId int32, player *Player, refRender
 		return
 	}
 
+	isSlowTicker := (0 < (unconfirmedMask & uint64(1<<uint32(playerJoinIndex))))
 	shouldResync1 := (PlayerBattleStateIns.READDED_BATTLE_COLLIDER_ACKED == playerBattleState) // i.e. implies that "MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED == player.LastSentInputFrameId"
-	shouldResync2 := (0 < (unconfirmedMask & uint64(1<<uint32(playerJoinIndex))))              // This condition is critical, if we don't send resync upon this condition, the "reconnected or slowly-clocking player" might never get its input synced
+	shouldResync2 := isSlowTicker                                                              // This condition is critical, if we don't send resync upon this condition, the "reconnected or slowly-clocking player" might never get its input synced
-	// shouldResync2 := (0 < unconfirmedMask) // An easier version of the above, might keep sending "refRenderFrame"s to still connected players when any player is disconnected
 	shouldResync3 := shouldForceResync
 	shouldResyncOverall := (shouldResync1 || shouldResync2 || shouldResync3)
 

battle_srv/models/watchdog.go

@@ -0,0 +1,27 @@
+package models
+
+import (
+	"time"
+)
+
+type Watchdog struct {
+	interval time.Duration
+	timer    *time.Timer
+}
+
+func NewWatchdog(interval time.Duration, callback func()) *Watchdog {
+	w := Watchdog{
+		interval: interval,
+		timer:    time.AfterFunc(interval, callback),
+	}
+	return &w
+}
+
+func (w *Watchdog) Stop() {
+	w.timer.Stop()
+}
+
+func (w *Watchdog) Kick() {
+	w.timer.Stop()
+	w.timer.Reset(w.interval)
+}

battle_srv/start_daemon.sh

@@ -7,6 +7,7 @@ fi
 
 basedir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 
+PROJECTNAME=server.exe
 OS_USER=$USER
 ServerEnv=$1
 LOG_PATH="/var/log/treasure-hunter.log"
@@ -17,5 +18,5 @@ PID_FILE="$basedir/treasure-hunter.pid"
 sudo su - root -c "touch $LOG_PATH" 
 sudo su - root -c "chown $OS_USER:$OS_USER $LOG_PATH" 
 
-ServerEnv=$ServerEnv $basedir/server >$LOG_PATH 2>&1 &
+ServerEnv=$ServerEnv $basedir/$PROJECTNAME >$LOG_PATH 2>&1 &
 echo $! > $PID_FILE

battle_srv/ws/serve.go

@@ -373,7 +373,7 @@ func Serve(c *gin.Context) {
 			// TODO: Is there any potential edge-trigger improvement like the epoll approach mentioned above for the following statement? See discussion in https://github.com/gorilla/websocket/issues/122
 			_, bytes, err := conn.ReadMessage()
 			if nil != err {
-				Logger.Error("About to `signalToCloseConnOfThisPlayer`", zap.Any("roomId", pRoom.Id), zap.Any("playerId", playerId), zap.Error(err))
+				Logger.Error("About to `signalToCloseConnOfThisPlayer` due to conn.ReadMessage err", zap.Any("roomId", pRoom.Id), zap.Any("playerId", playerId), zap.Error(err))
 				signalToCloseConnOfThisPlayer(Constants.RetCode.UnknownError, "")
 				return nil
 			}

collider_visualizer/Makefile

@@ -2,7 +2,8 @@ PROJECTNAME=viscol.exe
 ROOT_DIR=.
 all: help
 ## Available proxies for downloading go modules are listed in "https://github.com/golang/go/wiki/Modules#how-do-i-use-vendoring-with-modules-is-vendoring-going-away". 
-GOPROXY=https://mirrors.aliyun.com/goproxy 
+#GOPROXY=https://mirrors.aliyun.com/goproxy 
+GOPROXY=https://goproxy.io
 
 build:
 	GOPROXY=$(GOPROXY) go build -o $(ROOT_DIR)/$(PROJECTNAME)

dnmshared/tmx_parser.go

@@ -377,10 +377,6 @@ func ParseTmxLayersAndGroups(pTmxMapIns *TmxMap, gidBoundariesMap map[int]StrToP
 			}
 
 			for _, singleObjInTmxFile := range objGroup.Objects {
-				if nil == singleObjInTmxFile.Properties.Property || "boundary_type" != singleObjInTmxFile.Properties.Property[0].Name || "barrier" != singleObjInTmxFile.Properties.Property[0].Value {
-					continue
-				}
-
 				if nil == singleObjInTmxFile.Polyline {
 					pts := make([]*Vec2D, 4)
 					s := make([]string, 0)

frontend/assets/plugin_scripts/constants.js

@@ -23,8 +23,8 @@ var constants = {
     FILE_NAME: {
       TREASURE_PICKEDUP: "TreasurePicked",
       CRASHED_BY_TRAP_BULLET: "CrashedByTrapBullet",
-      HIGH_SCORE_TREASURE_PICKED:"HighScoreTreasurePicked",
+      HIGH_SCORE_TREASURE_PICKED: "HighScoreTreasurePicked",
-      COUNT_DOWN_10SEC_TO_END:"countDown10SecToEnd",
+      COUNT_DOWN_10SEC_TO_END: "countDown10SecToEnd",
       BGM: "BGM"
     }
   },
@@ -55,39 +55,41 @@ var constants = {
   },
   RET_CODE: {
     /**
-    * NOTE: The "RET_CODE"s from 1000-1015 are reserved for the websocket "WebsocketStdCloseCode"s.
+    * NOTE: The "RET_CODE"s from 1000-1015 are reserved for the websocket "WebsocketStdCloseCode"s, custom codes should be between 3000-4999
     *
     * References
     * - https://tools.ietf.org/html/rfc6455#section-7.4
     * - https://godoc.org/github.com/gorilla/websocket#pkg-constants.
     */
-    "__comment__": "基础",
+    "__comment__": "Websocket",
-    "OK": 9000,
+    "OK": 3000,
-    "UNKNOWN_ERROR": 9001,
+    "UNKNOWN_ERROR": 3001,
-    "INVALID_REQUEST_PARAM": 9002,
+    "INVALID_REQUEST_PARAM": 3002,
-    "IS_TEST_ACC": 9003,
+    "IS_TEST_ACC": 3003,
-    "MYSQL_ERROR": 9004,
+    "MYSQL_ERROR": 3004,
-    "NONEXISTENT_ACT": 9005,
+    "NONEXISTENT_ACT": 3005,
-    "LACK_OF_DIAMOND": 9006,
+    "LACK_OF_DIAMOND": 3006,
-    "LACK_OF_GOLD": 9007,
+    "LACK_OF_GOLD": 3007,
-    "LACK_OF_ENERGY": 9008,
+    "LACK_OF_ENERGY": 3008,
-    "NONEXISTENT_ACT_HANDLER": 9009,
+    "NONEXISTENT_ACT_HANDLER": 3009,
-    "LOCALLY_NO_AVAILABLE_ROOM": 9010,
+    "LOCALLY_NO_AVAILABLE_ROOM": 3010,
-    "LOCALLY_NO_SPECIFIED_ROOM": 9011,
+    "LOCALLY_NO_SPECIFIED_ROOM": 3011,
-    "PLAYER_NOT_ADDABLE_TO_ROOM": 9012,
+    "PLAYER_NOT_ADDABLE_TO_ROOM": 3012,
-    "PLAYER_NOT_READDABLE_TO_ROOM": 9013,
+    "PLAYER_NOT_READDABLE_TO_ROOM": 3013,
-    "PLAYER_NOT_FOUND": 9014,
+    "PLAYER_NOT_FOUND": 3014,
-    "PLAYER_CHEATING": 9015,
+    "PLAYER_CHEATING": 3015,
+    "WECHAT_SERVER_ERROR": 3016,
+    "IS_BOT_ACC": 3017,
+    "ACTIVE_WATCHDOG": 3018,
+    "BATTLE_STOPPED": 3019,
+    "CLIENT_MISMATCHED_RENDER_FRAME": 3020,
 
-
+    "__comment__": "OTHERS",
-    "__comment__": "SMS",
-    "SMS_CAPTCHA_REQUESTED_TOO_FREQUENTLY": 5001,
-    "SMS_CAPTCHA_NOT_MATCH": 5002,
     "INVALID_TOKEN": 2001,
 
     "DUPLICATED": 2002,
     "INCORRECT_HANDLE": 2004,
-    "NONEXISTENT_HANDLE": 2005,
+
     "INCORRECT_PASSWORD": 2006,
     "INCORRECT_CAPTCHA": 2007,
     "INVALID_EMAIL_LITERAL": 2008,
@@ -99,9 +101,14 @@ var constants = {
     "FAILED_TO_DELETE": 2015,
     "FAILED_TO_CREATE": 2016,
     "INCORRECT_PHONE_NUMBER": 2018,
-    "PASSWORD_RESET_CODE_GENERATION_PER_EMAIL_TOO_FREQUENTLY": 4000,
+    "INSUFFICIENT_MEM_TO_ALLOCATE_CONNECTION": 2019,
-    "TRADE_CREATION_TOO_FREQUENTLY": 4002,
+    "PASSWORD_RESET_CODE_GENERATION_PER_EMAIL_TOO_FREQUENTLY": 2020,
-    "MAP_NOT_UNLOCKED": 4003,
+    "TRADE_CREATION_TOO_FREQUENTLY": 2021,
+    "MAP_NOT_UNLOCKED": 2022,
+
+    "GET_SMS_CAPTCHA_RESP_ERROR_CODE": 2023,
+    "SMS_CAPTCHA_REQUESTED_TOO_FREQUENTLY": 2024,
+    "SMS_CAPTCHA_NOT_MATCH": 2025,
 
     "NOT_IMPLEMENTED_YET": 65535
   },

frontend/assets/resources/map/dungeon/map.tmx

@@ -1,18 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<map version="1.2" tiledversion="1.2.3" orientation="orthogonal" renderorder="right-down" width="128" height="128" tilewidth="16" tileheight="16" infinite="0" nextlayerid="3" nextobjectid="87">
+<map version="1.2" tiledversion="1.2.3" orientation="orthogonal" renderorder="right-down" width="128" height="128" tilewidth="16" tileheight="16" infinite="0" nextlayerid="4" nextobjectid="104">
  <tileset firstgid="1" source="tiles0.tsx"/>
  <tileset firstgid="65" source="tiles1.tsx"/>
  <tileset firstgid="129" source="tiles2.tsx"/>
  <layer id="2" name="Ground" width="128" height="128">
   <data encoding="base64" compression="zlib">
-   eJzt3DFq3EAUgOFlTRoXJiEkkNQpAr5EyuDKVdKl8k1yh9wg94wMK1DEaqXVjvRGel/xgXFh7PnfSBqx+O5wONwBAAAAAAAAAAAAAAAAAMAM9yfRvwfreelo+78kFN0hsv/xpO3/q/E04LhD+v/ff4j++9Pt/zTS/76CVvov1/8c/fft9W//cHJubfrXhOhW+q/bPwP99Y/uENn//QzRzfSP7b+nGdBf/+gOW+xfE/1z9rf/c/cvMQP6b5f9r7/+efuXmAH9y69t+07x942W3vv666//Nvp/OtE/T/9u7+7X+uuvf1z/tyNK9u/SP7b/WPdz/f80flyp7e/5r57+U9s/Hzz/b8XU/lPbH/XflLH+5xo/Nh4G2vf79z1fSf+4/ufaP3T0uy/R/2Pji/7V9L903e/2L03/evvPeUa8lv7r958yA/21LNl3TMn+xwpa1Ni/1BpfMqe9/vvpf82MLPGz9d/GDCxF/9wzoL/+mftHr3+07Oe/6PWPpn9u+uemf27656Z/bvrnpn9u+uemf27656Z/bvrnpn9u+uemf276z7eHzwnpX0//dyPeDNB/H/3t/7r77/Fzovrnpv+6hu7tkf2PFbSouf/Pk/71vv1+9B7Wf9n+l+75+m/XlP5DZ65XY+e1yOv6Nf2jO9Tav+389Qa3ns/1j93/tyrxjkb/5fqXfp821L/WGcjef63936rtPZH+6/ZvZyDq/73oP96/5PP8pfPDEP3r2f+3zsGc/mveJ/SfZu4cfJ7Z/2/ju/7V9J+r6f9tbv/WknOQvT/xHQAAAAAAAAAAAAAAAID1/QPUuKyX
+   eJzt3MFq1EAcwOFli5ceikUU9NyD4Et47qle9OapLyB60ZMgvoIH776nWUggxkySnZ1kksx3+KC0S2jn9082E5ZeHQ6HKwAAAAAAAAAAAAAAAAAAiHBdy/17sJzHlqb/Y4Fyd8jZ/1hr+n+s3Accd0j/f/uH6L8/7f73I/2vV9BK//n699F/305/+/Na39p0rwm5W+m/bP8S6K9/7g45+z+LkLuZ/nn772kG9Nc/d4ct9l8T/cvs7/wvu3+KGdB/u5z/+utfbv8UM6B/+rVtnin+uNDc577++uu/jf4va/qX07/du/21/vrrn6//0xEp+7fpn7f/WPe+/r8q78/U9Hf/t57+U9s/HNz/b8XU/lPbH/XflLH+fY3fVG4C7bv9ux7OpH++/n3tb1q63efo/6Jyp/9q+g9d99v9U9N/vf1j7hHPpf/y/afMQHctU/Ydk7L/cQUt1tg/1RoPiWmv/376nzMjcxxb/23MwFz0L3sG9Ne/5P651z+30vd/udc/N/3Lpn/Z9C+b/mXTv2z6l03/sulfNv3Lpn/Z9C+b/mXTv2z6l03/9boL0H8d/ef6nFCo+xxzoP96+t+OeBKg/z7656B/fG/9t23t93/6769/6L29+fm7hNrHDF2ffP573Ida93rffD/3OXzp+a//sKH3/C3177tG6D8stOc6Gduv3U44fs72Tf/cHdbav+n8+gKX7s/nbK///Guf4hnNXO31T/88LdQ/xwxM2SOU3n+p87+x1HOiqXtE/Zft38zAnP/v5ZxnBPr/L+X9/ND+IeR7hJj2+o/3u3QOYvrHzMDPSPpPEzsHrw5x/f9UvgRaN75VPtWv1X/e/rGq/m9j+598PoT7f2297tTyd03/6f3J3wEAAAAAAAAAAAAAAABY3l9OOPTh
   </data>
  </layer>
  <objectgroup id="1" name="PlayerStartingPos">
-  <object id="135" x="882" y="1437.33">
+  <object id="135" x="999" y="1608">
    <point/>
   </object>
-  <object id="137" x="955.333" y="1434.67">
+  <object id="137" x="875" y="1450">
    <point/>
   </object>
  </objectgroup>
@@ -25,7 +25,7 @@
     <property name="boundary_type" value="barrier"/>
    </properties>
   </object>
-  <object id="55" x="735" y="1552" width="113.5" height="15.5">
+  <object id="55" x="736" y="1552" width="112" height="16">
    <properties>
     <property name="boundary_type" value="barrier"/>
    </properties>
@@ -80,12 +80,12 @@
     <property name="boundary_type" value="barrier"/>
    </properties>
   </object>
-  <object id="73" x="783.75" y="1567.5" width="96.25" height="15.5">
+  <object id="73" x="784" y="1568" width="96" height="16">
    <properties>
     <property name="boundary_type" value="barrier"/>
    </properties>
   </object>
-  <object id="74" x="815.75" y="1583.75" width="96.25" height="15.5">
+  <object id="74" x="816" y="1584" width="96" height="16">
    <properties>
     <property name="boundary_type" value="barrier"/>
    </properties>
@@ -95,18 +95,6 @@
     <property name="boundary_type" value="barrier"/>
    </properties>
   </object>
-  <object id="80" x="1296" y="1600">
-   <properties>
-    <property name="boundary_type" value="barrier"/>
-   </properties>
-   <polyline points="0,0 -32.5,0 -32.25,-16.5 -16.5,-16.5"/>
-  </object>
-  <object id="82" x="1328" y="1616">
-   <properties>
-    <property name="boundary_type" value="barrier"/>
-   </properties>
-   <polyline points="0,0 -64.5,0 -64.0038,-15.75 -16.4734,-15.75"/>
-  </object>
   <object id="83" x="640" y="480" width="1056" height="16">
    <properties>
     <property name="boundary_type" value="barrier"/>
@@ -127,5 +115,90 @@
     <property name="boundary_type" value="barrier"/>
    </properties>
   </object>
+  <object id="87" x="1456" y="1568" width="224" height="48">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="88" x="1264" y="1584" width="16" height="32">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="89" x="1280" y="1600" width="16" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="90" x="1232" y="1408" width="304" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="91" x="1440" y="1584" width="16" height="32">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="92" x="1424" y="1600" width="16" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="93" x="1488" y="1552" width="192" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="94" x="1504" y="1536" width="176" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="95" x="1520" y="1520" width="160" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="96" x="1568" y="1408" width="16" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="97" x="1248" y="1328" width="158" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="98" x="1280" y="1312" width="96" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="99" x="1536" y="1504" width="144" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="100" x="1552" y="1488" width="128" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="101" x="1568" y="1472" width="112" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="102" x="1584" y="1456" width="96" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
+  <object id="103" x="1600" y="1440" width="80" height="16">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+  </object>
  </objectgroup>
 </map>

frontend/assets/scenes/login.fire

@@ -440,7 +440,7 @@
       "array": [
         0,
         0,
-        216.19964242526865,
+        210.4441731196186,
         0,
         0,
         0,

frontend/assets/scenes/offline_map_1.fire

@@ -460,7 +460,7 @@
       "array": [
         0,
         0,
-        215.81269742929726,
+        216.50635094610968,
         0,
         0,
         0,

frontend/assets/scripts/Map.js

@@ -11,6 +11,7 @@ window.ALL_MAP_STATES = {
 };
 
 window.ALL_BATTLE_STATES = {
+  NONE: -1,
   WAITING: 0,
   IN_BATTLE: 1,
   IN_SETTLEMENT: 2,
@@ -98,6 +99,9 @@ cc.Class({
     bulletTriggerEnabled: {
       default: false
     },
+    closeOnForcedtoResyncNotSelf: {
+      default: true
+    },
   },
 
   _inputFrameIdDebuggable(inputFrameId) {
@@ -121,7 +125,8 @@ cc.Class({
     return (confirmedList + 1) == (1 << this.playerRichInfoDict.size);
   },
 
-  _generateInputFrameUpsync(inputFrameId) {
+  getOrPrefabInputFrameUpsync(inputFrameId) {
+    // TODO: find some kind of synchronization mechanism against "onInputFrameDownsyncBatch"!
     const self = this;
     if (
       null == self.ctrl ||
@@ -133,28 +138,27 @@ cc.Class({
     let previousSelfInput = null,
       currSelfInput = null;
     const joinIndex = self.selfPlayerInfo.joinIndex;
-    // [WARNING] The while-loop here handles a situation where the "resync rdf & accompaniedInputFrameDownsyncBatch" mismatched and we have to predict some "gap-inputFrames"! 
+    const existingInputFrame = self.recentInputCache.getByFrameId(inputFrameId);
-    while (self.recentInputCache.edFrameId <= inputFrameId) {
+    const previousInputFrameDownsyncWithPrediction = self.getCachedInputFrameDownsyncWithPrediction(inputFrameId - 1);
-      // TODO: find some kind of synchronization mechanism against "onInputFrameDownsyncBatch"!
+    previousSelfInput = (null == previousInputFrameDownsyncWithPrediction ? null : previousInputFrameDownsyncWithPrediction.inputList[joinIndex - 1]);
-      const previousInputFrameDownsyncWithPrediction = self.getCachedInputFrameDownsyncWithPrediction(inputFrameId - 1);
+    if (null != existingInputFrame) {
-      previousSelfInput = (null == previousInputFrameDownsyncWithPrediction ? null : previousInputFrameDownsyncWithPrediction.inputList[joinIndex - 1]);
+      // 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]];
+    }
 
-      // If "forceConfirmation" is active on backend, there's a chance that the already downsynced "inputFrameDownsync"s are ahead of a locally generating inputFrameId, in this case we respect the downsynced one.  
+    const prefabbedInputList = (null == previousInputFrameDownsyncWithPrediction ? new Array(self.playerRichInfoDict.size).fill(0) : previousInputFrameDownsyncWithPrediction.inputList.slice());
-      const existingInputFrame = self.recentInputCache.getByFrameId(inputFrameId);
+    currSelfInput = self.ctrl.getEncodedInput(); // When "null == existingInputFrame", it'd be safe to say that the realtime "self.ctrl.getEncodedInput()" is for the requested "inputFrameId"
-      if (null != existingInputFrame && self._allConfirmed(existingInputFrame.confirmedList)) {
+    prefabbedInputList[(joinIndex - 1)] = currSelfInput;
-        console.log(`noDelayInputFrameId=${inputFrameId} already exists in recentInputCache and is all-confirmed: recentInputCache=${self._stringifyRecentInputCache(false)}`);
+    while (self.recentInputCache.edFrameId <= inputFrameId) {
-        return [previousSelfInput, existingInputFrame.inputList[joinIndex - 1]];
+      // Fill the gap
-      }
-      const prefabbedInputList = (null == previousInputFrameDownsyncWithPrediction ? new Array(self.playerRichInfoDict.size).fill(0) : previousInputFrameDownsyncWithPrediction.inputList.slice());
-      currSelfInput = self.ctrl.getEncodedInput();
-      prefabbedInputList[(joinIndex - 1)] = currSelfInput;
       const prefabbedInputFrameDownsync = window.pb.protos.InputFrameDownsync.create({
         inputFrameId: self.recentInputCache.edFrameId,
         inputList: prefabbedInputList,
         confirmedList: (1 << (self.selfPlayerInfo.joinIndex - 1))
       });
 
-      self.recentInputCache.put(prefabbedInputFrameDownsync); // A prefabbed inputFrame, would certainly be adding a new inputFrame to the cache, because server only downsyncs "all-confirmed inputFrames" 
+      self.recentInputCache.put(prefabbedInputFrameDownsync);
     }
 
     return [previousSelfInput, currSelfInput];
@@ -200,7 +204,6 @@ cc.Class({
       playerId: self.selfPlayerInfo.id,
       act: window.UPSYNC_MSG_ACT_PLAYER_CMD,
       joinIndex: self.selfPlayerInfo.joinIndex,
-      ackingFrameId: self.lastAllConfirmedRenderFrameId,
       ackingInputFrameId: self.lastAllConfirmedInputFrameId,
       inputFrameUpsyncBatch: inputFrameUpsyncBatch,
     }).finish();
@@ -222,15 +225,19 @@ cc.Class({
   onDestroy() {
     const self = this;
     console.warn("+++++++ Map onDestroy()");
-    if (null == self.battleState || ALL_BATTLE_STATES.WAITING == self.battleState) {
+    if (null == self.battleState || ALL_BATTLE_STATES.IN_BATTLE != self.battleState) {
       window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
     }
     if (null != window.handleBattleColliderInfo) {
       window.handleBattleColliderInfo = null;
     }
-    if (null != window.handleClientSessionError) {
+  },
-      window.handleClientSessionError = null;
+
-    }
+  onManualRejoinRequired(labelString) {
+    const self = this;
+    self.battleState = ALL_BATTLE_STATES.NONE; // Effectively stops "update(dt)" 
+    self.showPopupInCanvas(self.gameRuleNode);
+    self.popupSimplePressToGo(labelString, false);
   },
 
   popupSimplePressToGo(labelString, hideYesButton) {
@@ -288,10 +295,9 @@ cc.Class({
 
     self.renderFrameId = 0; // After battle started
     self.bulletBattleLocalIdCounter = 0;
-    self.lastAllConfirmedRenderFrameId = -1;
     self.lastAllConfirmedInputFrameId = -1;
     self.lastUpsyncInputFrameId = -1;
-    self.chaserRenderFrameId = -1; // at any moment, "lastAllConfirmedRenderFrameId <= chaserRenderFrameId <= renderFrameId", but "chaserRenderFrameId" would fluctuate according to "onInputFrameDownsyncBatch"
+    self.chaserRenderFrameId = -1; // at any moment, "chaserRenderFrameId <= renderFrameId", but "chaserRenderFrameId" would fluctuate according to "onInputFrameDownsyncBatch"
 
     self.recentRenderCache = new RingBuffer(self.renderCacheSize);
 
@@ -310,6 +316,8 @@ cc.Class({
 
     self.battleState = ALL_BATTLE_STATES.WAITING;
 
+    self.othersForcedDownsyncRenderFrameDict = new Map();
+
     self.countdownNanos = null;
     if (self.countdownLabel) {
       self.countdownLabel.string = "";
@@ -334,20 +342,9 @@ cc.Class({
     self.showCriticalCoordinateLabels = false;
 
     console.warn("+++++++ Map onLoad()");
-    window.handleClientSessionError = function() {
-      console.warn('+++++++ Common handleClientSessionError()');
-
-      if (ALL_BATTLE_STATES.IN_SETTLEMENT == self.battleState) {
-        console.log("Battled ended by settlement");
-      } else {
-        console.warn("Connection lost, going back to login page");
-        window.clearLocalStorageAndBackToLoginScene(true);
-      }
-    };
 
     const mapNode = self.node;
     const canvasNode = mapNode.parent;
-    cc.director.getCollisionManager().enabled = false;
     // self.musicEffectManagerScriptIns = self.node.getComponent("MusicEffectManager");
     self.musicEffectManagerScriptIns = null;
 
@@ -580,6 +577,7 @@ cc.Class({
   onRoomDownsyncFrame(rdf, accompaniedInputFrameDownsyncBatch) {
     // This function is also applicable to "re-joining".
     const self = window.mapIns;
+    self.onInputFrameDownsyncBatch(accompaniedInputFrameDownsyncBatch); // Important to do this step before setting IN_BATTLE
     if (!self.recentRenderCache) {
       return;
     }
@@ -587,17 +585,27 @@ cc.Class({
       return;
     }
     const shouldForceDumping1 = (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START == rdf.id);
-    const shouldForceDumping2 = (rdf.id > self.renderFrameId + self.renderFrameIdLagTolerance);
+    let shouldForceDumping2 = (rdf.id >= self.renderFrameId + self.renderFrameIdLagTolerance);
-    const shouldForceResync = rdf.shouldForceResync;
+    let shouldForceResync = rdf.shouldForceResync;
+    const notSelfUnconfirmed = (0 == (rdf.backendUnconfirmedMask & (1 << (self.selfPlayerInfo.joinIndex - 1))));
+    if (notSelfUnconfirmed) {
+      shouldForceDumping2 = false;
+      shouldForceResync = false;
+      self.othersForcedDownsyncRenderFrameDict.set(rdf.id, rdf);
+    }
+    /*
+    TODO
+    
+    If "BackendUnconfirmedMask" is non-all-1 and contains the current player, show a label/button to hint manual reconnection. Note that the continuity of "recentInputCache" is not a good indicator, because due to network delay upon a [type#1 forceConfirmation] a player might just lag in upsync networking and have all consecutive inputFrameIds locally. 
+    */
 
     const [dumpRenderCacheRet, oldStRenderFrameId, oldEdRenderFrameId] = (shouldForceDumping1 || shouldForceDumping2 || shouldForceResync) ? self.recentRenderCache.setByFrameId(rdf, rdf.id) : [window.RING_BUFF_CONSECUTIVE_SET, null, null];
     if (window.RING_BUFF_FAILED_TO_SET == dumpRenderCacheRet) {
-      throw `Failed to dump render cache#1 (maybe recentRenderCache too small)! rdf.id=${rdf.id}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
+      throw `Failed to dump render cache#1 (maybe recentRenderCache too small)! rdf.id=${rdf.id}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
     }
     if (!shouldForceResync && (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" (except for when RING_BUFF_NON_CONSECUTIVE_SET) 
       - chaserRenderFrameId, it's updated only in "rollbackAndChase & onInputFrameDownsyncBatch" (except for when RING_BUFF_NON_CONSECUTIVE_SET)
       */
       return dumpRenderCacheRet;
@@ -615,21 +623,19 @@ cc.Class({
       }
     }
 
-    if (null == self.renderFrameId || self.renderFrameId <= rdf.id) {
+    if (shouldForceDumping1 || shouldForceDumping2 || shouldForceResync) {
       // In fact, not having "window.RING_BUFF_CONSECUTIVE_SET == dumpRenderCacheRet" should already imply that "self.renderFrameId <= rdf.id", but here we double check and log the anomaly  
 
       if (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START == rdf.id) {
         console.log('On battle started! renderFrameId=', rdf.id);
       } else {
         self.hideFindingPlayersGUI(rdf);
-        self.onInputFrameDownsyncBatch(accompaniedInputFrameDownsyncBatch); // Important to do this step before setting IN_BATTLE
+        console.warn(`Got resync@localRenderFrameId=${self.renderFrameId} -> rdf.id=${rdf.id} & rdf.backendUnconfirmedMask=${rdf.backendUnconfirmedMask}, @lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, @chaserRenderFrameId=${self.chaserRenderFrameId}, @localRecentInputCache=${mapIns._stringifyRecentInputCache(false)}`);
-        console.warn(`Got resync@localRenderFrameId=${self.renderFrameId} -> rdf.id=${rdf.id} & rdf.backendUnconfirmedMask=${rdf.backendUnconfirmedMask}, @lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, @lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, @chaserRenderFrameId=${self.chaserRenderFrameId}, @localRecentInputCache=${mapIns._stringifyRecentInputCache(false)}`);
       }
 
       self.renderFrameId = rdf.id;
       self.lastRenderFrameIdTriggeredAt = performance.now();
-      // In this case it must be true that "rdf.id > chaserRenderFrameId >= lastAllConfirmedRenderFrameId".
+      // In this case it must be true that "rdf.id > chaserRenderFrameId".
-      self.lastAllConfirmedRenderFrameId = rdf.id;
       self.chaserRenderFrameId = rdf.id;
       const candidateLastAllConfirmedInputFrame = self._convertToInputFrameId(rdf.id - 1, self.inputDelayFrames);
       if (self.lastAllConfirmedInputFrame < candidateLastAllConfirmedInputFrame) {
@@ -667,8 +673,45 @@ cc.Class({
     return true;
   },
 
+  equalPlayers(lhs, rhs) {
+    if (null == lhs || null == rhs) return false;
+    if (lhs.virtualGridX != rhs.virtualGridX) return false;
+    if (lhs.virtualGridY != rhs.virtualGridY) return false;
+    if (lhs.dirX != rhs.dirX) return false;
+    if (lhs.dirY != rhs.dirY) return false;
+    if (lhs.velX != rhs.velX) return false;
+    if (lhs.velY != rhs.velY) return false;
+    if (lhs.speed != rhs.speed) return false;
+    if (lhs.framesToRecover != rhs.framesToRecover) return false;
+    if (lhs.hp != rhs.hp) return false;
+    if (lhs.maxHp != rhs.maxHp) return false;
+    if (lhs.characterState != rhs.characterState) return false;
+    if (lhs.inAir != rhs.inAir) return false;
+    return true;
+  },
+
+  equalMeleeBullets(lhs, rhs) {
+    if (null == lhs || null == rhs) return false;
+    if (lhs.battleLocalId != rhs.battleLocalId) return false;
+    if (lhs.offenderPlayerId != rhs.offenderPlayerId) return false;
+    if (lhs.offenderJoinIndex != rhs.offenderJoinIndex) return false;
+    if (lhs.originatedRenderFrameId != rhs.originatedRenderFrameId) return false;
+    return true;
+  },
+
+  equalRoomDownsyncFrames(lhs, rhs) {
+    if (null == lhs || null == rhs) return false;
+    for (let k in lhs.players) {
+      if (!this.equalPlayers(lhs.players[k], rhs.players[k])) return false;
+    }
+    for (let k in lhs.meleeBullets) {
+      if (!this.equalMeleeBullets(lhs.meleeBullets[k], rhs.meleeBullets[k])) return false;
+    }
+    return true;
+  },
+
   onInputFrameDownsyncBatch(batch) {
-    // TODO: find some kind of synchronization mechanism against "_generateInputFrameUpsync"!
+    // TODO: find some kind of synchronization mechanism against "getOrPrefabInputFrameUpsync"!
     const self = this;
     if (!self.recentInputCache) {
       return;
@@ -681,9 +724,10 @@ cc.Class({
     for (let k in batch) {
       const inputFrameDownsync = batch[k];
       const inputFrameDownsyncId = inputFrameDownsync.inputFrameId;
-      if (inputFrameDownsyncId < self.lastAllConfirmedInputFrameId) {
+      if (inputFrameDownsyncId <= self.lastAllConfirmedInputFrameId) {
         continue;
       }
+      // [WARNING] Take all "inputFrameDownsync" from backend as all-confirmed, it'll be later checked by "rollbackAndChase". 
       self.lastAllConfirmedInputFrameId = inputFrameDownsyncId;
       const localInputFrame = self.recentInputCache.getByFrameId(inputFrameDownsyncId);
       if (null != localInputFrame
@@ -694,11 +738,10 @@ 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 [ret, oldStFrameId, oldEdFrameId] = self.recentInputCache.setByFrameId(inputFrameDownsync, inputFrameDownsync.inputFrameId);
       if (window.RING_BUFF_FAILED_TO_SET == ret) {
-        throw `Failed to dump input cache (maybe recentInputCache too small)! inputFrameDownsync.inputFrameId=${inputFrameDownsync.inputFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
+        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)}`;
       }
     }
 
@@ -712,8 +755,6 @@ cc.Class({
     /*
     A typical case is as follows.
     --------------------------------------------------------
-    [self.lastAllConfirmedRenderFrameId]       :              22
-
     <renderFrameId1>                           :              36
 
 
@@ -723,7 +764,8 @@ cc.Class({
     --------------------------------------------------------
     */
     // The actual rollback-and-chase would later be executed in update(dt). 
-    console.warn(`Mismatched input detected, resetting chaserRenderFrameId: ${self.chaserRenderFrameId}->${renderFrameId1} by firstPredictedYetIncorrectInputFrameId: ${inputFrameId1}`);
+    console.warn(`Mismatched input detected, resetting chaserRenderFrameId: ${self.chaserRenderFrameId}->${renderFrameId1} by firstPredictedYetIncorrectInputFrameId: ${inputFrameId1}
+lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}`);
     self.chaserRenderFrameId = renderFrameId1;
   },
 
@@ -740,7 +782,7 @@ cc.Class({
   logBattleStats() {
     const self = this;
     let s = [];
-    s.push(`Battle stats: renderFrameId=${self.renderFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastUpsyncInputFrameId=${self.lastUpsyncInputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, chaserRenderFrameId=${self.chaserRenderFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`);
+    s.push(`Battle stats: renderFrameId=${self.renderFrameId}, lastUpsyncInputFrameId=${self.lastUpsyncInputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, chaserRenderFrameId=${self.chaserRenderFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`);
 
     for (let i = self.recentInputCache.stFrameId; i < self.recentInputCache.edFrameId; ++i) {
       const inputFrameDownsync = self.recentInputCache.getByFrameId(i);
@@ -755,6 +797,8 @@ cc.Class({
     if (ALL_BATTLE_STATES.IN_BATTLE != self.battleState) {
       return;
     }
+    window.closeWSConnection(constants.RET_CODE.BATTLE_STOPPED);
+    self.battleState = ALL_BATTLE_STATES.IN_SETTLEMENT;
     self.countdownNanos = null;
     self.logBattleStats();
     if (self.musicEffectManagerScriptIns) {
@@ -765,7 +809,6 @@ cc.Class({
     const resultPanelScriptIns = resultPanelNode.getComponent("ResultPanel");
     resultPanelScriptIns.showPlayerInfo(self.playerRichInfoDict);
     window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
-    self.battleState = ALL_BATTLE_STATES.IN_SETTLEMENT;
     self.showPopupInCanvas(resultPanelNode);
 
     // Clear player info
@@ -828,7 +871,7 @@ cc.Class({
           currSelfInput = null;
         const noDelayInputFrameId = self._convertToInputFrameId(self.renderFrameId, 0); // It's important that "inputDelayFrames == 0" here 
         if (self.shouldGenerateInputFrameUpsync(self.renderFrameId)) {
-          [prevSelfInput, currSelfInput] = self._generateInputFrameUpsync(noDelayInputFrameId);
+          [prevSelfInput, currSelfInput] = self.getOrPrefabInputFrameUpsync(noDelayInputFrameId);
         }
 
         let t0 = performance.now();
@@ -844,11 +887,16 @@ cc.Class({
         if (nextChaserRenderFrameId > self.renderFrameId) {
           nextChaserRenderFrameId = self.renderFrameId;
         }
-        self.rollbackAndChase(prevChaserRenderFrameId, nextChaserRenderFrameId, self.collisionSys, self.collisionSysMap, true);
+        if (prevChaserRenderFrameId < nextChaserRenderFrameId) {
+          // Do not execute "rollbackAndChase" when "prevChaserRenderFrameId == nextChaserRenderFrameId", otherwise if "nextChaserRenderFrameId == self.renderFrameId" we'd be wasting computing power once. 
+          self.rollbackAndChase(prevChaserRenderFrameId, nextChaserRenderFrameId, self.collisionSys, self.collisionSysMap, true);
+        }
         let t2 = performance.now();
 
         // Inside the following "self.rollbackAndChase" actually ROLLS FORWARD w.r.t. the corresponding delayedInputFrame, REGARDLESS OF whether or not "self.chaserRenderFrameId == self.renderFrameId" now. 
-        const [prevRdf, rdf] = self.rollbackAndChase(self.renderFrameId, self.renderFrameId + 1, self.collisionSys, self.collisionSysMap, false);
+        const latestRdfResults = self.rollbackAndChase(self.renderFrameId, self.renderFrameId + 1, self.collisionSys, self.collisionSysMap, false);
+        let prevRdf = latestRdfResults[0],
+          rdf = latestRdfResults[1];
         /*
         const nonTrivialChaseEnded = (prevChaserRenderFrameId < nextChaserRenderFrameId && nextChaserRenderFrameId == self.renderFrameId); 
         if (nonTrivialChaseEnded) {
@@ -856,6 +904,20 @@ cc.Class({
         }  
         */
         // [WARNING] Don't try to get "prevRdf(i.e. renderFrameId == latest-1)" by "self.recentRenderCache.getByFrameId(...)" here, as the cache might have been updated by asynchronous "onRoomDownsyncFrame(...)" calls!
+        if (self.othersForcedDownsyncRenderFrameDict.has(rdf.id)) {
+          const delayedInputFrameId = self._convertToInputFrameId(rdf.id, 0);
+          const othersForcedDownsyncRenderFrame = self.othersForcedDownsyncRenderFrameDict.get(rdf.id);
+          if (self.lastAllConfirmedInputFrameId >= delayedInputFrameId && !self.equalRoomDownsyncFrames(othersForcedDownsyncRenderFrame, rdf)) {
+            console.warn(`Mismatched render frame@rdf.id=${rdf.id} w/ inputFrameId=${delayedInputFrameId}, @lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, @chaserRenderFrameId=${self.chaserRenderFrameId}:
+rdf=${JSON.stringify(rdf)}
+othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame)}
+recentRenderCache=${self._stringifyRecentRenderCache(true)}
+recentInputCache=${self._stringifyRecentInputCache(true)}`);
+            closeWSConnection(constants.RET_CODE.CLIENT_MISMATCHED_RENDER_FRAME, "");
+            self.onManualRejoinRequired("[DEBUG] CLIENT_MISMATCHED_RENDER_FRAME");
+            rdf = othersForcedDownsyncRenderFrame;
+          }
+        }
         self.applyRoomDownsyncFrameDynamics(rdf, prevRdf);
         self.showDebugBoundaries(rdf);
         ++self.renderFrameId; // [WARNING] It's important to increment the renderFrameId AFTER all the operations above!!!
@@ -941,6 +1003,7 @@ cc.Class({
 
   showPopupInCanvas(toShowNode) {
     const self = this;
+    toShowNode.active = true;
     self.disableInputControls();
     self.transitToState(ALL_MAP_STATES.SHOWING_MODAL_POPUP);
     safelyAddChild(self.widgetsAboveAllNode, toShowNode);
@@ -1078,11 +1141,13 @@ cc.Class({
   getCachedInputFrameDownsyncWithPrediction(inputFrameId) {
     const self = this;
     const inputFrameDownsync = self.recentInputCache.getByFrameId(inputFrameId);
-    const lastAllConfirmedInputFrame = self.recentInputCache.getByFrameId(self.lastAllConfirmedInputFrameId);
+    if (null != inputFrameDownsync && inputFrameId > self.lastAllConfirmedInputFrameId) {
-    if (null != inputFrameDownsync && null != lastAllConfirmedInputFrame && inputFrameId > self.lastAllConfirmedInputFrameId) {
+      const lastAllConfirmedInputFrame = self.recentInputCache.getByFrameId(self.lastAllConfirmedInputFrameId);
-      for (let i = 0; i < inputFrameDownsync.inputList.length; ++i) {
+      if (null != lastAllConfirmedInputFrame) {
-        if (i == (self.selfPlayerInfo.joinIndex - 1)) continue;
+        for (let i = 0; i < inputFrameDownsync.inputList.length; ++i) {
-        inputFrameDownsync.inputList[i] = (lastAllConfirmedInputFrame.inputList[i] & 15); // Don't predict attack input!
+          if (i == (self.selfPlayerInfo.joinIndex - 1)) continue;
+          inputFrameDownsync.inputList[i] = (lastAllConfirmedInputFrame.inputList[i] & 15); // Don't predict attack input!
+        }
       }
     }
 
@@ -1323,13 +1388,17 @@ cc.Class({
 
         if (1 == joinIndex) {
           if (fallStopping) {
+            /*
             console.info(`playerId=${playerId}, joinIndex=${thatPlayerInNextFrame.joinIndex} fallStopping#1:
 {renderFrame.id: ${currRenderFrame.id}, possiblyFallStoppedOnAnotherPlayer: ${possiblyFallStoppedOnAnotherPlayer}}
 playerColliderPos=${self.stringifyColliderCenterInWorld(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding)}, effPushback={${effPushbacks[joinIndex - 1][0].toFixed(3)}, ${effPushbacks[joinIndex - 1][1].toFixed(3)}}, overlayMag=${result.overlap.toFixed(4)}`);
+            */
           } else if (currPlayerDownsync.inAir && isBarrier && !landedOnGravityPushback) {
+            /*
             console.warn(`playerId=${playerId}, joinIndex=${currPlayerDownsync.joinIndex} inAir & pushed back by barrier & not landed:
 {renderFrame.id: ${currRenderFrame.id}}
 playerColliderPos=${self.stringifyColliderCenterInWorld(playerCollider, halfColliderWidth, halfColliderHeight, topPadding, bottomPadding, leftPadding, rightPadding)}, effPushback={${effPushbacks[joinIndex - 1][0].toFixed(3)}, ${effPushbacks[joinIndex - 1][1].toFixed(3)}}, overlayMag=${result.overlap.toFixed(4)}, len(hardPushbackNorms)=${hardPushbackNorms.length}`);
+            */
           } else if (currPlayerDownsync.inAir && isAnotherPlayer) {
             console.warn(`playerId=${playerId}, joinIndex=${currPlayerDownsync.joinIndex} inAir and pushed back by another player
 {renderFrame.id: ${currRenderFrame.id}}
@@ -1455,39 +1524,28 @@ playerColliderPos=${self.stringifyColliderCenterInWorld(playerCollider, halfColl
     const self = this;
     let prevLatestRdf = null,
       latestRdf = null;
-
     for (let i = renderFrameIdSt; i < renderFrameIdEd; i++) {
-      latestRdf = self.recentRenderCache.getByFrameId(i); // typed "RoomDownsyncFrame"; [WARNING] When "true == isChasing", this function can be interruptted by "onRoomDownsyncFrame(rdf)" asynchronously anytime, making this line return "null"!
+      const currRdf = self.recentRenderCache.getByFrameId(i); // typed "RoomDownsyncFrame"; [WARNING] When "true == isChasing" and using Firefox, this function could be interruptted by "onRoomDownsyncFrame(rdf)" asynchronously anytime, making this line return "null"!
-      if (null == latestRdf) {
+      if (null == currRdf) {
-        console.warn(`Couldn't find renderFrame for i=${i} to rollback, self.renderFrameId=${self.renderFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, might've been interruptted by onRoomDownsyncFrame`);
+        throw `Couldn't find renderFrame for i=${i} to rollback (are you using Firefox?), self.renderFrameId=${self.renderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, might've been interruptted by onRoomDownsyncFrame`;
-        return [prevLatestRdf, latestRdf];
       }
       const j = self._convertToInputFrameId(i, self.inputDelayFrames);
-      const delayedInputFrame = self.getCachedInputFrameDownsyncWithPrediction(j);
+      const delayedInputFrame = self.recentInputCache.getByFrameId(j); // Don't make prediction here, the inputFrameDownsyncs in recentInputCache was already predicted while prefabbing
       if (null == delayedInputFrame) {
         // Shouldn't happen!
-        throw `Failed to get cached delayedInputFrame for i=${i}, j=${j}, renderFrameId=${self.renderFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastUpsyncInputFrameId=${self.lastUpsyncInputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, chaserRenderFrameId=${self.chaserRenderFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
+        throw `Failed to get cached delayedInputFrame for i=${i}, j=${j}, renderFrameId=${self.renderFrameId}, lastUpsyncInputFrameId=${self.lastUpsyncInputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, chaserRenderFrameId=${self.chaserRenderFrameId}; recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`;
-      }
-      prevLatestRdf = latestRdf;
-      latestRdf = self.applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame, prevLatestRdf, collisionSys, collisionSysMap);
-      if (
-        self._allConfirmed(delayedInputFrame.confirmedList)
-        &&
-        latestRdf.id > self.lastAllConfirmedRenderFrameId
-      ) {
-        // We got a more up-to-date "all-confirmed-render-frame".
-        self.lastAllConfirmedRenderFrameId = latestRdf.id;
-        if (latestRdf.id > self.chaserRenderFrameId) {
-          // it must be true that "chaserRenderFrameId >= lastAllConfirmedRenderFrameId", regardeless of the "isChasing" param 
-          self.chaserRenderFrameId = latestRdf.id;
-        }
       }
+      const nextRdf = self.applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame, currRdf, collisionSys, collisionSysMap);
 
       if (true == isChasing) {
-        // Move the cursor "self.chaserRenderFrameId", keep in mind that "self.chaserRenderFrameId" is not monotonic!
+        // [WARNING] Move the cursor "self.chaserRenderFrameId" when "true == isChasing", keep in mind that "self.chaserRenderFrameId" is not monotonic!
-        self.chaserRenderFrameId = latestRdf.id;
+        self.chaserRenderFrameId = nextRdf.id;
+      } else if (nextRdf.id == self.chaserRenderFrameId + 1) {
+        self.chaserRenderFrameId = nextRdf.id; // To avoid redundant calculation 
       }
-      self.recentRenderCache.setByFrameId(latestRdf, latestRdf.id);
+      self.recentRenderCache.setByFrameId(nextRdf, nextRdf.id);
+      prevLatestRdf = currRdf;
+      latestRdf = nextRdf;
     }
 
     return [prevLatestRdf, latestRdf];

frontend/assets/scripts/OfflineMap.js

@@ -15,8 +15,6 @@ cc.Class({
     window.mapIns = self;
     self.showCriticalCoordinateLabels = true;
 
-    cc.director.getCollisionManager().enabled = false;
-
     const mapNode = self.node;
     const canvasNode = mapNode.parent;
 

frontend/assets/scripts/TileCollisionManagerSingleton.js

@@ -116,31 +116,28 @@ TileCollisionManager.prototype.extractBoundaryObjects = function(withTiledMapNod
   const allObjectGroups = tiledMapIns.getObjectGroups();
   for (let i = 0; i < allObjectGroups.length; ++i) {
     var objectGroup = allObjectGroups[i];
-    if ("PlayerStartingPos" == objectGroup.getGroupName()) {
-      var allObjects = objectGroup.getObjects();
-      for (let j = 0; j < allObjects.length; ++j) {
-        const cccMaskedX = allObjects[j].x,
-          cccMaskedY = allObjects[j].y;
-        const origX = cccMaskedX,
-          origY = withTiledMapNode.getContentSize().height - cccMaskedY; // FIXME: I don't know why CocosCreator did this, it's stupid and MIGHT NOT WORK IN ISOMETRIC orientation!   
-        let wpos = this.continuousObjLayerOffsetToContinuousMapNodePos(withTiledMapNode, cc.v2(origX, origY));
-        toRet.playerStartingPositions.push(wpos);
-      }
-      continue;
-    }
-    if ("barrier_and_shelter" != objectGroup.getProperty("type")) continue;
     var allObjects = objectGroup.getObjects();
-    for (let j = 0; j < allObjects.length; ++j) {
+    switch (objectGroup.getGroupName()) {
-      let object = allObjects[j];
+      case "PlayerStartingPos":
-      let gid = object.gid;
+        for (let j = 0; j < allObjects.length; ++j) {
-      if (0 < gid) {
+          const cccMaskedX = allObjects[j].x,
-        continue;
+            cccMaskedY = allObjects[j].y;
-      }
+          const origX = cccMaskedX,
-      const boundaryType = object.boundary_type;
+            origY = withTiledMapNode.getContentSize().height - cccMaskedY; // FIXME: I don't know why CocosCreator did this, it's stupid and MIGHT NOT WORK IN ISOMETRIC orientation!   
-      let toPushBarrier = [];
+          let wpos = this.continuousObjLayerOffsetToContinuousMapNodePos(withTiledMapNode, cc.v2(origX, origY));
-      toPushBarrier.boundaryType = boundaryType;
+          toRet.playerStartingPositions.push(wpos);
-      switch (boundaryType) {
+        }
-        case "barrier":
+        break;
+      case "Barrier":
+        for (let j = 0; j < allObjects.length; ++j) {
+          let object = allObjects[j];
+          let gid = object.gid;
+          if (0 < gid) {
+            continue;
+          }
+          const boundaryType = object.boundary_type;
+          let toPushBarrier = [];
+          toPushBarrier.boundaryType = boundaryType;
           let polylinePoints = object.polylinePoints;
           if (null == polylinePoints) {
             polylinePoints = [{
@@ -163,10 +160,8 @@ TileCollisionManager.prototype.extractBoundaryObjects = function(withTiledMapNod
           }
           toPushBarrier.anchor = this.continuousObjLayerOffsetToContinuousMapNodePos(withTiledMapNode, object.offset); // DON'T use "(object.x, object.y)" which are wrong/meaningless! 
           toRet.barriers.push(toPushBarrier);
-          break;
+        }
-        default:
+        break;
-          break;
-      }
     }
   }
 

frontend/assets/scripts/WsSessionMgr.js

@@ -12,7 +12,6 @@ window.DOWNSYNC_MSG_ACT_INPUT_BATCH = 2;
 window.DOWNSYNC_MSG_ACT_BATTLE_STOPPED = 3;
 window.DOWNSYNC_MSG_ACT_FORCED_RESYNC = 4;
 
-
 window.sendSafely = function(msgStr) {
   /**
   * - "If the data can't be sent (for example, because it needs to be buffered but the buffer is full), the socket is closed automatically."
@@ -28,10 +27,13 @@ window.sendUint8AsBase64Safely = function(msgUint8Arr) {
   window.clientSession.send(_uint8ToBase64(msgUint8Arr));
 }
 
-window.closeWSConnection = function() {
+window.closeWSConnection = function(code, reason) {
-  if (null == window.clientSession || window.clientSession.readyState != WebSocket.OPEN) return;
+  if (null == window.clientSession || window.clientSession.readyState != WebSocket.OPEN) {
+    console.log(`"window.clientSession" is already closed or destroyed.`);
+    return;
+  }
   console.log(`Closing "window.clientSession" from the client-side.`);
-  window.clientSession.close();
+  window.clientSession.close(code, reason);
 }
 
 window.getBoundRoomIdFromPersistentStorage = function() {
@@ -144,6 +146,7 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
     if (null == evt || null == evt.data) {
       return;
     }
+    // FIXME: In practice, it seems like the thread invoking "onmessage" could be different from "Map.update(dt)", which makes it necessary to guard "recentRenderCache & recentInputCache" for "getOrPrefabInputFrameUpsync & rollbackAndChase & onRoomDownsyncFrame & onInputFrameDownsyncBatch" to avoid mysterious RAM contamination, but there's no explicit mutex in JavaScript for browsers -- this issue is found in Firefox (108.0.1, 64-bit, Windows 11), but not in Chrome (108.0.5359.125, Official Build, 64-bit, Windows 11) -- just breakpoint in "Map.rollbackAndChase" then see whether the logs of "onmessage" can still be printed and whether the values of "recentRenderCache & recentInputCache" change in console). 
     try {
       const resp = window.pb.protos.WsResp.decode(new Uint8Array(evt.data));
       //console.log(`Got non-empty onmessage decoded: resp.act=${resp.act}`);
@@ -183,39 +186,37 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
 
   clientSession.onerror = function(evt) {
     console.error("Error caught on the WS clientSession: ", evt);
-    if (window.handleClientSessionError) {
+    window.clearLocalStorageAndBackToLoginScene(true);
-      window.handleClientSessionError();
-    }
   };
 
   clientSession.onclose = function(evt) {
     // [WARNING] The callback "onclose" might be called AFTER the webpage is refreshed with "1001 == evt.code".
-    console.warn("The WS clientSession is closed: ", evt, clientSession);
+    console.warn(`The WS clientSession is closed: evt=${JSON.stringify(evt)}, evt.code=${evt.code}`);
-    if (false == evt.wasClean) {
+    switch (evt.code) {
-      /*
+      case constants.RET_CODE.CLIENT_MISMATCHED_RENDER_FRAME:
-      Chrome doesn't allow the use of "CustomCloseCode"s (yet) and will callback with a "WebsocketStdCloseCode 1006" and "false == evt.wasClean" here. See https://tools.ietf.org/html/rfc6455#section-7.4 for more information.
+        break;
-      */
+      case constants.RET_CODE.BATTLE_STOPPED:
-      if (window.handleClientSessionError) {
+        // deliberately do nothing
-        window.handleClientSessionError();
+        break;
-      }
+      case constants.RET_CODE.PLAYER_NOT_ADDABLE_TO_ROOM:
-    } else {
+      case constants.RET_CODE.PLAYER_NOT_READDABLE_TO_ROOM:
-      switch (evt.code) {
+        window.clearBoundRoomIdInBothVolatileAndPersistentStorage(); // To favor the player to join other rooms
-        case constants.RET_CODE.PLAYER_NOT_ADDABLE_TO_ROOM:
+        mapIns.onManualRejoinRequired("Couldn't join any room at the moment, please retry");
-        case constants.RET_CODE.PLAYER_NOT_READDABLE_TO_ROOM:
+        break;
-          window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
+      case constants.RET_CODE.ACTIVE_WATCHDOG:
-          break;
+        mapIns.onManualRejoinRequired("Disconnected due to long-time inactivity, please rejoin");
-        case constants.RET_CODE.UNKNOWN_ERROR:
+        break;
-        case constants.RET_CODE.MYSQL_ERROR:
+      case constants.RET_CODE.UNKNOWN_ERROR:
-        case constants.RET_CODE.PLAYER_NOT_FOUND:
+      case constants.RET_CODE.MYSQL_ERROR:
-        case constants.RET_CODE.PLAYER_CHEATING:
+      case constants.RET_CODE.PLAYER_NOT_FOUND:
-        case 1006: // Peer(i.e. the backend) gone unexpectedly 
+      case constants.RET_CODE.PLAYER_CHEATING:
-          if (window.handleClientSessionError) {
+      case 1006: // Peer(i.e. the backend) gone unexpectedly 
-            window.handleClientSessionError();
+        console.warn(`recentRenderCache=${mapIns._stringifyRecentRenderCache(true)}
-          }
+recentInputCache=${mapIns._stringifyRecentInputCache(true)}`);
-          break;
+        window.clearLocalStorageAndBackToLoginScene(true);
-        default:
+        break;
-          break;
+      default:
-      }
+        break;
     }
   };
 };
@@ -226,19 +227,7 @@ window.clearLocalStorageAndBackToLoginScene = function(shouldRetainBoundRoomIdIn
   if (window.mapIns && window.mapIns.musicEffectManagerScriptIns) {
     window.mapIns.musicEffectManagerScriptIns.stopAllMusic();
   }
-  /**
+
-   * Here I deliberately removed the callback in the "common `handleClientSessionError` callback"
-   * within which another invocation to `clearLocalStorageAndBackToLoginScene` will be made.
-   *
-   * It'll be re-assigned to the common one upon reentrance of `Map.onLoad`.
-   *
-   * -- YFLu 2019-04-06
-   */
-  window.handleClientSessionError = () => {
-    console.warn("+++++++ Special handleClientSessionError() assigned within `clearLocalStorageAndBackToLoginScene`");
-    // TBD.
-    window.handleClientSessionError = null; // To ensure that it's called at most once. 
-  };
   window.closeWSConnection();
   window.clearSelfPlayer();
   if (true != shouldRetainBoundRoomIdInBothVolatileAndPersistentStorage) {

frontend/settings/builder.json

@@ -17,13 +17,13 @@
   },
   "encryptJs": true,
   "excludeScenes": [
-    "475b849b-44b3-4390-982d-bd0d9e695093"
+    "368b10b6-88fc-423c-9fcd-545d9fc673bd"
   ],
   "fb-instant-games": {},
   "includeSDKBox": false,
   "inlineSpriteFrames": true,
   "inlineSpriteFrames_native": true,
-  "md5Cache": true,
+  "md5Cache": false,
   "mergeStartScene": true,
   "optimizeHotUpdate": false,
   "orientation": {

frontend/settings/project.json

@@ -34,7 +34,6 @@
   "design-resolution-width": 960,
   "excluded-modules": [
     "Collider",
-    "DragonBones",
     "Geom Utils",
     "Mesh",
     "MotionStreak",
@@ -69,7 +68,7 @@
     "shelter_z_reducer",
     "shelter"
   ],
-  "last-module-event-record-time": 1579766511782,
+  "last-module-event-record-time": 1671346284377,
   "simulator-orientation": false,
   "simulator-resolution": {
     "height": 640,