Updated README.

Integer positioning.

README.md

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

battle_srv/api/v1/player.go

@@ -1,6 +1,11 @@
 package v1
 
 import (
+	"battle_srv/api"
+	. "battle_srv/common"
+	"battle_srv/common/utils"
+	"battle_srv/models"
+	"battle_srv/storage"
 	"bytes"
 	"crypto/sha256"
 	"encoding/hex"
@@ -10,11 +15,6 @@ import (
 	"go.uber.org/zap"
 	"io/ioutil"
 	"net/http"
-	"server/api"
-	. "server/common"
-	"server/common/utils"
-	"server/models"
-	"server/storage"
 	"strconv"
 
 	. "dnmshared"
@@ -79,7 +79,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 		c.Set(api.RET, Constants.RetCode.UnknownError)
 		return
 	}
-	// Redis剩余时长校验
 	if ttl >= ConstVals.Player.CaptchaMaxTTL {
 		Logger.Info("There's an existing SmsCaptcha record in Redis-server: ", zap.String("key", redisKey), zap.Duration("ttl", ttl))
 		c.Set(api.RET, Constants.RetCode.SmsCaptchaRequestedTooFrequently)
@@ -89,7 +88,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 	pass := false
 	var succRet int
 	if Conf.General.ServerEnv == SERVER_ENV_TEST {
-		// 测试环境，优先从数据库校验`player.name`，不通过再走机器人magic name校验
 		player, err := models.GetPlayerByName(req.Num)
 		if nil == err && nil != player {
 			pass = true
@@ -98,7 +96,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 	}
 
 	if !pass {
-		// 机器人magic name校验，不通过再走手机号校验
 		player, err := models.GetPlayerByName(req.Num)
 		if nil == err && nil != player {
 			pass = true
@@ -111,7 +108,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 			succRet = Constants.RetCode.Ok
 			pass = true
 		}
-		// Hardecoded 只验证国内手机号格式
 		if req.CountryCode == "86" {
 			if RE_CHINA_PHONE_NUM.MatchString(req.Num) {
 				succRet = Constants.RetCode.Ok
@@ -133,7 +129,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 	}{Ret: succRet}
 	var captcha string
 	if ttl >= 0 {
-		// 已有未过期的旧验证码记录，续验证码有效期。
 		storage.RedisManagerIns.Expire(redisKey, ConstVals.Player.CaptchaExpire)
 		captcha = storage.RedisManagerIns.Get(redisKey).Val()
 		if ttl >= ConstVals.Player.CaptchaExpire/4 {
@@ -147,7 +142,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 		}
 		Logger.Info("Extended ttl of existing SMSCaptcha record in Redis:", zap.String("key", redisKey), zap.String("captcha", captcha))
 	} else {
-		// 校验通过，进行验证码生成处理
 		captcha = strconv.Itoa(utils.Rand.Number(1000, 9999))
 		if succRet == Constants.RetCode.Ok {
 			getSmsCaptchaRespErrorCode := sendSMSViaVendor(req.Num, req.CountryCode, captcha)
@@ -234,7 +228,6 @@ func (p *playerController) WechatLogin(c *gin.Context) {
 		return
 	}
 
-	//baseInfo ResAccessToken 获取用户授权access_token的返回结果
 	baseInfo, err := utils.WechatIns.GetOauth2Basic(req.Authcode)
 
 	if err != nil {
@@ -250,7 +243,6 @@ func (p *playerController) WechatLogin(c *gin.Context) {
 		c.Set(api.RET, Constants.RetCode.WechatServerError)
 		return
 	}
-	//fserver不会返回openId
 	userInfo.OpenID = baseInfo.OpenID
 
 	player, err := p.maybeCreatePlayerWechatAuthBinding(userInfo)
@@ -316,7 +308,6 @@ func (p *playerController) WechatGameLogin(c *gin.Context) {
 		return
 	}
 
-	//baseInfo ResAccessToken 获取用户授权access_token的返回结果
 	baseInfo, err := utils.WechatGameIns.GetOauth2Basic(req.Authcode)
 
 	if err != nil {
@@ -337,7 +328,6 @@ func (p *playerController) WechatGameLogin(c *gin.Context) {
 		c.Set(api.RET, Constants.RetCode.WechatServerError)
 		return
 	}
-	//fserver不会返回openId
 	userInfo.OpenID = baseInfo.OpenID
 
 	player, err := p.maybeCreatePlayerWechatGameAuthBinding(userInfo)
@@ -395,7 +385,6 @@ func (p *playerController) IntAuthTokenLogin(c *gin.Context) {
 		return
 	}
 
-	//kobako: 从player获取display name等
 	player, err := models.GetPlayerById(playerLogin.PlayerID)
 	if err != nil {
 		Logger.Error("Get player by id in IntAuthTokenLogin function error: ", zap.Error(err))
@@ -479,7 +468,6 @@ func (p *playerController) TokenAuth(c *gin.Context) {
 	c.Abort()
 }
 
-// 以下是内部私有函数
 func (p *playerController) maybeCreateNewPlayer(req smsCaptchaReq) (*models.Player, error) {
 	extAuthID := req.extAuthID()
 	if Conf.General.ServerEnv == SERVER_ENV_TEST {
@@ -492,7 +480,7 @@ func (p *playerController) maybeCreateNewPlayer(req smsCaptchaReq) (*models.Play
 			Logger.Info("Got a test env player:", zap.Any("phonenum", req.Num), zap.Any("playerId", player.Id))
 			return player, nil
 		}
-	} else { //正式环境检查是否为bot用户
+	} else {
 		botPlayer, err := models.GetPlayerByName(req.Num)
 		if err != nil {
 			Logger.Error("Seeking bot player error:", zap.Error(err))
@@ -537,19 +525,17 @@ func (p *playerController) maybeCreatePlayerWechatAuthBinding(userInfo utils.Use
 			return nil, err
 		}
 		if player != nil {
-			{ //更新玩家姓名及头像
-				updateInfo := models.Player{
-					Avatar:      userInfo.HeadImgURL,
-					DisplayName: userInfo.Nickname,
-				}
-				tx := storage.MySQLManagerIns.MustBegin()
-				defer tx.Rollback()
-				ok, err := models.Update(tx, player.Id, &updateInfo)
-				if err != nil && ok != true {
-					return nil, err
-				} else {
-					tx.Commit()
-				}
+			updateInfo := models.Player{
+				Avatar:      userInfo.HeadImgURL,
+				DisplayName: userInfo.Nickname,
+			}
+			tx := storage.MySQLManagerIns.MustBegin()
+			defer tx.Rollback()
+			ok, err := models.Update(tx, player.Id, &updateInfo)
+			if err != nil && ok != true {
+				return nil, err
+			} else {
+				tx.Commit()
 			}
 			return player, nil
 		}
@@ -575,19 +561,17 @@ func (p *playerController) maybeCreatePlayerWechatGameAuthBinding(userInfo utils
 			return nil, err
 		}
 		if player != nil {
-			{ //更新玩家姓名及头像
-				updateInfo := models.Player{
-					Avatar:      userInfo.HeadImgURL,
-					DisplayName: userInfo.Nickname,
-				}
-				tx := storage.MySQLManagerIns.MustBegin()
-				defer tx.Rollback()
-				ok, err := models.Update(tx, player.Id, &updateInfo)
-				if err != nil && ok != true {
-					return nil, err
-				} else {
-					tx.Commit()
-				}
+			updateInfo := models.Player{
+				Avatar:      userInfo.HeadImgURL,
+				DisplayName: userInfo.Nickname,
+			}
+			tx := storage.MySQLManagerIns.MustBegin()
+			defer tx.Rollback()
+			ok, err := models.Update(tx, player.Id, &updateInfo)
+			if err != nil && ok != true {
+				return nil, err
+			} else {
+				tx.Commit()
 			}
 			return player, nil
 		}
@@ -672,15 +656,13 @@ func sendSMSViaVendor(mobile string, nationcode string, captchaCode string) int
 		Nationcode: nationcode,
 	}
 	var captchaExpireMin string
-	//短信有效期hardcode
 	if Conf.General.ServerEnv == SERVER_ENV_TEST {
-		//测试环境下有效期为20秒 先hardcode了
-		captchaExpireMin = "0.5"
+		captchaExpireMin = "0.5" // Hardcoded
 	} else {
 		captchaExpireMin = strconv.Itoa(int(ConstVals.Player.CaptchaExpire) / 60000000000)
 	}
 	params := [2]string{captchaCode, captchaExpireMin}
-	appkey := "41a5142feff0b38ade02ea12deee9741" // TODO: Should read from config file!
+	appkey := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // TODO: Should read from config file!
 	rand := strconv.Itoa(utils.Rand.Number(1000, 9999))
 	now := utils.UnixtimeSec()
 
@@ -694,7 +676,7 @@ func sendSMSViaVendor(mobile string, nationcode string, captchaCode string) int
 		Extend: "",
 		Params: &params,
 		Sig:    sig,
-		Sign:   "洛克互娱",
+		Sign:   "YYYYYYYYYYYYYYYYY",
 		Tel:    tel,
 		Time:   now,
 		Tpl_id: 207399,
@@ -705,7 +687,7 @@ func sendSMSViaVendor(mobile string, nationcode string, captchaCode string) int
 		Logger.Info("json marshal", zap.Any("err:", err))
 		return -1
 	}
-	resp, err := http.Post("https://yun.tim.qq.com/v5/tlssmssvr/sendsms?sdkappid=1400150185&random="+rand,
+	resp, err := http.Post("https://yun.tim.qq.com/v5/tlssmssvr/sendsms?sdkappid=uuuuuuuuuuuuuuuuuuuuuuuu&random="+rand,
 		"application/json",
 		req)
 	if err != nil {

battle_srv/common/utils/wechat.go

@@ -1,6 +1,8 @@
 package utils
 
 import (
+	. "battle_srv/common"
+	. "battle_srv/configs"
 	"bytes"
 	"crypto/sha1"
 	. "dnmshared"
@@ -11,8 +13,6 @@ import (
 	"io/ioutil"
 	"math/rand"
 	"net/http"
-	. "server/common"
-	. "server/configs"
 	"sort"
 	"time"
 )
@@ -250,10 +250,6 @@ func (w *wechat) getTicketFromServer() (ticket resTicket, err error) {
 		return
 	}
 
-	//jsAPITicketCacheKey := fmt.Sprintf("jsapi_ticket_%s", w.config.AppID)
-	//expires := ticket.ExpiresIn - 1500
-	//set
-	//err = js.Cache.Set(jsAPITicketCacheKey, ticket.Ticket, time.Duration(expires)*time.Second)
 	return
 }
 
@@ -276,9 +272,6 @@ func (w *wechat) getAccessTokenFromServer() (accessToken string, err error) {
 		return
 	}
 
-	//accessTokenCacheKey := fmt.Sprintf("access_token_%s", w.config.AppID)
-	//expires := r.ExpiresIn - 1500
-	//set to redis err = ctx.Cache.Set(accessTokenCacheKey, r.AccessToken, time.Duration(expires)*time.Second)
 	accessToken = r.AccessToken
 	return
 }

battle_srv/env_tools/load_pre_conf.go

@@ -1,15 +1,15 @@
 package env_tools
 
 import (
+	. "battle_srv/common"
+	"battle_srv/common/utils"
+	"battle_srv/models"
+	"battle_srv/storage"
 	. "dnmshared"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jmoiron/sqlx"
 	_ "github.com/mattn/go-sqlite3"
 	"go.uber.org/zap"
-	. "server/common"
-	"server/common/utils"
-	"server/models"
-	"server/storage"
 )
 
 func LoadPreConf() {

battle_srv/env_tools/test_env_db.go

@@ -1,11 +1,11 @@
 package env_tools
 
 import (
+	. "battle_srv/common"
+	"battle_srv/common/utils"
+	"battle_srv/models"
+	"battle_srv/storage"
 	. "dnmshared"
-	. "server/common"
-	"server/common/utils"
-	"server/models"
-	"server/storage"
 
 	"github.com/jmoiron/sqlx"
 	_ "github.com/mattn/go-sqlite3"

battle_srv/go.mod

@@ -1,4 +1,4 @@
-module server
+module battle_srv
 
 go 1.19
 

battle_srv/main.go

@@ -1,19 +1,19 @@
 package main
 
 import (
+	"battle_srv/api"
+	"battle_srv/api/v1"
+	. "battle_srv/common"
+	"battle_srv/env_tools"
+	"battle_srv/models"
+	"battle_srv/storage"
+	"battle_srv/ws"
 	"context"
 	"fmt"
 	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
-	"server/api"
-	"server/api/v1"
-	. "server/common"
-	"server/env_tools"
-	"server/models"
-	"server/storage"
-	"server/ws"
 	"syscall"
 	"time"
 

battle_srv/models/barrier.go

@@ -1,7 +1,7 @@
 package models
 
 import (
-	. "dnmshared"
+	. "dnmshared/sharedprotos"
 )
 
 type Barrier struct {

battle_srv/models/pb_type_convert.go

@@ -1,77 +1,22 @@
 package models
 
 import (
-	. "dnmshared"
-	pb "server/pb_output"
+	. "battle_srv/protos"
+	. "dnmshared/sharedprotos"
 )
 
-func toPbVec2D(modelInstance *Vec2D) *pb.Vec2D {
-	toRet := &pb.Vec2D{
-		X: modelInstance.X,
-		Y: modelInstance.Y,
-	}
-	return toRet
-}
-
-func toPbPolygon2D(modelInstance *Polygon2D) *pb.Polygon2D {
-	toRet := &pb.Polygon2D{
-		Anchor: toPbVec2D(modelInstance.Anchor),
-		Points: make([]*pb.Vec2D, len(modelInstance.Points)),
-	}
-	for index, p := range modelInstance.Points {
-		toRet.Points[index] = toPbVec2D(p)
-	}
-	return toRet
-}
-
-func toPbVec2DList(modelInstance *Vec2DList) *pb.Vec2DList {
-	toRet := &pb.Vec2DList{
-		Vec2DList: make([]*pb.Vec2D, len(*modelInstance)),
-	}
-	for k, v := range *modelInstance {
-		toRet.Vec2DList[k] = toPbVec2D(v)
-	}
-	return toRet
-}
-
-func ToPbVec2DListMap(modelInstances map[string]*Vec2DList) map[string]*pb.Vec2DList {
-	toRet := make(map[string]*pb.Vec2DList, len(modelInstances))
-	for k, v := range modelInstances {
-		toRet[k] = toPbVec2DList(v)
-	}
-	return toRet
-}
-
-func toPbPolygon2DList(modelInstance *Polygon2DList) *pb.Polygon2DList {
-	toRet := &pb.Polygon2DList{
-		Polygon2DList: make([]*pb.Polygon2D, len(*modelInstance)),
-	}
-	for k, v := range *modelInstance {
-		toRet.Polygon2DList[k] = toPbPolygon2D(v)
-	}
-	return toRet
-}
-
-func ToPbPolygon2DListMap(modelInstances map[string]*Polygon2DList) map[string]*pb.Polygon2DList {
-	toRet := make(map[string]*pb.Polygon2DList, len(modelInstances))
-	for k, v := range modelInstances {
-		toRet[k] = toPbPolygon2DList(v)
-	}
-	return toRet
-}
-
-func toPbPlayers(modelInstances map[int32]*Player) map[int32]*pb.Player {
-	toRet := make(map[int32]*pb.Player, 0)
+func toPbPlayers(modelInstances map[int32]*Player) map[int32]*PlayerDownsync {
+	toRet := make(map[int32]*PlayerDownsync, 0)
 	if nil == modelInstances {
 		return toRet
 	}
 
 	for k, last := range modelInstances {
-		toRet[k] = &pb.Player{
-			Id: last.Id,
-			X:  last.X,
-			Y:  last.Y,
-			Dir: &pb.Direction{
+		toRet[k] = &PlayerDownsync{
+			Id:           last.Id,
+			VirtualGridX: last.VirtualGridX,
+			VirtualGridY: last.VirtualGridY,
+			Dir: &Direction{
 				Dx: last.Dir.Dx,
 				Dy: last.Dir.Dy,
 			},

battle_srv/models/player.go

@@ -2,7 +2,7 @@ package models
 
 import (
 	"database/sql"
-	. "dnmshared"
+	. "dnmshared/sharedprotos"
 	"fmt"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jmoiron/sqlx"
@@ -33,30 +33,32 @@ func InitPlayerBattleStateIns() {
 }
 
 type Player struct {
-	Id                int32      `json:"id,omitempty" db:"id"`
-	X                 float64    `json:"x,omitempty"`
-	Y                 float64    `json:"y,omitempty"`
-	Dir               *Direction `json:"dir,omitempty"`
-	Speed             float64    `json:"speed,omitempty"`
-	BattleState       int32      `json:"battleState,omitempty"`
-	LastMoveGmtMillis int32      `json:"lastMoveGmtMillis,omitempty"`
-	Score             int32      `json:"score,omitempty"`
-	Removed           bool       `json:"removed,omitempty"`
-	JoinIndex         int32
+	// Meta info fields
+	Id             int32   `json:"id,omitempty" db:"id"`
+	Name           string  `json:"name,omitempty" db:"name"`
+	DisplayName    string  `json:"displayName,omitempty" db:"display_name"`
+	Avatar         string  `json:"avatar,omitempty"`
+	ColliderRadius float64 `json:"-"`
 
-	Name        string `json:"name,omitempty" db:"name"`
-	DisplayName string `json:"displayName,omitempty" db:"display_name"`
-	Avatar      string `json:"avatar,omitempty"`
+	// DB only fields
+	CreatedAt     int64     `db:"created_at"`
+	UpdatedAt     int64     `db:"updated_at"`
+	DeletedAt     NullInt64 `db:"deleted_at"`
+	TutorialStage int       `db:"tutorial_stage"`
 
-	FrozenAtGmtMillis    int64     `json:"-" db:"-"`
-	AddSpeedAtGmtMillis  int64     `json:"-" db:"-"`
-	CreatedAt            int64     `json:"-" db:"created_at"`
-	UpdatedAt            int64     `json:"-" db:"updated_at"`
-	DeletedAt            NullInt64 `json:"-" db:"deleted_at"`
-	TutorialStage        int       `json:"-" db:"tutorial_stage"`
-	AckingFrameId        int32     `json:"ackingFrameId"`
-	AckingInputFrameId   int32     `json:"-"`
-	LastSentInputFrameId int32     `json:"-"`
+	// in-battle info fields
+	VirtualGridX         int32
+	VirtualGridY         int32
+	Dir                  *Direction
+	Speed                int32
+	BattleState          int32
+	LastMoveGmtMillis    int32
+	Score                int32
+	Removed              bool
+	JoinIndex            int32
+	AckingFrameId        int32
+	AckingInputFrameId   int32
+	LastSentInputFrameId int32
 }
 
 func ExistPlayerByName(name string) (bool, error) {

battle_srv/models/player_dao_helper.go

@@ -1,9 +1,9 @@
 package models
 
 import (
+	"battle_srv/storage"
 	"database/sql"
 	. "dnmshared"
-	"server/storage"
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jmoiron/sqlx"

battle_srv/models/player_login.go

@@ -1,10 +1,10 @@
 package models
 
 import (
+	. "battle_srv/common"
+	"battle_srv/common/utils"
+	"battle_srv/storage"
 	"database/sql"
-	. "server/common"
-	"server/common/utils"
-	"server/storage"
 
 	sq "github.com/Masterminds/squirrel"
 )

battle_srv/models/player_wallet.go

@@ -1,11 +1,11 @@
 package models
 
 import (
+	. "battle_srv/common"
+	"battle_srv/common/utils"
 	"database/sql"
 	. "dnmshared"
 	"errors"
-	. "server/common"
-	"server/common/utils"
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jmoiron/sqlx"

battle_srv/models/room.go

@@ -1,26 +1,26 @@
 package models
 
 import (
+	. "battle_srv/common"
+	"battle_srv/common/utils"
+	. "battle_srv/protos"
 	. "dnmshared"
+	. "dnmshared/sharedprotos"
+	"encoding/xml"
 	"fmt"
 	"github.com/golang/protobuf/proto"
 	"github.com/gorilla/websocket"
 	"github.com/solarlune/resolv"
 	"go.uber.org/zap"
+	"io/ioutil"
 	"math"
 	"math/rand"
-	. "server/common"
-	"server/common/utils"
-	pb "server/pb_output"
+	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
-
-	"encoding/xml"
-	"io/ioutil"
-	"os"
-	"path/filepath"
 )
 
 const (
@@ -61,36 +61,17 @@ const (
 	MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED      = -2
 )
 
+// These directions are chosen such that when speed is changed to "(speedX+delta, speedY+delta)" for any of them, the direction is unchanged.
 var DIRECTION_DECODER = [][]int32{
 	{0, 0},
-	{0, +1},
-	{0, -1},
+	{0, +2},
+	{0, -2},
 	{+2, 0},
 	{-2, 0},
-	{+2, +1},
-	{-2, -1},
-	{+2, -1},
-	{-2, +1},
-	{+2, 0},
-	{-2, 0},
-	{0, +1},
-	{0, -1},
-}
-
-var DIRECTION_DECODER_INVERSE_LENGTH = []float64{
-	0.0,
-	1.0,
-	1.0,
-	0.5,
-	0.5,
-	0.4472,
-	0.4472,
-	0.4472,
-	0.4472,
-	0.5,
-	0.5,
-	1.0,
-	1.0,
+	{+1, +1},
+	{-1, -1},
+	{+1, -1},
+	{-1, +1},
 }
 
 type RoomBattleState struct {
@@ -129,11 +110,13 @@ func calRoomScore(inRoomPlayerCount int32, roomPlayerCnt int, currentRoomBattleS
 }
 
 type Room struct {
-	Id              int32
-	Capacity        int
-	Players         map[int32]*Player
-	PlayersArr      []*Player // ordered by joinIndex
-	CollisionSysMap map[int32]*resolv.Object
+	Id                    int32
+	Capacity              int
+	collisionSpaceOffsetX float64
+	collisionSpaceOffsetY float64
+	Players               map[int32]*Player
+	PlayersArr            []*Player // ordered by joinIndex
+	CollisionSysMap       map[int32]*resolv.Object
 	/**
 		 * The following `PlayerDownsyncSessionDict` is NOT individually put
 		 * under `type Player struct` for a reason.
@@ -177,11 +160,15 @@ type Room struct {
 	NstDelayFrames                         int32  // network-single-trip delay in the count of render frames, proposed to be (InputDelayFrames >> 1) because we expect a round-trip delay to be exactly "InputDelayFrames"
 	InputScaleFrames                       uint32 // inputDelayedAndScaledFrameId = ((originalFrameId - InputDelayFrames) >> InputScaleFrames)
 	JoinIndexBooleanArr                    []bool
-	RollbackEstimatedDt                    float64
 	RollbackEstimatedDtMillis              float64
 	RollbackEstimatedDtNanos               int64
 	LastRenderFrameIdTriggeredAt           int64
 
+	WorldToVirtualGridRatio float64
+	VirtualGridToWorldRatio float64
+
+	PlayerDefaultSpeed int32
+
 	StageName                      string
 	StageDiscreteW                 int32
 	StageDiscreteH                 int32
@@ -189,13 +176,9 @@ type Room struct {
 	StageTileH                     int32
 	RawBattleStrToVec2DListMap     StrToVec2DListMap
 	RawBattleStrToPolygon2DListMap StrToPolygon2DListMap
+	BackendDynamicsEnabled         bool
 }
 
-const (
-	PLAYER_DEFAULT_SPEED = float64(200) // Hardcoded
-	ADD_SPEED            = float64(100) // Hardcoded
-)
-
 func (pR *Room) updateScore() {
 	pR.Score = calRoomScore(pR.EffectivePlayerCount, pR.Capacity, pR.State)
 }
@@ -217,9 +200,8 @@ func (pR *Room) AddPlayerIfPossible(pPlayerFromDbInit *Player, session *websocke
 	pPlayerFromDbInit.AckingInputFrameId = -1
 	pPlayerFromDbInit.LastSentInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_NORMAL_ADDED
 	pPlayerFromDbInit.BattleState = PlayerBattleStateIns.ADDED_PENDING_BATTLE_COLLIDER_ACK
-	pPlayerFromDbInit.FrozenAtGmtMillis = -1       // Hardcoded temporarily.
-	pPlayerFromDbInit.Speed = PLAYER_DEFAULT_SPEED // Hardcoded temporarily.
-	pPlayerFromDbInit.AddSpeedAtGmtMillis = -1     // Hardcoded temporarily.
+	pPlayerFromDbInit.Speed = pR.PlayerDefaultSpeed // Hardcoded
+	pPlayerFromDbInit.ColliderRadius = float64(24)  // Hardcoded
 
 	pR.Players[playerId] = pPlayerFromDbInit
 	pR.PlayerDownsyncSessionDict[playerId] = session
@@ -251,6 +233,8 @@ func (pR *Room) ReAddPlayerIfPossible(pTmpPlayerInstance *Player, session *webso
 	pEffectiveInRoomPlayerInstance.AckingInputFrameId = -1
 	pEffectiveInRoomPlayerInstance.LastSentInputFrameId = MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED
 	pEffectiveInRoomPlayerInstance.BattleState = PlayerBattleStateIns.READDED_PENDING_BATTLE_COLLIDER_ACK
+	pEffectiveInRoomPlayerInstance.Speed = pR.PlayerDefaultSpeed // Hardcoded
+	pEffectiveInRoomPlayerInstance.ColliderRadius = float64(16)  // Hardcoded
 
 	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
@@ -268,7 +252,7 @@ func (pR *Room) ChooseStage() error {
 	}
 
 	rand.Seed(time.Now().Unix())
-	stageNameList := []string{ /*"simple" ,*/ "richsoil"}
+	stageNameList := []string{"simple" /* "richsoil" */}
 	chosenStageIndex := rand.Int() % len(stageNameList) // Hardcoded temporarily. -- YFLu
 
 	pR.StageName = stageNameList[chosenStageIndex]
@@ -328,8 +312,8 @@ func (pR *Room) ChooseStage() error {
 	barrierPolygon2DList := *(toRetStrToPolygon2DListMap["Barrier"])
 
 	var barrierLocalIdInBattle int32 = 0
-	for _, polygon2DUnaligned := range barrierPolygon2DList {
-        polygon2D := AlignPolygon2DToBoundingBox(polygon2DUnaligned)  
+	for _, polygon2DUnaligned := range barrierPolygon2DList.Eles {
+		polygon2D := AlignPolygon2DToBoundingBox(polygon2DUnaligned)
 		/*
 		   // For debug-printing only.
 		   Logger.Info("ChooseStage printing polygon2D for barrierPolygon2DList", zap.Any("barrierLocalIdInBattle", barrierLocalIdInBattle), zap.Any("polygon2D.Anchor", polygon2D.Anchor), zap.Any("polygon2D.Points", polygon2D.Points))
@@ -361,7 +345,7 @@ func (pR *Room) ConvertToLastUsedRenderFrameId(inputFrameId int32, inputDelayFra
 	return ((inputFrameId << pR.InputScaleFrames) + inputDelayFrames + (1 << pR.InputScaleFrames) - 1)
 }
 
-func (pR *Room) EncodeUpsyncCmd(upsyncCmd *pb.InputFrameUpsync) uint64 {
+func (pR *Room) EncodeUpsyncCmd(upsyncCmd *InputFrameUpsync) uint64 {
 	var ret uint64 = 0
 	// There're 13 possible directions, occupying the first 4 bits, no need to shift
 	ret += uint64(upsyncCmd.EncodedDir)
@@ -385,7 +369,7 @@ func (pR *Room) InputsBufferString(allDetails bool) string {
 			if nil == tmp {
 				break
 			}
-			f := tmp.(*pb.InputFrameDownsync)
+			f := tmp.(*InputFrameDownsync)
 			s = append(s, fmt.Sprintf("{inputFrameId: %v, inputList: %v, confirmedList: %v}", f.InputFrameId, f.InputList, f.ConfirmedList))
 		}
 
@@ -407,7 +391,7 @@ func (pR *Room) StartBattle() {
 
 	// Initialize the "collisionSys" as well as "RenderFrameBuffer"
 	pR.CurDynamicsRenderFrameId = 0
-	kickoffFrame := &pb.RoomDownsyncFrame{
+	kickoffFrame := &RoomDownsyncFrame{
 		Id:             pR.RenderFrameId,
 		Players:        toPbPlayers(pR.Players),
 		CountdownNanos: pR.BattleDurationNanos,
@@ -415,7 +399,11 @@ func (pR *Room) StartBattle() {
 	pR.RenderFrameBuffer.Put(kickoffFrame)
 
 	// Refresh "Colliders"
-	pR.refreshColliders()
+	spaceW := pR.StageDiscreteW * pR.StageTileW
+	spaceH := pR.StageDiscreteH * pR.StageTileH
+
+	pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY = float64(spaceW)*0.5, float64(spaceH)*0.5
+	pR.refreshColliders(spaceW, spaceH)
 
 	/**
 	 * Will be triggered from a goroutine which executes the critical `Room.AddPlayerIfPossible`, thus the `battleMainLoop` should be detached.
@@ -459,17 +447,11 @@ func (pR *Room) StartBattle() {
 				pR.prefabInputFrameDownsync(noDelayInputFrameId)
 			}
 
-			// Force setting all-confirmed of buffered inputFrames periodically
-			unconfirmedMask := pR.forceConfirmationIfApplicable()
-
-			dynamicsDuration := int64(0)
-			if 0 <= pR.LastAllConfirmedInputFrameId {
-				dynamicsStartedAt := utils.UnixtimeNano()
-				// Apply "all-confirmed inputFrames" to move forward "pR.CurDynamicsRenderFrameId"
-				nextDynamicsRenderFrameId := pR.ConvertToLastUsedRenderFrameId(pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames)
-				Logger.Debug(fmt.Sprintf("roomId=%v, room.RenderFrameId=%v, LastAllConfirmedInputFrameId=%v, InputDelayFrames=%v, nextDynamicsRenderFrameId=%v", pR.Id, pR.RenderFrameId, pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames, nextDynamicsRenderFrameId))
-				pR.applyInputFrameDownsyncDynamics(pR.CurDynamicsRenderFrameId, nextDynamicsRenderFrameId)
-				dynamicsDuration = utils.UnixtimeNano() - dynamicsStartedAt
+			pR.markConfirmationIfApplicable()
+			unconfirmedMask := uint64(0)
+			if pR.BackendDynamicsEnabled {
+				// Force setting all-confirmed of buffered inputFrames periodically
+				unconfirmedMask = pR.forceConfirmationIfApplicable()
 			}
 
 			upperToSendInputFrameId := atomic.LoadInt32(&(pR.LastAllConfirmedInputFrameId))
@@ -479,31 +461,45 @@ func (pR *Room) StartBattle() {
 
 			   If "NstDelayFrames" becomes larger, "pR.RenderFrameId - refRenderFrameId" possibly becomes larger because the force confirmation is delayed more.
 
-			   Hence even upon resync, it's still possible that "refRenderFrameId < frontend.chaserRenderFrameId".
+			   Upon resync, it's still possible that "refRenderFrameId < frontend.chaserRenderFrameId" -- and this is allowed.
 			*/
 			refRenderFrameId := pR.ConvertToGeneratingRenderFrameId(upperToSendInputFrameId) + (1 << pR.InputScaleFrames) - 1
-			// [WARNING] The following inequalities are seldom true, but just to avoid that in good network condition the frontend resyncs itself to a "too advanced frontend.renderFrameId", and then starts upsyncing "too advanced inputFrameId".
 			if refRenderFrameId > pR.RenderFrameId {
 				refRenderFrameId = pR.RenderFrameId
 			}
-			if refRenderFrameId > pR.CurDynamicsRenderFrameId {
-				refRenderFrameId = pR.CurDynamicsRenderFrameId
+
+			dynamicsDuration := int64(0)
+			if pR.BackendDynamicsEnabled {
+				if 0 <= pR.LastAllConfirmedInputFrameId {
+					dynamicsStartedAt := utils.UnixtimeNano()
+					// Apply "all-confirmed inputFrames" to move forward "pR.CurDynamicsRenderFrameId"
+					nextDynamicsRenderFrameId := pR.ConvertToLastUsedRenderFrameId(pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames)
+					Logger.Debug(fmt.Sprintf("roomId=%v, room.RenderFrameId=%v, LastAllConfirmedInputFrameId=%v, InputDelayFrames=%v, nextDynamicsRenderFrameId=%v", pR.Id, pR.RenderFrameId, pR.LastAllConfirmedInputFrameId, pR.InputDelayFrames, nextDynamicsRenderFrameId))
+					pR.applyInputFrameDownsyncDynamics(pR.CurDynamicsRenderFrameId, nextDynamicsRenderFrameId, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY)
+					dynamicsDuration = utils.UnixtimeNano() - dynamicsStartedAt
+				}
+
+				// [WARNING] The following inequality are seldom true, but just to avoid that in good network condition the frontend resyncs itself to a "too advanced frontend.renderFrameId", and then starts upsyncing "too advanced inputFrameId".
+				if refRenderFrameId > pR.CurDynamicsRenderFrameId {
+					refRenderFrameId = pR.CurDynamicsRenderFrameId
+				}
 			}
+
 			for playerId, player := range pR.Players {
 				if swapped := atomic.CompareAndSwapInt32(&player.BattleState, PlayerBattleStateIns.ACTIVE, PlayerBattleStateIns.ACTIVE); !swapped {
 					// [WARNING] DON'T send anything if the player is disconnected, because it could jam the channel and cause significant delay upon "battle recovery for reconnected player".
 					continue
 				}
 				if 0 == pR.RenderFrameId {
-					kickoffFrame := pR.RenderFrameBuffer.GetByFrameId(0).(*pb.RoomDownsyncFrame)
+					kickoffFrame := pR.RenderFrameBuffer.GetByFrameId(0).(*RoomDownsyncFrame)
 					pR.sendSafely(kickoffFrame, nil, DOWNSYNC_MSG_ACT_BATTLE_START, playerId)
 				} else {
 					// [WARNING] Websocket is TCP-based, thus no need to re-send a previously sent inputFrame to a same player!
-					toSendInputFrames := make([]*pb.InputFrameDownsync, 0, pR.InputsBuffer.Cnt)
+					toSendInputFrames := make([]*InputFrameDownsync, 0, pR.InputsBuffer.Cnt)
 					candidateToSendInputFrameId := pR.Players[playerId].LastSentInputFrameId + 1
 					if candidateToSendInputFrameId < pR.InputsBuffer.StFrameId {
 						// [WARNING] As "player.LastSentInputFrameId <= lastAllConfirmedInputFrameIdWithChange" for each iteration, and "lastAllConfirmedInputFrameIdWithChange <= lastAllConfirmedInputFrameId" where the latter is used to "applyInputFrameDownsyncDynamics" and then evict "pR.InputsBuffer", thus there's a very high possibility that "player.LastSentInputFrameId" is already evicted.
-						// Logger.Debug(fmt.Sprintf("LastSentInputFrameId already popped: roomId=%v, playerId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, candidateToSendInputFrameId-1, player.AckingInputFrameId, pR.InputsBufferString(false)))
+						Logger.Warn(fmt.Sprintf("LastSentInputFrameId already popped: roomId=%v, playerId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v, InputsBuffer=%v", pR.Id, playerId, candidateToSendInputFrameId-1, player.AckingInputFrameId, pR.InputsBufferString(false)))
 						candidateToSendInputFrameId = pR.InputsBuffer.StFrameId
 					}
 
@@ -519,7 +515,7 @@ func (pR *Room) StartBattle() {
 						if nil == tmp {
 							panic(fmt.Sprintf("Required inputFrameId=%v for roomId=%v, playerId=%v doesn't exist! InputsBuffer=%v", candidateToSendInputFrameId, pR.Id, playerId, pR.InputsBufferString(false)))
 						}
-						f := tmp.(*pb.InputFrameDownsync)
+						f := tmp.(*InputFrameDownsync)
 						if pR.inputFrameIdDebuggable(candidateToSendInputFrameId) {
 							Logger.Debug("inputFrame lifecycle#3[sending]:", zap.Any("roomId", pR.Id), zap.Any("playerId", playerId), zap.Any("playerAckingInputFrameId", player.AckingInputFrameId), zap.Any("inputFrameId", candidateToSendInputFrameId), zap.Any("inputFrameId-doublecheck", f.InputFrameId), zap.Any("InputsBuffer", pR.InputsBufferString(false)), zap.Any("ConfirmedList", f.ConfirmedList))
 						}
@@ -529,22 +525,26 @@ func (pR *Room) StartBattle() {
 
 					if 0 >= len(toSendInputFrames) {
 						// [WARNING] When sending DOWNSYNC_MSG_ACT_FORCED_RESYNC, there MUST BE accompanying "toSendInputFrames" for calculating "refRenderFrameId"!
-
 						if MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED == player.LastSentInputFrameId {
-							Logger.Warn(fmt.Sprintf("Not sending due to empty toSendInputFrames: roomId=%v, playerId=%v, refRenderFrameId=%v, candidateToSendInputFrameId=%v, upperToSendInputFrameId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v", pR.Id, playerId, refRenderFrameId, candidateToSendInputFrameId, upperToSendInputFrameId, player.LastSentInputFrameId, player.AckingInputFrameId))
+							Logger.Warn(fmt.Sprintf("Not sending due to empty toSendInputFrames: roomId=%v, playerId=%v, refRenderFrameId=%v, upperToSendInputFrameId=%v, lastSentInputFrameId=%v, playerAckingInputFrameId=%v", pR.Id, playerId, refRenderFrameId, upperToSendInputFrameId, player.LastSentInputFrameId, player.AckingInputFrameId))
 						}
 						continue
 					}
 
-					indiceInJoinIndexBooleanArr := uint32(player.JoinIndex - 1)
-					var joinMask uint64 = (1 << indiceInJoinIndexBooleanArr)
-					if MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED == player.LastSentInputFrameId || 0 < (unconfirmedMask&joinMask) {
-						// [WARNING] Even upon "MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED", it could be true that "0 == (unconfirmedMask & joinMask)"!
+					/*
+					   Resync helps
+					   1. when player with a slower frontend clock lags significantly behind and thus wouldn't get its inputUpsync recognized due to faster "forceConfirmation"
+					   2. reconnection
+					*/
+					shouldResync1 := (MAGIC_LAST_SENT_INPUT_FRAME_ID_READDED == player.LastSentInputFrameId)
+					// shouldResync2 := (0 < (unconfirmedMask & uint64(1 << uint32(player.JoinIndex-1)))) // 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
+					if pR.BackendDynamicsEnabled && (shouldResync1 || shouldResync2) {
 						tmp := pR.RenderFrameBuffer.GetByFrameId(refRenderFrameId)
 						if nil == tmp {
 							panic(fmt.Sprintf("Required refRenderFrameId=%v for roomId=%v, playerId=%v, candidateToSendInputFrameId=%v doesn't exist! InputsBuffer=%v, RenderFrameBuffer=%v", refRenderFrameId, pR.Id, playerId, candidateToSendInputFrameId, pR.InputsBufferString(false), pR.RenderFrameBufferString()))
 						}
-						refRenderFrame := tmp.(*pb.RoomDownsyncFrame)
+						refRenderFrame := tmp.(*RoomDownsyncFrame)
 						pR.sendSafely(refRenderFrame, toSendInputFrames, DOWNSYNC_MSG_ACT_FORCED_RESYNC, playerId)
 					} else {
 						pR.sendSafely(nil, toSendInputFrames, DOWNSYNC_MSG_ACT_INPUT_BATCH, playerId)
@@ -553,24 +553,40 @@ func (pR *Room) StartBattle() {
 				}
 			}
 
-			// Evict no longer required "RenderFrameBuffer"
-			for pR.RenderFrameBuffer.N < pR.RenderFrameBuffer.Cnt || (0 < pR.RenderFrameBuffer.Cnt && pR.RenderFrameBuffer.StFrameId < refRenderFrameId) {
-				_ = pR.RenderFrameBuffer.Pop()
+			if pR.BackendDynamicsEnabled {
+				// Evict no longer required "RenderFrameBuffer"
+				for pR.RenderFrameBuffer.N < pR.RenderFrameBuffer.Cnt || (0 < pR.RenderFrameBuffer.Cnt && pR.RenderFrameBuffer.StFrameId < refRenderFrameId) {
+					_ = pR.RenderFrameBuffer.Pop()
+				}
 			}
 
 			toApplyInputFrameId := pR.ConvertToInputFrameId(refRenderFrameId, pR.InputDelayFrames)
+			/*
+			   [WARNING]
+			   The following updates to "toApplyInputFrameId" is necessary because when "false == pR.BackendDynamicsEnabled", the variable "refRenderFrameId" is not well defined.
+			*/
+			minLastSentInputFrameId := int32(math.MaxInt32)
+			for _, player := range pR.Players {
+				if player.LastSentInputFrameId >= minLastSentInputFrameId {
+					continue
+				}
+				minLastSentInputFrameId = player.LastSentInputFrameId
+			}
+			if minLastSentInputFrameId < toApplyInputFrameId {
+				toApplyInputFrameId = minLastSentInputFrameId
+			}
 			for pR.InputsBuffer.N < pR.InputsBuffer.Cnt || (0 < pR.InputsBuffer.Cnt && pR.InputsBuffer.StFrameId < toApplyInputFrameId) {
-				f := pR.InputsBuffer.Pop().(*pb.InputFrameDownsync)
+				f := pR.InputsBuffer.Pop().(*InputFrameDownsync)
 				if pR.inputFrameIdDebuggable(f.InputFrameId) {
 					// Popping of an "inputFrame" would be AFTER its being all being confirmed, because it requires the "inputFrame" to be all acked
-					Logger.Debug("inputFrame lifecycle#4[popped]:", zap.Any("roomId", pR.Id), zap.Any("inputFrameId", f.InputFrameId), zap.Any("InputsBuffer", pR.InputsBufferString(false)))
+					Logger.Debug("inputFrame lifecycle#4[popped]:", zap.Any("roomId", pR.Id), zap.Any("inputFrameId", f.InputFrameId), zap.Any("toApplyInputFrameId", toApplyInputFrameId), zap.Any("InputsBuffer", pR.InputsBufferString(false)))
 				}
 			}
 
 			pR.RenderFrameId++
 			elapsedInCalculation := (utils.UnixtimeNano() - stCalculation)
 			if elapsedInCalculation > nanosPerFrame {
-				Logger.Warn(fmt.Sprintf("SLOW FRAME! Elapsed time statistics: roomId=%v, room.RenderFrameId=%v, elapsedInCalculation=%v, dynamicsDuration=%v, nanosPerFrame=%v", pR.Id, pR.RenderFrameId, elapsedInCalculation, dynamicsDuration, nanosPerFrame))
+				Logger.Warn(fmt.Sprintf("SLOW FRAME! Elapsed time statistics: roomId=%v, room.RenderFrameId=%v, elapsedInCalculation=%v ns, dynamicsDuration=%v ns, expected nanosPerFrame=%v", pR.Id, pR.RenderFrameId, elapsedInCalculation, dynamicsDuration, nanosPerFrame))
 			}
 			time.Sleep(time.Duration(nanosPerFrame - elapsedInCalculation))
 		}
@@ -586,7 +602,7 @@ func (pR *Room) toDiscreteInputsBufferIndex(inputFrameId int32, joinIndex int32)
 	return (inputFrameId << 2) + joinIndex // allowing joinIndex upto 15
 }
 
-func (pR *Room) OnBattleCmdReceived(pReq *pb.WsReq) {
+func (pR *Room) OnBattleCmdReceived(pReq *WsReq) {
 	if swapped := atomic.CompareAndSwapInt32(&pR.State, RoomBattleStateIns.IN_BATTLE, RoomBattleStateIns.IN_BATTLE); !swapped {
 		return
 	}
@@ -624,7 +640,7 @@ func (pR *Room) OnBattleCmdReceived(pReq *pb.WsReq) {
 	}
 }
 
-func (pR *Room) onInputFrameDownsyncAllConfirmed(inputFrameDownsync *pb.InputFrameDownsync, playerId int32) {
+func (pR *Room) onInputFrameDownsyncAllConfirmed(inputFrameDownsync *InputFrameDownsync, playerId int32) {
 	inputFrameId := inputFrameDownsync.InputFrameId
 	if -1 == pR.LastAllConfirmedInputFrameIdWithChange || false == pR.equalInputLists(inputFrameDownsync.InputList, pR.LastAllConfirmedInputList) {
 		if -1 == playerId {
@@ -666,7 +682,7 @@ func (pR *Room) StopBattleForSettlement() {
 	Logger.Info("Stopping the `battleMainLoop` for:", zap.Any("roomId", pR.Id))
 	pR.RenderFrameId++
 	for playerId, _ := range pR.Players {
-		assembledFrame := pb.RoomDownsyncFrame{
+		assembledFrame := RoomDownsyncFrame{
 			Id:             pR.RenderFrameId,
 			Players:        toPbPlayers(pR.Players),
 			CountdownNanos: -1, // TODO: Replace this magic constant!
@@ -692,18 +708,19 @@ func (pR *Room) onBattlePrepare(cb BattleStartCbType) {
 	pR.State = RoomBattleStateIns.PREPARE
 	Logger.Info("Battle state transitted to RoomBattleStateIns.PREPARE for:", zap.Any("roomId", pR.Id))
 
-	playerMetas := make(map[int32]*pb.PlayerMeta, 0)
+	playerMetas := make(map[int32]*PlayerDownsyncMeta, 0)
 	for _, player := range pR.Players {
-		playerMetas[player.Id] = &pb.PlayerMeta{
-			Id:          player.Id,
-			Name:        player.Name,
-			DisplayName: player.DisplayName,
-			Avatar:      player.Avatar,
-			JoinIndex:   player.JoinIndex,
+		playerMetas[player.Id] = &PlayerDownsyncMeta{
+			Id:             player.Id,
+			Name:           player.Name,
+			DisplayName:    player.DisplayName,
+			Avatar:         player.Avatar,
+			ColliderRadius: player.ColliderRadius, // hardcoded for now
+			JoinIndex:      player.JoinIndex,
 		}
 	}
 
-	battleReadyToStartFrame := &pb.RoomDownsyncFrame{
+	battleReadyToStartFrame := &RoomDownsyncFrame{
 		Id:             DOWNSYNC_MSG_ACT_BATTLE_READY_TO_START,
 		Players:        toPbPlayers(pR.Players),
 		PlayerMetas:    playerMetas,
@@ -773,6 +790,9 @@ func (pR *Room) Dismiss() {
 func (pR *Room) OnDismissed() {
 
 	// Always instantiates new HeapRAM blocks and let the old blocks die out due to not being retained by any root reference.
+	pR.WorldToVirtualGridRatio = float64(1000)
+	pR.VirtualGridToWorldRatio = float64(1.0) / pR.WorldToVirtualGridRatio // this is a one-off computation, should avoid division in iterations
+	pR.PlayerDefaultSpeed = int32(float64(2) * pR.WorldToVirtualGridRatio) // in virtual grids per frame
 	pR.Players = make(map[int32]*Player)
 	pR.PlayersArr = make([]*Player, pR.Capacity)
 	pR.CollisionSysMap = make(map[int32]*resolv.Object)
@@ -794,13 +814,14 @@ func (pR *Room) OnDismissed() {
 	pR.NstDelayFrames = 8
 	pR.InputScaleFrames = uint32(2)
 	pR.ServerFps = 60
-	pR.RollbackEstimatedDt = 0.016667      // Use fixed-and-low-precision to mitigate the inconsistent floating-point-number issue between Golang and JavaScript
 	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 preventing FAST FRAME
 	pR.BattleDurationFrames = 30 * pR.ServerFps
 	pR.BattleDurationNanos = int64(pR.BattleDurationFrames) * (pR.RollbackEstimatedDtNanos + 1)
 	pR.InputFrameUpsyncDelayTolerance = 2
-	pR.MaxChasingRenderFramesPerUpdate = 10
+	pR.MaxChasingRenderFramesPerUpdate = 5
+
+	pR.BackendDynamicsEnabled = true // [WARNING] When "false", recovery upon reconnection wouldn't work!
 
 	pR.ChooseStage()
 	pR.EffectivePlayerCount = 0
@@ -911,16 +932,15 @@ func (pR *Room) onPlayerAdded(playerId int32) {
 
 			// Lazily assign the initial position of "Player" for "RoomDownsyncFrame".
 			playerPosList := *(pR.RawBattleStrToVec2DListMap["PlayerStartingPos"])
-			if index > len(playerPosList) {
+			if index > len(playerPosList.Eles) {
 				panic(fmt.Sprintf("onPlayerAdded error, index >= len(playerPosList), roomId=%v, playerId=%v, roomState=%v, roomEffectivePlayerCount=%v", pR.Id, playerId, pR.State, pR.EffectivePlayerCount))
 			}
-			playerPos := playerPosList[index]
+			playerPos := playerPosList.Eles[index]
 
 			if nil == playerPos {
 				panic(fmt.Sprintf("onPlayerAdded error, nil == playerPos, roomId=%v, playerId=%v, roomState=%v, roomEffectivePlayerCount=%v", pR.Id, playerId, pR.State, pR.EffectivePlayerCount))
 			}
-			pR.Players[playerId].X = playerPos.X
-			pR.Players[playerId].Y = playerPos.Y
+			pR.Players[playerId].VirtualGridX, pR.Players[playerId].VirtualGridY = WorldToVirtualGridPos(playerPos.X, playerPos.Y, pR.WorldToVirtualGridRatio)
 
 			break
 		}
@@ -948,14 +968,15 @@ func (pR *Room) OnPlayerBattleColliderAcked(playerId int32) bool {
 		return false
 	}
 
-	playerMetas := make(map[int32]*pb.PlayerMeta, 0)
+	playerMetas := make(map[int32]*PlayerDownsyncMeta, 0)
 	for _, eachPlayer := range pR.Players {
-		playerMetas[eachPlayer.Id] = &pb.PlayerMeta{
-			Id:          eachPlayer.Id,
-			Name:        eachPlayer.Name,
-			DisplayName: eachPlayer.DisplayName,
-			Avatar:      eachPlayer.Avatar,
-			JoinIndex:   eachPlayer.JoinIndex,
+		playerMetas[eachPlayer.Id] = &PlayerDownsyncMeta{
+			Id:             eachPlayer.Id,
+			Name:           eachPlayer.Name,
+			DisplayName:    eachPlayer.DisplayName,
+			Avatar:         eachPlayer.Avatar,
+			JoinIndex:      eachPlayer.JoinIndex,
+			ColliderRadius: eachPlayer.ColliderRadius,
 		}
 	}
 
@@ -971,14 +992,14 @@ func (pR *Room) OnPlayerBattleColliderAcked(playerId int32) bool {
 		*/
 		switch targetPlayer.BattleState {
 		case PlayerBattleStateIns.ADDED_PENDING_BATTLE_COLLIDER_ACK:
-			playerAckedFrame := &pb.RoomDownsyncFrame{
+			playerAckedFrame := &RoomDownsyncFrame{
 				Id:          pR.RenderFrameId,
 				Players:     toPbPlayers(pR.Players),
 				PlayerMetas: playerMetas,
 			}
 			pR.sendSafely(playerAckedFrame, nil, DOWNSYNC_MSG_ACT_PLAYER_ADDED_AND_ACKED, eachPlayer.Id)
 		case PlayerBattleStateIns.READDED_PENDING_BATTLE_COLLIDER_ACK:
-			playerAckedFrame := &pb.RoomDownsyncFrame{
+			playerAckedFrame := &RoomDownsyncFrame{
 				Id:          pR.RenderFrameId,
 				Players:     toPbPlayers(pR.Players),
 				PlayerMetas: playerMetas,
@@ -1009,14 +1030,14 @@ func (pR *Room) OnPlayerBattleColliderAcked(playerId int32) bool {
 	return true
 }
 
-func (pR *Room) sendSafely(roomDownsyncFrame *pb.RoomDownsyncFrame, toSendFrames []*pb.InputFrameDownsync, act int32, playerId int32) {
+func (pR *Room) sendSafely(roomDownsyncFrame *RoomDownsyncFrame, toSendFrames []*InputFrameDownsync, act int32, playerId int32) {
 	defer func() {
 		if r := recover(); r != nil {
 			pR.PlayerSignalToCloseDict[playerId](Constants.RetCode.UnknownError, fmt.Sprintf("%v", r))
 		}
 	}()
 
-	pResp := &pb.WsResp{
+	pResp := &WsResp{
 		Ret:                     int32(Constants.RetCode.Ok),
 		Act:                     act,
 		Rdf:                     roomDownsyncFrame,
@@ -1037,16 +1058,16 @@ func (pR *Room) shouldPrefabInputFrameDownsync(renderFrameId int32) bool {
 	return ((renderFrameId & ((1 << pR.InputScaleFrames) - 1)) == 0)
 }
 
-func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *pb.InputFrameDownsync {
+func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *InputFrameDownsync {
 	/*
 	   Kindly note that on backend the prefab is much simpler than its frontend counterpart, because frontend will upsync its latest command immediately if there's any change w.r.t. its own prev cmd, thus if no upsync received from a frontend,
 	   - EITHER it's due to local lag and bad network,
 	   - OR there's no change w.r.t. to its prev cmd.
 	*/
-	var currInputFrameDownsync *pb.InputFrameDownsync = nil
+	var currInputFrameDownsync *InputFrameDownsync = nil
 
 	if 0 == inputFrameId && 0 == pR.InputsBuffer.Cnt {
-		currInputFrameDownsync = &pb.InputFrameDownsync{
+		currInputFrameDownsync = &InputFrameDownsync{
 			InputFrameId:  0,
 			InputList:     make([]uint64, pR.Capacity),
 			ConfirmedList: uint64(0),
@@ -1056,9 +1077,9 @@ func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *pb.InputFrameDowns
 		if nil == tmp {
 			panic(fmt.Sprintf("Error prefabbing inputFrameDownsync: roomId=%v, InputsBuffer=%v", pR.Id, pR.InputsBufferString(false)))
 		}
-		prevInputFrameDownsync := tmp.(*pb.InputFrameDownsync)
+		prevInputFrameDownsync := tmp.(*InputFrameDownsync)
 		currInputList := prevInputFrameDownsync.InputList // Would be a clone of the values
-		currInputFrameDownsync = &pb.InputFrameDownsync{
+		currInputFrameDownsync = &InputFrameDownsync{
 			InputFrameId:  inputFrameId,
 			InputList:     currInputList,
 			ConfirmedList: uint64(0),
@@ -1069,6 +1090,42 @@ func (pR *Room) prefabInputFrameDownsync(inputFrameId int32) *pb.InputFrameDowns
 	return currInputFrameDownsync
 }
 
+func (pR *Room) markConfirmationIfApplicable() {
+	inputFrameId1 := pR.LastAllConfirmedInputFrameId + 1
+	gap := int32(4) // This value is hardcoded and doesn't need be much bigger, because the backend side is supposed to never lag when "false == BackendDynamicsEnabled".
+	inputFrameId2 := inputFrameId1 + gap
+	if inputFrameId2 > pR.InputsBuffer.EdFrameId {
+		inputFrameId2 = pR.InputsBuffer.EdFrameId
+	}
+
+	totPlayerCnt := uint32(pR.Capacity)
+	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
+	for inputFrameId := inputFrameId1; inputFrameId < inputFrameId2; inputFrameId++ {
+		tmp := pR.InputsBuffer.GetByFrameId(inputFrameId)
+		if nil == tmp {
+			panic(fmt.Sprintf("inputFrameId=%v doesn't exist for roomId=%v, this is abnormal because the server should prefab inputFrameDownsync in a most advanced pace, check the prefab logic! InputsBuffer=%v", inputFrameId, pR.Id, pR.InputsBufferString(false)))
+		}
+		inputFrameDownsync := tmp.(*InputFrameDownsync)
+		for _, player := range pR.Players {
+			bufIndex := pR.toDiscreteInputsBufferIndex(inputFrameId, player.JoinIndex)
+			tmp, loaded := pR.DiscreteInputsBuffer.LoadAndDelete(bufIndex) // It's safe to "LoadAndDelete" here because the "inputFrameUpsync" of this player is already remembered by the corresponding "inputFrameDown".
+			if !loaded {
+				continue
+			}
+			inputFrameUpsync := tmp.(*InputFrameUpsync)
+			indiceInJoinIndexBooleanArr := uint32(player.JoinIndex - 1)
+			inputFrameDownsync.InputList[indiceInJoinIndexBooleanArr] = pR.EncodeUpsyncCmd(inputFrameUpsync)
+			inputFrameDownsync.ConfirmedList |= (1 << indiceInJoinIndexBooleanArr)
+		}
+
+		if allConfirmedMask == inputFrameDownsync.ConfirmedList {
+			pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
+		} else {
+			break
+		}
+	}
+}
+
 func (pR *Room) forceConfirmationIfApplicable() uint64 {
 	// 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
 	renderFrameId1 := (pR.RenderFrameId - pR.NstDelayFrames) // the renderFrameId which should've been rendered on frontend
@@ -1091,24 +1148,12 @@ func (pR *Room) forceConfirmationIfApplicable() uint64 {
 	if nil == tmp {
 		panic(fmt.Sprintf("inputFrameId2=%v doesn't exist for roomId=%v, this is abnormal because the server should prefab inputFrameDownsync in a most advanced pace, check the prefab logic! InputsBuffer=%v", inputFrameId2, pR.Id, pR.InputsBufferString(false)))
 	}
-	inputFrame2 := tmp.(*pb.InputFrameDownsync)
-	for _, player := range pR.Players {
-		// Enrich by already arrived player upsync commands
-		bufIndex := pR.toDiscreteInputsBufferIndex(inputFrame2.InputFrameId, player.JoinIndex)
-		tmp, loaded := pR.DiscreteInputsBuffer.LoadAndDelete(bufIndex)
-		if !loaded {
-			continue
-		}
-		inputFrameUpsync := tmp.(*pb.InputFrameUpsync)
-		indiceInJoinIndexBooleanArr := uint32(player.JoinIndex - 1)
-		inputFrame2.InputList[indiceInJoinIndexBooleanArr] = pR.EncodeUpsyncCmd(inputFrameUpsync)
-		inputFrame2.ConfirmedList |= (1 << indiceInJoinIndexBooleanArr)
-	}
 
 	totPlayerCnt := uint32(pR.Capacity)
 	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
 
 	// Force confirmation of "inputFrame2"
+	inputFrame2 := tmp.(*InputFrameDownsync)
 	oldConfirmedList := inputFrame2.ConfirmedList
 	unconfirmedMask := (oldConfirmedList ^ allConfirmedMask)
 	inputFrame2.ConfirmedList = allConfirmedMask
@@ -1117,7 +1162,7 @@ func (pR *Room) forceConfirmationIfApplicable() uint64 {
 	return unconfirmedMask
 }
 
-func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRenderFrameId int32) {
+func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRenderFrameId int32, spaceOffsetX, spaceOffsetY float64) {
 	if fromRenderFrameId >= toRenderFrameId {
 		return
 	}
@@ -1127,7 +1172,13 @@ func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRende
 	allConfirmedMask := uint64((1 << totPlayerCnt) - 1)
 
 	for collisionSysRenderFrameId := fromRenderFrameId; collisionSysRenderFrameId < toRenderFrameId; collisionSysRenderFrameId++ {
+		currRenderFrameTmp := pR.RenderFrameBuffer.GetByFrameId(collisionSysRenderFrameId)
+		if nil == currRenderFrameTmp {
+			panic(fmt.Sprintf("collisionSysRenderFrameId=%v doesn't exist for roomId=%v, this is abnormal because it's to be used for applying dynamics to [fromRenderFrameId:%v, toRenderFrameId:%v)! RenderFrameBuffer=%v", collisionSysRenderFrameId, pR.Id, fromRenderFrameId, toRenderFrameId, pR.RenderFrameBufferString()))
+		}
+		currRenderFrame := currRenderFrameTmp.(*RoomDownsyncFrame)
 		delayedInputFrameId := pR.ConvertToInputFrameId(collisionSysRenderFrameId, pR.InputDelayFrames)
+		var delayedInputFrame *InputFrameDownsync = nil
 		if 0 <= delayedInputFrameId {
 			if delayedInputFrameId > pR.LastAllConfirmedInputFrameId {
 				panic(fmt.Sprintf("delayedInputFrameId=%v is not yet all-confirmed for roomId=%v, this is abnormal because it's to be used for applying dynamics to [fromRenderFrameId:%v, toRenderFrameId:%v) @ collisionSysRenderFrameId=%v! InputsBuffer=%v", delayedInputFrameId, pR.Id, fromRenderFrameId, toRenderFrameId, collisionSysRenderFrameId, pR.InputsBufferString(false)))
@@ -1136,76 +1187,126 @@ func (pR *Room) applyInputFrameDownsyncDynamics(fromRenderFrameId int32, toRende
 			if nil == tmp {
 				panic(fmt.Sprintf("delayedInputFrameId=%v doesn't exist for roomId=%v, this is abnormal because it's to be used for applying dynamics to [fromRenderFrameId:%v, toRenderFrameId:%v) @ collisionSysRenderFrameId=%v! InputsBuffer=%v", delayedInputFrameId, pR.Id, fromRenderFrameId, toRenderFrameId, collisionSysRenderFrameId, pR.InputsBufferString(false)))
 			}
-			delayedInputFrame := tmp.(*pb.InputFrameDownsync)
+			delayedInputFrame = tmp.(*InputFrameDownsync)
 			// [WARNING] It's possible that by now "allConfirmedMask != delayedInputFrame.ConfirmedList && delayedInputFrameId <= pR.LastAllConfirmedInputFrameId", we trust "pR.LastAllConfirmedInputFrameId" as the TOP AUTHORITY.
 			atomic.StoreUint64(&(delayedInputFrame.ConfirmedList), allConfirmedMask)
+		}
 
-			inputList := delayedInputFrame.InputList
-			// Ordered by joinIndex to guarantee determinism
-			for _, player := range pR.PlayersArr {
-				joinIndex := player.JoinIndex
-				encodedInput := inputList[joinIndex-1]
-				decodedInput := DIRECTION_DECODER[encodedInput]
-				decodedInputSpeedFactor := DIRECTION_DECODER_INVERSE_LENGTH[encodedInput]
-				if 0.0 == decodedInputSpeedFactor {
-					continue
-				}
-				baseChange := player.Speed * pR.RollbackEstimatedDt * decodedInputSpeedFactor
-				dx := baseChange * float64(decodedInput[0])
-				dy := baseChange * float64(decodedInput[1])
+		nextRenderFrame := pR.applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame, currRenderFrame, pR.CollisionSysMap)
+		// Update in the latest player pointers
+		for playerId, playerDownsync := range nextRenderFrame.Players {
+			pR.Players[playerId].VirtualGridX = playerDownsync.VirtualGridX
+			pR.Players[playerId].VirtualGridY = playerDownsync.VirtualGridY
+			pR.Players[playerId].Dir.Dx = playerDownsync.Dir.Dx
+			pR.Players[playerId].Dir.Dy = playerDownsync.Dir.Dy
+		}
+		pR.RenderFrameBuffer.Put(nextRenderFrame)
+		pR.CurDynamicsRenderFrameId++
+	}
+}
 
-				collisionPlayerIndex := COLLISION_PLAYER_INDEX_PREFIX + joinIndex
-				playerCollider := pR.CollisionSysMap[collisionPlayerIndex]
-				if collision := playerCollider.Check(dx, dy, "Barrier"); collision != nil {
-					changeWithCollision := collision.ContactWithObject(collision.Objects[0])
-					Logger.Info(fmt.Sprintf("Collided: roomId=%v, playerId=%v, orig dx=%v, orig dy=%v, proposed new dx =%v, proposed new dy=%v", pR.Id, player.Id, dx, dy, changeWithCollision.X(), changeWithCollision.Y()))
-                    // FIXME: Use a mechanism equivalent to that of the frontend!
-					// dx = changeWithCollision.X()
-					// dy = changeWithCollision.Y()
-					dx = 0
-					dy = 0
-				}
-				playerCollider.X += dx
-				playerCollider.Y += dy
-				// Update in "collision space"
-				playerCollider.Update()
+// TODO: Write unit-test for this function to compare with its frontend counter part
+func (pR *Room) applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame *InputFrameDownsync, currRenderFrame *RoomDownsyncFrame, collisionSysMap map[int32]*resolv.Object) *RoomDownsyncFrame {
+	nextRenderFramePlayers := make(map[int32]*PlayerDownsync, pR.Capacity)
+	// Make a copy first
+	for playerId, currPlayerDownsync := range currRenderFrame.Players {
+		nextRenderFramePlayers[playerId] = &PlayerDownsync{
+			Id:           playerId,
+			VirtualGridX: currPlayerDownsync.VirtualGridX,
+			VirtualGridY: currPlayerDownsync.VirtualGridY,
+			Dir: &Direction{
+				Dx: currPlayerDownsync.Dir.Dx,
+				Dy: currPlayerDownsync.Dir.Dy,
+			},
+			Speed:       currPlayerDownsync.Speed,
+			BattleState: currPlayerDownsync.BattleState,
+			Score:       currPlayerDownsync.Score,
+			Removed:     currPlayerDownsync.Removed,
+			JoinIndex:   currPlayerDownsync.JoinIndex,
+		}
+	}
 
-				player.Dir.Dx = decodedInput[0]
-				player.Dir.Dy = decodedInput[1]
-				player.X += dx
-				player.Y += dy
+	toRet := &RoomDownsyncFrame{
+		Id:             currRenderFrame.Id + 1,
+		Players:        nextRenderFramePlayers,
+		CountdownNanos: (pR.BattleDurationNanos - int64(currRenderFrame.Id)*pR.RollbackEstimatedDtNanos),
+	}
+
+	if nil != delayedInputFrame {
+		inputList := delayedInputFrame.InputList
+		effPushbacks := make([]Vec2D, pR.Capacity) // Guaranteed determinism regardless of traversal order
+		for playerId, player := range pR.Players {
+			joinIndex := player.JoinIndex
+			effPushbacks[joinIndex-1].X, effPushbacks[joinIndex-1].Y = float64(0), float64(0)
+			currPlayerDownsync := currRenderFrame.Players[playerId]
+			encodedInput := inputList[joinIndex-1]
+			decodedInput := DIRECTION_DECODER[encodedInput]
+			proposedVirtualGridDx, proposedVirtualGridDy := (decodedInput[0] + decodedInput[0]*currPlayerDownsync.Speed), (decodedInput[1] + decodedInput[1]*currPlayerDownsync.Speed)
+			newVx, newVy := (currPlayerDownsync.VirtualGridX + proposedVirtualGridDx), (currPlayerDownsync.VirtualGridY + proposedVirtualGridDy)
+			// Reset playerCollider position from the "virtual grid position"
+			collisionPlayerIndex := COLLISION_PLAYER_INDEX_PREFIX + joinIndex
+			playerCollider := collisionSysMap[collisionPlayerIndex]
+			playerCollider.X, playerCollider.Y = VirtualGridToPolygonColliderAnchorPos(newVx, newVy, player.ColliderRadius, player.ColliderRadius, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY, pR.VirtualGridToWorldRatio)
+
+			// Update in the collision system
+			playerCollider.Update()
+
+			if 0 < encodedInput {
+				Logger.Debug(fmt.Sprintf("Checking collision for playerId=%v: virtual (%d, %d) -> (%d, %d), now playerShape=%v", playerId, currPlayerDownsync.VirtualGridX, currPlayerDownsync.VirtualGridY, newVx, newVy, ConvexPolygonStr(playerCollider.Shape.(*resolv.ConvexPolygon))))
+				nextRenderFramePlayers[playerId].Dir.Dx = decodedInput[0]
+				nextRenderFramePlayers[playerId].Dir.Dy = decodedInput[1]
 			}
 		}
 
-		newRenderFrame := pb.RoomDownsyncFrame{
-			Id:             collisionSysRenderFrameId + 1,
-			Players:        toPbPlayers(pR.Players),
-			CountdownNanos: (pR.BattleDurationNanos - int64(collisionSysRenderFrameId)*pR.RollbackEstimatedDtNanos),
+		// handle pushbacks upon collision after all movements treated as simultaneous
+		for _, player := range pR.Players {
+			joinIndex := player.JoinIndex
+			collisionPlayerIndex := COLLISION_PLAYER_INDEX_PREFIX + joinIndex
+			playerCollider := collisionSysMap[collisionPlayerIndex]
+			if collision := playerCollider.Check(0, 0); collision != nil {
+				playerShape := playerCollider.Shape.(*resolv.ConvexPolygon)
+				for _, obj := range collision.Objects {
+					barrierShape := obj.Shape.(*resolv.ConvexPolygon)
+					if overlapped, pushbackX, pushbackY, overlapResult := CalcPushbacks(0, 0, playerShape, barrierShape); overlapped {
+						Logger.Debug(fmt.Sprintf("Overlapped: a=%v, b=%v, pushbackX=%v, pushbackY=%v", ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), pushbackX, pushbackY))
+						effPushbacks[joinIndex-1].X += pushbackX
+						effPushbacks[joinIndex-1].Y += pushbackY
+					} else {
+						Logger.Debug(fmt.Sprintf("Collided BUT not overlapped: a=%v, b=%v, overlapResult=%v", ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), overlapResult))
+					}
+				}
+			}
 		}
-		pR.RenderFrameBuffer.Put(&newRenderFrame)
-		pR.CurDynamicsRenderFrameId++
+
+		for playerId, player := range pR.Players {
+			joinIndex := player.JoinIndex
+			collisionPlayerIndex := COLLISION_PLAYER_INDEX_PREFIX + joinIndex
+			playerCollider := collisionSysMap[collisionPlayerIndex]
+
+			// Update "virtual grid position"
+			newVx, newVy := PolygonColliderAnchorToVirtualGridPos(playerCollider.X-effPushbacks[joinIndex-1].X, playerCollider.Y-effPushbacks[joinIndex-1].Y, player.ColliderRadius, player.ColliderRadius, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY, pR.WorldToVirtualGridRatio)
+			nextRenderFramePlayers[playerId].VirtualGridX = newVx
+			nextRenderFramePlayers[playerId].VirtualGridY = newVy
+		}
+
+		Logger.Debug(fmt.Sprintf("After applyInputFrameDownsyncDynamicsOnSingleRenderFrame: currRenderFrame.Id=%v, inputList=%v, currRenderFrame.Players=%v, nextRenderFramePlayers=%v, toRet.Players=%v", currRenderFrame.Id, inputList, currRenderFrame.Players, nextRenderFramePlayers, toRet.Players))
 	}
+
+	return toRet
 }
 
 func (pR *Room) inputFrameIdDebuggable(inputFrameId int32) bool {
 	return 0 == (inputFrameId % 10)
 }
 
-func (pR *Room) refreshColliders() {
-	playerColliderRadius := float64(12) // hardcoded
+func (pR *Room) refreshColliders(spaceW, spaceH int32) {
 	// Kindly note that by now, we've already got all the shapes in the tmx file into "pR.(Players | Barriers)" from "ParseTmxLayersAndGroups"
-	spaceW := pR.StageDiscreteW * pR.StageTileW
-	spaceH := pR.StageDiscreteH * pR.StageTileH
 
-	spaceOffsetX := float64(spaceW) * 0.5
-	spaceOffsetY := float64(spaceH) * 0.5
-
-    minStep := int(3) // the approx minimum distance a player can move per frame
-	space := resolv.NewSpace(int(spaceW), int(spaceH), minStep, minStep) // allocate a new collision space everytime after a battle is settled
+	minStep := (int(float64(pR.PlayerDefaultSpeed)*pR.VirtualGridToWorldRatio) << 2) // the approx minimum distance a player can move per frame in world coordinate
+	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 {
-		playerCollider := resolv.NewObject(player.X+spaceOffsetX, player.Y+spaceOffsetY, playerColliderRadius*2, playerColliderRadius*2)
-		playerColliderShape := resolv.NewCircle(0, 0, playerColliderRadius*2)
-		playerCollider.SetShape(playerColliderShape)
+		wx, wy := VirtualGridToWorldPos(player.VirtualGridX, player.VirtualGridY, pR.VirtualGridToWorldRatio)
+		playerCollider := GenerateRectCollider(wx, wy, player.ColliderRadius*2, player.ColliderRadius*2, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY, "Player")
 		space.Add(playerCollider)
 		// Keep track of the collider in "pR.CollisionSysMap"
 		joinIndex := player.JoinIndex
@@ -1215,31 +1316,8 @@ func (pR *Room) refreshColliders() {
 	}
 
 	for _, barrier := range pR.Barriers {
-
-		var w float64 = 0
-		var h float64 = 0
-
-		for i, pi := range barrier.Boundary.Points {
-			for j, pj := range barrier.Boundary.Points {
-				if i == j {
-					continue
-				}
-				if math.Abs(pj.X-pi.X) > w {
-					w = math.Abs(pj.X - pi.X)
-				}
-				if math.Abs(pj.Y-pi.Y) > h {
-					h = math.Abs(pj.Y - pi.Y)
-				}
-			}
-		}
-
-		barrierColliderShape := resolv.NewConvexPolygon()
-		for _, p := range barrier.Boundary.Points {
-			barrierColliderShape.AddPoints(p.X, p.Y)
-		}
-
-		barrierCollider := resolv.NewObject(barrier.Boundary.Anchor.X+spaceOffsetX, barrier.Boundary.Anchor.Y+spaceOffsetY, w, h, "Barrier")
-		barrierCollider.SetShape(barrierColliderShape)
+		boundaryUnaligned := barrier.Boundary
+		barrierCollider := GenerateConvexPolygonCollider(boundaryUnaligned, pR.collisionSpaceOffsetX, pR.collisionSpaceOffsetY, "Barrier")
 		space.Add(barrierCollider)
 	}
 }

battle_srv/storage/mysql_manager.go

@@ -1,7 +1,7 @@
 package storage
 
 import (
-	. "server/common"
+	. "battle_srv/common"
 
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/jmoiron/sqlx"

battle_srv/storage/redis_manager.go

@@ -1,8 +1,8 @@
 package storage
 
 import (
+	. "battle_srv/common"
 	"fmt"
-	. "server/common"
 
 	"github.com/go-redis/redis"
 	_ "github.com/go-sql-driver/mysql"

battle_srv/ws/serve.go

@@ -1,6 +1,9 @@
 package ws
 
 import (
+	. "battle_srv/common"
+	"battle_srv/models"
+	pb "battle_srv/protos"
 	"container/heap"
 	"fmt"
 	"github.com/gin-gonic/gin"
@@ -8,14 +11,12 @@ import (
 	"github.com/gorilla/websocket"
 	"go.uber.org/zap"
 	"net/http"
-	. "server/common"
-	"server/models"
-	pb "server/pb_output"
 	"strconv"
 	"sync/atomic"
 	"time"
 
 	. "dnmshared"
+	"runtime/debug"
 )
 
 const (
@@ -104,7 +105,7 @@ func Serve(c *gin.Context) {
 		}
 		defer func() {
 			if r := recover(); r != nil {
-				Logger.Warn("Recovered from: ", zap.Any("panic", r))
+				Logger.Error("Recovered from: ", zap.Any("panic", r))
 			}
 		}()
 		/**
@@ -246,8 +247,8 @@ func Serve(c *gin.Context) {
 		bciFrame := &pb.BattleColliderInfo{
 			BoundRoomId:           pRoom.Id,
 			StageName:             pRoom.StageName,
-			StrToVec2DListMap:     models.ToPbVec2DListMap(pRoom.RawBattleStrToVec2DListMap),
-			StrToPolygon2DListMap: models.ToPbPolygon2DListMap(pRoom.RawBattleStrToPolygon2DListMap),
+			StrToVec2DListMap:     pRoom.RawBattleStrToVec2DListMap,
+			StrToPolygon2DListMap: pRoom.RawBattleStrToPolygon2DListMap,
 			StageDiscreteW:        pRoom.StageDiscreteW,
 			StageDiscreteH:        pRoom.StageDiscreteH,
 			StageTileW:            pRoom.StageTileW,
@@ -263,9 +264,11 @@ func Serve(c *gin.Context) {
 			InputFrameUpsyncDelayTolerance:  pRoom.InputFrameUpsyncDelayTolerance,
 			MaxChasingRenderFramesPerUpdate: pRoom.MaxChasingRenderFramesPerUpdate,
 			PlayerBattleState:               pThePlayer.BattleState, // For frontend to know whether it's rejoining
-			RollbackEstimatedDt:             pRoom.RollbackEstimatedDt,
 			RollbackEstimatedDtMillis:       pRoom.RollbackEstimatedDtMillis,
 			RollbackEstimatedDtNanos:        pRoom.RollbackEstimatedDtNanos,
+
+			WorldToVirtualGridRatio: pRoom.WorldToVirtualGridRatio,
+			VirtualGridToWorldRatio: pRoom.VirtualGridToWorldRatio,
 		}
 
 		resp := &pb.WsResp{
@@ -354,7 +357,7 @@ func Serve(c *gin.Context) {
 	receivingLoopAgainstPlayer := func() error {
 		defer func() {
 			if r := recover(); r != nil {
-				Logger.Warn("Goroutine `receivingLoopAgainstPlayer`, recovery spot#1, recovered from: ", zap.Any("panic", r))
+				Logger.Error("Goroutine `receivingLoopAgainstPlayer`, recovery spot#1, recovered from: ", zap.Any("panic", r), zap.Any("callstack", debug.Stack()))
 			}
 			Logger.Info("Goroutine `receivingLoopAgainstPlayer` is stopped for:", zap.Any("playerId", playerId), zap.Any("roomId", pRoom.Id))
 		}()

charts/README.md

@@ -0,0 +1,4 @@
+# GIF creation cmd reference
+```
+ffmpeg -ss 12 -t 13 -i input.mp4 -vf "fps=10,scale=480:-1" -loop 0 output.gif
+```

collider_visualizer/go.mod

@@ -3,11 +3,11 @@ module viscol
 go 1.19
 
 require (
+	dnmshared v0.0.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/hajimehoshi/ebiten/v2 v2.4.7
 	github.com/solarlune/resolv v0.5.1
 	golang.org/x/image v0.0.0-20220902085622-e7cb96979f69
-	dnmshared v0.0.0
 )
 
 require (
@@ -22,6 +22,7 @@ require (
 	golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56 // indirect
 	golang.org/x/mobile v0.0.0-20220722155234-aaac322e2105 // indirect
 	golang.org/x/sys v0.0.0-20220818161305-2296e01440c6 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 )
 
 replace dnmshared => ../dnmshared

collider_visualizer/go.sum

@@ -7,6 +7,8 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20220806181222-55e207c401ad h1:kX51IjbsJP
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20220806181222-55e207c401ad/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/hajimehoshi/bitmapfont/v2 v2.2.1 h1:y7zcy02/UgO24IL3COqYtrRZzhRucNBtmCo/SNU648k=
 github.com/hajimehoshi/bitmapfont/v2 v2.2.1/go.mod h1:wjrYAy8vKgj9JsFgnYAOK346/uvE22TlmqouzdnYIs0=
 github.com/hajimehoshi/ebiten/v2 v2.4.7 h1:XuvB7R0Rbw/O7g6vNU8gqr5b9e7MNhhAONMSsyreLDI=
@@ -93,4 +95,8 @@ golang.org/x/tools v0.1.8-0.20211022200916-316ba0b74098/go.mod h1:LGqMHiF4EqQNHR
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=

collider_visualizer/main.go

@@ -85,8 +85,8 @@ type Game struct {
 
 func NewGame() *Game {
 
-	// stageName := "simple" // Use this for calibration
-	stageName := "richsoil"
+	stageName := "simple" // Use this for calibration
+	// stageName := "richsoil"
 	stageDiscreteW, stageDiscreteH, stageTileW, stageTileH, playerPosMap, barrierMap, err := parseStage(stageName)
 	if nil != err {
 		panic(err)
@@ -160,7 +160,6 @@ func (g *Game) DebugDraw(screen *ebiten.Image, space *resolv.Space) {
 			ebitenutil.DrawLine(screen, cx, cy+ch, cx, cy, drawColor)
 		}
 	}
-
 }
 
 func (g *Game) Layout(w, h int) (int, int) {

collider_visualizer/worldColliderDisplay.go

@@ -2,14 +2,12 @@ package main
 
 import (
 	. "dnmshared"
+	. "dnmshared/sharedprotos"
 	"fmt"
 	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
 	"github.com/solarlune/resolv"
 	"go.uber.org/zap"
 	"image/color"
-
-	"math"
 )
 
 type WorldColliderDisplay struct {
@@ -22,7 +20,7 @@ func (world *WorldColliderDisplay) Init() {
 
 func NewWorldColliderDisplay(game *Game, stageDiscreteW, stageDiscreteH, stageTileW, stageTileH int32, playerPosMap StrToVec2DListMap, barrierMap StrToPolygon2DListMap) *WorldColliderDisplay {
 
-	playerList := *(playerPosMap["PlayerStartingPos"])
+	playerPosList := *(playerPosMap["PlayerStartingPos"])
 	barrierList := *(barrierMap["Barrier"])
 
 	world := &WorldColliderDisplay{Game: game}
@@ -35,52 +33,58 @@ func NewWorldColliderDisplay(game *Game, stageDiscreteW, stageDiscreteH, stageTi
 	spaceOffsetX := float64(spaceW) * 0.5
 	spaceOffsetY := float64(spaceH) * 0.5
 
-	// TODO: Move collider y-axis transformation to a "dnmshared"
-	playerColliderRadius := float64(12) // hardcoded
-	space := resolv.NewSpace(int(spaceW), int(spaceH), 16, 16)
-	for _, player := range playerList {
-		playerCollider := resolv.NewObject(player.X+spaceOffsetX, player.Y+spaceOffsetY, playerColliderRadius*2, playerColliderRadius*2, "Player")
-		playerColliderShape := resolv.NewCircle(0, 0, playerColliderRadius*2)
-		playerCollider.SetShape(playerColliderShape)
+	virtualGridToWorldRatio := 0.1
+	playerDefaultSpeed := 20
+	minStep := (int(float64(playerDefaultSpeed)*virtualGridToWorldRatio) << 2)
+	playerColliderRadius := float64(24)
+	playerColliders := make([]*resolv.Object, len(playerPosList.Eles))
+	space := resolv.NewSpace(int(spaceW), int(spaceH), minStep, minStep)
+	for i, playerPos := range playerPosList.Eles {
+		playerCollider := GenerateRectCollider(playerPos.X, playerPos.Y, playerColliderRadius*2, playerColliderRadius*2, spaceOffsetX, spaceOffsetY, "Player") // [WARNING] Deliberately not using a circle because "resolv v0.5.1" doesn't yet align circle center with space cell center, regardless of the "specified within-object offset"
+		Logger.Info(fmt.Sprintf("Player Collider#%d: player world pos =(%.2f, %.2f), shape=%v", i, playerPos.X, playerPos.Y, ConvexPolygonStr(playerCollider.Shape.(*resolv.ConvexPolygon))))
+		playerColliders[i] = playerCollider
 		space.Add(playerCollider)
 	}
 
 	barrierLocalId := 0
-	for _, barrierUnaligned := range barrierList {
-        barrier := AlignPolygon2DToBoundingBox(barrierUnaligned)
-
-		var w float64 = 0
-		var h float64 = 0
-
-		for i, pi := range barrier.Points {
-			for j, pj := range barrier.Points {
-				if i == j {
-					continue
-				}
-				if math.Abs(pj.X-pi.X) > w {
-					w = math.Abs(pj.X - pi.X)
-				}
-				if math.Abs(pj.Y-pi.Y) > h {
-					h = math.Abs(pj.Y - pi.Y)
-				}
-			}
-		}
-
-		barrierColliderShape := resolv.NewConvexPolygon()
-		for i := 0; i < len(barrier.Points); i++ {
-			p := barrier.Points[i]
-			barrierColliderShape.AddPoints(p.X, p.Y)
-		}
-
-		barrierCollider := resolv.NewObject(barrier.Anchor.X+spaceOffsetX, barrier.Anchor.Y+spaceOffsetY, w, h, "Barrier")
-		barrierCollider.SetShape(barrierColliderShape)
-
+	for _, barrierUnaligned := range barrierList.Eles {
+		barrierCollider := GenerateConvexPolygonCollider(barrierUnaligned, spaceOffsetX, spaceOffsetY, "Barrier")
+		Logger.Info(fmt.Sprintf("Added barrier: shape=%v", ConvexPolygonStr(barrierCollider.Shape.(*resolv.ConvexPolygon))))
 		space.Add(barrierCollider)
-
 		barrierLocalId++
 	}
 
 	world.Space = space
+
+	moveToCollide := true
+	if moveToCollide {
+		newVx, newVy := int32(-2959), int32(-2261)
+		effPushback := Vec2D{X: float64(0), Y: float64(0)}
+		toTestPlayerCollider := playerColliders[0]
+		toTestPlayerCollider.X, toTestPlayerCollider.Y = VirtualGridToPolygonColliderAnchorPos(newVx, newVy, playerColliderRadius, playerColliderRadius, spaceOffsetX, spaceOffsetY, virtualGridToWorldRatio)
+
+		Logger.Info(fmt.Sprintf("Checking collision for virtual (%d, %d), now playerShape=%v", newVx, newVy, ConvexPolygonStr(toTestPlayerCollider.Shape.(*resolv.ConvexPolygon))))
+
+		toTestPlayerCollider.Update()
+		if collision := toTestPlayerCollider.Check(0, 0); collision != nil {
+			playerShape := toTestPlayerCollider.Shape.(*resolv.ConvexPolygon)
+			for _, obj := range collision.Objects {
+				barrierShape := obj.Shape.(*resolv.ConvexPolygon)
+				if overlapped, pushbackX, pushbackY, overlapResult := CalcPushbacks(0, 0, playerShape, barrierShape); overlapped {
+					Logger.Warn(fmt.Sprintf("Overlapped: a=%v, b=%v, pushbackX=%v, pushbackY=%v", ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), pushbackX, pushbackY))
+					effPushback.X += pushbackX
+					effPushback.Y += pushbackY
+				} else {
+					Logger.Warn(fmt.Sprintf("Collided BUT not overlapped: a=%v, b=%v, overlapResult=%v", ConvexPolygonStr(playerShape), ConvexPolygonStr(barrierShape), overlapResult))
+				}
+			}
+			toTestPlayerCollider.X -= effPushback.X
+			toTestPlayerCollider.Y -= effPushback.Y
+			toTestPlayerCollider.Update()
+			Logger.Info(fmt.Sprintf("effPushback={%v, %v}", effPushback.X, effPushback.Y))
+		}
+	}
+
 	return world
 }
 
@@ -92,9 +96,8 @@ func (world *WorldColliderDisplay) Draw(screen *ebiten.Image) {
 
 	for _, o := range world.Space.Objects() {
 		if o.HasTags("Player") {
-			circle := o.Shape.(*resolv.Circle)
 			drawColor := color.RGBA{0, 255, 0, 255}
-			ebitenutil.DrawCircle(screen, circle.X, circle.Y, circle.Radius, drawColor)
+			DrawPolygon(screen, o.Shape.(*resolv.ConvexPolygon), drawColor)
 		} else {
 			drawColor := color.RGBA{60, 60, 60, 255}
 			DrawPolygon(screen, o.Shape.(*resolv.ConvexPolygon), drawColor)

dnmshared/geometry.go

@@ -1,43 +1,46 @@
 package dnmshared
 
 import (
+	. "dnmshared/sharedprotos"
 	"math"
 )
 
-// Use type `float64` for json unmarshalling of numbers.
-type Direction struct {
-	Dx int32 `json:"dx,omitempty"`
-	Dy int32 `json:"dy,omitempty"`
+func NormVec2D(dx, dy float64) Vec2D {
+	return Vec2D{X: dy, Y: -dx}
 }
 
-type Vec2D struct {
-	X float64 `json:"x,omitempty"`
-	Y float64 `json:"y,omitempty"`
-}
+func AlignPolygon2DToBoundingBox(input *Polygon2D) *Polygon2D {
+	// Transform again to put "anchor" at the top-left point of the bounding box for "resolv"
+	boundingBoxTL := &Vec2D{
+		X: math.MaxFloat64,
+		Y: math.MaxFloat64,
+	}
+	for _, p := range input.Points {
+		if p.X < boundingBoxTL.X {
+			boundingBoxTL.X = p.X
+		}
+		if p.Y < boundingBoxTL.Y {
+			boundingBoxTL.Y = p.Y
+		}
+	}
 
-type Polygon2D struct {
-	Anchor *Vec2D   `json:"-"` // This "Polygon2D.Anchor" is used to be assigned to "B2BodyDef.Position", which in turn is used as the position of the FIRST POINT of the polygon.
-	Points []*Vec2D `json:"-"`
+	// Now "input.Anchor" should move to "input.Anchor+boundingBoxTL", thus "boundingBoxTL" is also the value of the negative diff for all "input.Points"
+	output := &Polygon2D{
+		Anchor: &Vec2D{
+			X: input.Anchor.X + boundingBoxTL.X,
+			Y: input.Anchor.Y + boundingBoxTL.Y,
+		},
+		Points: make([]*Vec2D, len(input.Points)),
+	}
 
-	/*
-	   When used to represent a "polyline directly drawn in a `Tmx file`", we can initialize both "Anchor" and "Points" simultaneously.
+	for i, p := range input.Points {
+		output.Points[i] = &Vec2D{
+			X: p.X - boundingBoxTL.X,
+			Y: p.Y - boundingBoxTL.Y,
+		}
+	}
 
-	   Yet when used to represent a "polyline drawn in a `Tsx file`", we have to first initialize "Points w.r.t. center of the tile-rectangle", and then "Anchor(initially nil) of the tile positioned in the `Tmx file`".
-
-	   Refer to https://shimo.im/docs/SmLJJhXm2C8XMzZT for more information.
-	*/
-
-	/*
-	  [WARNING] Used to cache "`TileWidth & TileHeight` of a Tsx file" only.
-	*/
-	TileWidth  int
-	TileHeight int
-
-	/*
-	  [WARNING] Used to cache "`Width & TileHeight` of an object in Tmx file" only.
-	*/
-	TmxObjectWidth  float64
-	TmxObjectHeight float64
+	return output
 }
 
 func Distance(pt1 *Vec2D, pt2 *Vec2D) float64 {

dnmshared/go.mod

@@ -1,3 +1,3 @@
-module tiled
+module dnmshared 
 
 go 1.19

dnmshared/resolv_helper.go

@@ -0,0 +1,255 @@
+package dnmshared
+
+import (
+	. "dnmshared/sharedprotos"
+	"fmt"
+	"github.com/kvartborg/vector"
+	"github.com/solarlune/resolv"
+	"math"
+	"strings"
+)
+
+func ConvexPolygonStr(body *resolv.ConvexPolygon) string {
+	var s []string = make([]string, len(body.Points))
+	for i, p := range body.Points {
+		s[i] = fmt.Sprintf("[%.2f, %.2f]", p[0]+body.X, p[1]+body.Y)
+	}
+
+	return fmt.Sprintf("{\n%s\n}", strings.Join(s, ",\n"))
+}
+
+func GenerateRectCollider(origX, origY, w, h, spaceOffsetX, spaceOffsetY float64, tag string) *resolv.Object {
+	cx, cy := WorldToPolygonColliderAnchorPos(origX, origY, w*0.5, h*0.5, spaceOffsetX, spaceOffsetY)
+	collider := resolv.NewObject(cx, cy, w, h, tag)
+	shape := resolv.NewRectangle(0, 0, w, h)
+	collider.SetShape(shape)
+	return collider
+}
+
+func GenerateConvexPolygonCollider(unalignedSrc *Polygon2D, spaceOffsetX, spaceOffsetY float64, tag string) *resolv.Object {
+	aligned := AlignPolygon2DToBoundingBox(unalignedSrc)
+	var w, h float64 = 0, 0
+
+	shape := resolv.NewConvexPolygon()
+	for i, pi := range aligned.Points {
+		for j, pj := range aligned.Points {
+			if i == j {
+				continue
+			}
+			if math.Abs(pj.X-pi.X) > w {
+				w = math.Abs(pj.X - pi.X)
+			}
+			if math.Abs(pj.Y-pi.Y) > h {
+				h = math.Abs(pj.Y - pi.Y)
+			}
+		}
+	}
+
+	for i := 0; i < len(aligned.Points); i++ {
+		p := aligned.Points[i]
+		shape.AddPoints(p.X, p.Y)
+	}
+
+	collider := resolv.NewObject(aligned.Anchor.X+spaceOffsetX, aligned.Anchor.Y+spaceOffsetY, w, h, tag)
+	collider.SetShape(shape)
+
+	return collider
+}
+
+func CalcPushbacks(oldDx, oldDy float64, playerShape, barrierShape *resolv.ConvexPolygon) (bool, float64, float64, *SatResult) {
+	origX, origY := playerShape.Position()
+	defer func() {
+		playerShape.SetPosition(origX, origY)
+	}()
+	playerShape.SetPosition(origX+oldDx, origY+oldDy)
+	overlapResult := &SatResult{
+		Overlap:       0,
+		OverlapX:      0,
+		OverlapY:      0,
+		AContainedInB: true,
+		BContainedInA: true,
+		Axis:          vector.Vector{0, 0},
+	}
+	if overlapped := IsPolygonPairOverlapped(playerShape, barrierShape, overlapResult); overlapped {
+		pushbackX, pushbackY := overlapResult.Overlap*overlapResult.OverlapX, overlapResult.Overlap*overlapResult.OverlapY
+		return true, pushbackX, pushbackY, overlapResult
+	} else {
+		return false, 0, 0, overlapResult
+	}
+}
+
+type SatResult struct {
+	Overlap       float64
+	OverlapX      float64
+	OverlapY      float64
+	AContainedInB bool
+	BContainedInA bool
+	Axis          vector.Vector
+}
+
+func IsPolygonPairOverlapped(a, b *resolv.ConvexPolygon, result *SatResult) bool {
+	aCnt, bCnt := len(a.Points), len(b.Points)
+	// Single point case
+	if 1 == aCnt && 1 == bCnt {
+		if nil != result {
+			result.Overlap = 0
+		}
+		return a.Points[0].X() == b.Points[0].X() && a.Points[0].Y() == b.Points[0].Y()
+	}
+
+	if 1 < aCnt {
+		for _, axis := range a.SATAxes() {
+			if isPolygonPairSeparatedByDir(a, b, axis.Unit(), result) {
+				return false
+			}
+		}
+	}
+
+	if 1 < bCnt {
+		for _, axis := range b.SATAxes() {
+			if isPolygonPairSeparatedByDir(a, b, axis.Unit(), result) {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+func isPolygonPairSeparatedByDir(a, b *resolv.ConvexPolygon, e vector.Vector, result *SatResult) bool {
+	/*
+		[WARNING] This function is deliberately made private, it shouldn't be used alone (i.e. not along the norms of a polygon), otherwise the pushbacks calculated would be meaningless.
+
+		Consider the following example
+		a: {
+			anchor: [1337.19 1696.74]
+			points: [[0 0] [24 0] [24 24] [0 24]]
+		},
+		b: {
+			anchor: [1277.72 1570.56]
+			points: [[642.57 319.16] [0 319.16] [5.73 0] [643.75 0.90]]
+		}
+
+		e = (-2.98, 1.49).Unit()
+	*/
+
+	var aStart, aEnd, bStart, bEnd float64 = math.MaxFloat64, -math.MaxFloat64, math.MaxFloat64, -math.MaxFloat64
+	for _, p := range a.Points {
+		dot := (p.X()+a.X)*e.X() + (p.Y()+a.Y)*e.Y()
+
+		if aStart > dot {
+			aStart = dot
+		}
+
+		if aEnd < dot {
+			aEnd = dot
+		}
+	}
+
+	for _, p := range b.Points {
+		dot := (p.X()+b.X)*e.X() + (p.Y()+b.Y)*e.Y()
+
+		if bStart > dot {
+			bStart = dot
+		}
+
+		if bEnd < dot {
+			bEnd = dot
+		}
+	}
+
+	if aStart > bEnd || aEnd < bStart {
+		// Separated by unit vector "e"
+		return true
+	}
+
+	if nil != result {
+		result.Axis = e
+		overlap := float64(0)
+
+		if aStart < bStart {
+			result.AContainedInB = false
+
+			if aEnd < bEnd {
+				overlap = aEnd - bStart
+				result.BContainedInA = false
+			} else {
+				option1 := aEnd - bStart
+				option2 := bEnd - aStart
+				if option1 < option2 {
+					overlap = option1
+				} else {
+					overlap = -option2
+				}
+			}
+		} else {
+			result.BContainedInA = false
+
+			if aEnd > bEnd {
+				overlap = aStart - bEnd
+				result.AContainedInB = false
+			} else {
+				option1 := aEnd - bStart
+				option2 := bEnd - aStart
+				if option1 < option2 {
+					overlap = option1
+				} else {
+					overlap = -option2
+				}
+			}
+		}
+
+		currentOverlap := result.Overlap
+		absoluteOverlap := overlap
+		if overlap < 0 {
+			absoluteOverlap = -overlap
+		}
+
+		if 0 == currentOverlap || currentOverlap > absoluteOverlap {
+			var sign float64 = 1
+			if overlap < 0 {
+				sign = -1
+			}
+
+			result.Overlap = absoluteOverlap
+			result.OverlapX = e.X() * sign
+			result.OverlapY = e.Y() * sign
+		}
+	}
+
+	// the specified unit vector "e" doesn't separate "a" and "b", overlap result is generated
+	return false
+}
+
+func WorldToVirtualGridPos(wx, wy, worldToVirtualGridRatio float64) (int32, int32) {
+	// [WARNING] Introduces loss of precision!
+	// In JavaScript floating numbers suffer from seemingly non-deterministic arithmetics, and even if certain libs solved this issue by approaches such as fixed-point-number, they might not be used in other libs -- e.g. the "collision libs" we're interested in -- thus couldn't kill all pains.
+	var virtualGridX int32 = int32(math.Round(wx * worldToVirtualGridRatio))
+	var virtualGridY int32 = int32(math.Round(wy * worldToVirtualGridRatio))
+	return virtualGridX, virtualGridY
+}
+
+func VirtualGridToWorldPos(vx, vy int32, virtualGridToWorldRatio float64) (float64, float64) {
+	// No loss of precision
+	var wx float64 = float64(vx) * virtualGridToWorldRatio
+	var wy float64 = float64(vy) * virtualGridToWorldRatio
+	return wx, wy
+}
+
+func WorldToPolygonColliderAnchorPos(wx, wy, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY float64) (float64, float64) {
+	return wx - halfBoundingW + collisionSpaceOffsetX, wy - halfBoundingH + collisionSpaceOffsetY
+}
+
+func PolygonColliderAnchorToWorldPos(cx, cy, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY float64) (float64, float64) {
+	return cx + halfBoundingW - collisionSpaceOffsetX, cy + halfBoundingH - collisionSpaceOffsetY
+}
+
+func PolygonColliderAnchorToVirtualGridPos(cx, cy, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY float64, worldToVirtualGridRatio float64) (int32, int32) {
+	wx, wy := PolygonColliderAnchorToWorldPos(cx, cy, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY)
+	return WorldToVirtualGridPos(wx, wy, worldToVirtualGridRatio)
+}
+
+func VirtualGridToPolygonColliderAnchorPos(vx, vy int32, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY float64, virtualGridToWorldRatio float64) (float64, float64) {
+	wx, wy := VirtualGridToWorldPos(vx, vy, virtualGridToWorldRatio)
+	return WorldToPolygonColliderAnchorPos(wx, wy, halfBoundingW, halfBoundingH, collisionSpaceOffsetX, collisionSpaceOffsetY)
+}

dnmshared/sharedprotos/geometry.pb.go

@@ -0,0 +1,427 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.28.1
+// 	protoc        v3.21.4
+// source: geometry.proto
+
+package sharedprotos
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Direction struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Dx int32 `protobuf:"varint,1,opt,name=dx,proto3" json:"dx,omitempty"`
+	Dy int32 `protobuf:"varint,2,opt,name=dy,proto3" json:"dy,omitempty"`
+}
+
+func (x *Direction) Reset() {
+	*x = Direction{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_geometry_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Direction) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Direction) ProtoMessage() {}
+
+func (x *Direction) ProtoReflect() protoreflect.Message {
+	mi := &file_geometry_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Direction.ProtoReflect.Descriptor instead.
+func (*Direction) Descriptor() ([]byte, []int) {
+	return file_geometry_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Direction) GetDx() int32 {
+	if x != nil {
+		return x.Dx
+	}
+	return 0
+}
+
+func (x *Direction) GetDy() int32 {
+	if x != nil {
+		return x.Dy
+	}
+	return 0
+}
+
+type Vec2D struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	X float64 `protobuf:"fixed64,1,opt,name=x,proto3" json:"x,omitempty"`
+	Y float64 `protobuf:"fixed64,2,opt,name=y,proto3" json:"y,omitempty"`
+}
+
+func (x *Vec2D) Reset() {
+	*x = Vec2D{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_geometry_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Vec2D) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Vec2D) ProtoMessage() {}
+
+func (x *Vec2D) ProtoReflect() protoreflect.Message {
+	mi := &file_geometry_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Vec2D.ProtoReflect.Descriptor instead.
+func (*Vec2D) Descriptor() ([]byte, []int) {
+	return file_geometry_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Vec2D) GetX() float64 {
+	if x != nil {
+		return x.X
+	}
+	return 0
+}
+
+func (x *Vec2D) GetY() float64 {
+	if x != nil {
+		return x.Y
+	}
+	return 0
+}
+
+type Polygon2D struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Anchor *Vec2D   `protobuf:"bytes,1,opt,name=anchor,proto3" json:"anchor,omitempty"`
+	Points []*Vec2D `protobuf:"bytes,2,rep,name=points,proto3" json:"points,omitempty"`
+}
+
+func (x *Polygon2D) Reset() {
+	*x = Polygon2D{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_geometry_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Polygon2D) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Polygon2D) ProtoMessage() {}
+
+func (x *Polygon2D) ProtoReflect() protoreflect.Message {
+	mi := &file_geometry_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Polygon2D.ProtoReflect.Descriptor instead.
+func (*Polygon2D) Descriptor() ([]byte, []int) {
+	return file_geometry_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Polygon2D) GetAnchor() *Vec2D {
+	if x != nil {
+		return x.Anchor
+	}
+	return nil
+}
+
+func (x *Polygon2D) GetPoints() []*Vec2D {
+	if x != nil {
+		return x.Points
+	}
+	return nil
+}
+
+type Vec2DList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Eles []*Vec2D `protobuf:"bytes,1,rep,name=eles,proto3" json:"eles,omitempty"`
+}
+
+func (x *Vec2DList) Reset() {
+	*x = Vec2DList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_geometry_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Vec2DList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Vec2DList) ProtoMessage() {}
+
+func (x *Vec2DList) ProtoReflect() protoreflect.Message {
+	mi := &file_geometry_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Vec2DList.ProtoReflect.Descriptor instead.
+func (*Vec2DList) Descriptor() ([]byte, []int) {
+	return file_geometry_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *Vec2DList) GetEles() []*Vec2D {
+	if x != nil {
+		return x.Eles
+	}
+	return nil
+}
+
+type Polygon2DList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Eles []*Polygon2D `protobuf:"bytes,1,rep,name=eles,proto3" json:"eles,omitempty"`
+}
+
+func (x *Polygon2DList) Reset() {
+	*x = Polygon2DList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_geometry_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Polygon2DList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Polygon2DList) ProtoMessage() {}
+
+func (x *Polygon2DList) ProtoReflect() protoreflect.Message {
+	mi := &file_geometry_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Polygon2DList.ProtoReflect.Descriptor instead.
+func (*Polygon2DList) Descriptor() ([]byte, []int) {
+	return file_geometry_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *Polygon2DList) GetEles() []*Polygon2D {
+	if x != nil {
+		return x.Eles
+	}
+	return nil
+}
+
+var File_geometry_proto protoreflect.FileDescriptor
+
+var file_geometry_proto_rawDesc = []byte{
+	0x0a, 0x0e, 0x67, 0x65, 0x6f, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x0c, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x22, 0x2b,
+	0x0a, 0x09, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x64,
+	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x64, 0x78, 0x12, 0x0e, 0x0a, 0x02, 0x64,
+	0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x64, 0x79, 0x22, 0x23, 0x0a, 0x05, 0x56,
+	0x65, 0x63, 0x32, 0x44, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x01, 0x78, 0x12, 0x0c, 0x0a, 0x01, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x01, 0x79,
+	0x22, 0x65, 0x0a, 0x09, 0x50, 0x6f, 0x6c, 0x79, 0x67, 0x6f, 0x6e, 0x32, 0x44, 0x12, 0x2b, 0x0a,
+	0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e,
+	0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x56, 0x65, 0x63,
+	0x32, 0x44, 0x52, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x06, 0x70, 0x6f,
+	0x69, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x68, 0x61,
+	0x72, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x56, 0x65, 0x63, 0x32, 0x44, 0x52,
+	0x06, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x34, 0x0a, 0x09, 0x56, 0x65, 0x63, 0x32, 0x44,
+	0x4c, 0x69, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x04, 0x65, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x73, 0x2e, 0x56, 0x65, 0x63, 0x32, 0x44, 0x52, 0x04, 0x65, 0x6c, 0x65, 0x73, 0x22, 0x3c, 0x0a,
+	0x0d, 0x50, 0x6f, 0x6c, 0x79, 0x67, 0x6f, 0x6e, 0x32, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x2b,
+	0x0a, 0x04, 0x65, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73,
+	0x68, 0x61, 0x72, 0x65, 0x64, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2e, 0x50, 0x6f, 0x6c, 0x79,
+	0x67, 0x6f, 0x6e, 0x32, 0x44, 0x52, 0x04, 0x65, 0x6c, 0x65, 0x73, 0x42, 0x18, 0x5a, 0x16, 0x64,
+	0x6e, 0x6d, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_geometry_proto_rawDescOnce sync.Once
+	file_geometry_proto_rawDescData = file_geometry_proto_rawDesc
+)
+
+func file_geometry_proto_rawDescGZIP() []byte {
+	file_geometry_proto_rawDescOnce.Do(func() {
+		file_geometry_proto_rawDescData = protoimpl.X.CompressGZIP(file_geometry_proto_rawDescData)
+	})
+	return file_geometry_proto_rawDescData
+}
+
+var file_geometry_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_geometry_proto_goTypes = []interface{}{
+	(*Direction)(nil),     // 0: sharedprotos.Direction
+	(*Vec2D)(nil),         // 1: sharedprotos.Vec2D
+	(*Polygon2D)(nil),     // 2: sharedprotos.Polygon2D
+	(*Vec2DList)(nil),     // 3: sharedprotos.Vec2DList
+	(*Polygon2DList)(nil), // 4: sharedprotos.Polygon2DList
+}
+var file_geometry_proto_depIdxs = []int32{
+	1, // 0: sharedprotos.Polygon2D.anchor:type_name -> sharedprotos.Vec2D
+	1, // 1: sharedprotos.Polygon2D.points:type_name -> sharedprotos.Vec2D
+	1, // 2: sharedprotos.Vec2DList.eles:type_name -> sharedprotos.Vec2D
+	2, // 3: sharedprotos.Polygon2DList.eles:type_name -> sharedprotos.Polygon2D
+	4, // [4:4] is the sub-list for method output_type
+	4, // [4:4] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_geometry_proto_init() }
+func file_geometry_proto_init() {
+	if File_geometry_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_geometry_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Direction); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_geometry_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Vec2D); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_geometry_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Polygon2D); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_geometry_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Vec2DList); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_geometry_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Polygon2DList); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_geometry_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   5,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_geometry_proto_goTypes,
+		DependencyIndexes: file_geometry_proto_depIdxs,
+		MessageInfos:      file_geometry_proto_msgTypes,
+	}.Build()
+	File_geometry_proto = out.File
+	file_geometry_proto_rawDesc = nil
+	file_geometry_proto_goTypes = nil
+	file_geometry_proto_depIdxs = nil
+}

dnmshared/tmx_parser.go

@@ -3,6 +3,7 @@ package dnmshared
 import (
 	"bytes"
 	"compress/zlib"
+	. "dnmshared/sharedprotos"
 	"encoding/base64"
 	"encoding/xml"
 	"errors"
@@ -173,8 +174,6 @@ func (l *TmxLayer) decodeBase64() ([]uint32, error) {
 	return gids, nil
 }
 
-type Vec2DList []*Vec2D
-type Polygon2DList []*Polygon2D
 type StrToVec2DListMap map[string]*Vec2DList
 type StrToPolygon2DListMap map[string]*Polygon2DList
 
@@ -233,10 +232,8 @@ func tsxPolylineToOffsetsWrtTileCenter(pTmxMapIns *TmxMap, singleObjInTsxFile *T
 	pointsCount := len(singleValueArray)
 
 	thePolygon2DFromPolyline := &Polygon2D{
-		Anchor:     nil,
-		Points:     make([]*Vec2D, pointsCount),
-		TileWidth:  pTsxIns.TileWidth,
-		TileHeight: pTsxIns.TileHeight,
+		Anchor: nil,
+		Points: make([]*Vec2D, pointsCount),
 	}
 
 	/*
@@ -327,16 +324,17 @@ func DeserializeTsxToColliderDict(pTmxMapIns *TmxMap, byteArrOfTsxFile []byte, f
 			if _, ok := theStrToPolygon2DListMap[key]; ok {
 				pThePolygon2DList = theStrToPolygon2DListMap[key]
 			} else {
-				thePolygon2DList := make(Polygon2DList, 0)
-				theStrToPolygon2DListMap[key] = &thePolygon2DList
-				pThePolygon2DList = theStrToPolygon2DListMap[key]
+				pThePolygon2DList = &Polygon2DList{
+					Eles: make([]*Polygon2D, 0),
+				}
+				theStrToPolygon2DListMap[key] = pThePolygon2DList
 			}
 
 			thePolygon2DFromPolyline, err := tsxPolylineToOffsetsWrtTileCenter(pTmxMapIns, singleObj, singleObj.Polyline, pTsxIns)
 			if nil != err {
 				panic(err)
 			}
-			*pThePolygon2DList = append(*pThePolygon2DList, thePolygon2DFromPolyline)
+			pThePolygon2DList.Eles = append(pThePolygon2DList.Eles, thePolygon2DFromPolyline)
 		}
 	}
 	return nil
@@ -352,8 +350,10 @@ func ParseTmxLayersAndGroups(pTmxMapIns *TmxMap, gidBoundariesMap map[int]StrToP
 			var pTheVec2DListToCache *Vec2DList
 			_, ok := toRetStrToVec2DListMap[objGroup.Name]
 			if false == ok {
-				theVec2DListToCache := make(Vec2DList, 0)
-				toRetStrToVec2DListMap[objGroup.Name] = &theVec2DListToCache
+				pTheVec2DListToCache = &Vec2DList{
+					Eles: make([]*Vec2D, 0),
+				}
+				toRetStrToVec2DListMap[objGroup.Name] = pTheVec2DListToCache
 			}
 			pTheVec2DListToCache = toRetStrToVec2DListMap[objGroup.Name]
 			for _, singleObjInTmxFile := range objGroup.Objects {
@@ -362,17 +362,18 @@ func ParseTmxLayersAndGroups(pTmxMapIns *TmxMap, gidBoundariesMap map[int]StrToP
 					Y: singleObjInTmxFile.Y,
 				}
 				thePosInWorld := pTmxMapIns.continuousObjLayerOffsetToContinuousMapNodePos(theUntransformedPos)
-				*pTheVec2DListToCache = append(*pTheVec2DListToCache, &thePosInWorld)
+				pTheVec2DListToCache.Eles = append(pTheVec2DListToCache.Eles, &thePosInWorld)
 			}
 		case "Barrier":
 			// Note that in this case, the "Polygon2D.Anchor" of each "TmxOrTsxObject" is exactly overlapping with "Polygon2D.Points[0]".
 			var pThePolygon2DListToCache *Polygon2DList
 			_, ok := toRetStrToPolygon2DListMap[objGroup.Name]
 			if false == ok {
-				thePolygon2DListToCache := make(Polygon2DList, 0)
-				toRetStrToPolygon2DListMap[objGroup.Name] = &thePolygon2DListToCache
+				pThePolygon2DListToCache = &Polygon2DList{
+					Eles: make([]*Polygon2D, 0),
+				}
+				toRetStrToPolygon2DListMap[objGroup.Name] = pThePolygon2DListToCache
 			}
-			pThePolygon2DListToCache = toRetStrToPolygon2DListMap[objGroup.Name]
 
 			for _, singleObjInTmxFile := range objGroup.Objects {
 				if nil == singleObjInTmxFile.Polyline {
@@ -386,7 +387,7 @@ func ParseTmxLayersAndGroups(pTmxMapIns *TmxMap, gidBoundariesMap map[int]StrToP
 				if nil != err {
 					panic(err)
 				}
-				*pThePolygon2DListToCache = append(*pThePolygon2DListToCache, thePolygon2DInWorld)
+				pThePolygon2DListToCache.Eles = append(pThePolygon2DListToCache.Eles, thePolygon2DInWorld)
 			}
 		default:
 		}
@@ -442,40 +443,3 @@ func (pTmxMapIns *TmxMap) continuousObjLayerOffsetToContinuousMapNodePos(continu
 
 	return toRet
 }
-
-func AlignPolygon2DToBoundingBox(input *Polygon2D) *Polygon2D {
-    // Transform again to put "anchor" at the top-left point of the bounding box for "resolv"
-    float64Max := float64(99999999999999.9)
-    boundingBoxTL := &Vec2D{
-        X: float64Max, 
-        Y: float64Max,
-    } 
-    for _, p := range input.Points {
-        if p.X < boundingBoxTL.X {
-            boundingBoxTL.X = p.X
-        } 
-        if p.Y < boundingBoxTL.Y {
-            boundingBoxTL.Y = p.Y
-        } 
-    }    
-
-    // Now "input.Anchor" should move to "input.Anchor+boundingBoxTL", thus "boundingBoxTL" is also the value of the negative diff for all "input.Points" 
-    output := &Polygon2D{
-            Anchor: &Vec2D{
-                X: input.Anchor.X+boundingBoxTL.X, 
-                Y: input.Anchor.Y+boundingBoxTL.Y,
-            },
-            Points:     make([]*Vec2D, len(input.Points)),
-            TileWidth:  input.TileWidth,
-            TileHeight: input.TileHeight,
-	} 
-
-    for i, p := range input.Points {
-        output.Points[i] = &Vec2D{
-            X: p.X-boundingBoxTL.X,
-            Y: p.Y-boundingBoxTL.Y,
-        }
-    }    
-    
-    return output 
-} 

frontend/assets/plugin_scripts/protobuf.js.meta

@@ -1,9 +0,0 @@
-{
-  "ver": "1.0.5",
-  "uuid": "bd514df4-095e-4088-9060-d99397a29a4f",
-  "isPlugin": true,
-  "loadPluginInWeb": true,
-  "loadPluginInNative": true,
-  "loadPluginInEditor": false,
-  "subMetas": {}
-}

frontend/assets/resources/map/simple/map.tmx

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<map version="1.2" tiledversion="1.2.3" orientation="isometric" renderorder="right-down" width="50" height="50" tilewidth="64" tileheight="64" infinite="0" nextlayerid="11" nextobjectid="214">
+<map version="1.2" tiledversion="1.2.3" orientation="isometric" renderorder="right-down" width="50" height="50" tilewidth="64" tileheight="64" infinite="0" nextlayerid="11" nextobjectid="215">
  <tileset firstgid="1" source="Tile_W64_H64_S01.tsx"/>
  <tileset firstgid="17" source="Tile_W300_H300_S01.tsx"/>
  <layer id="1" name="GroundFloor" width="50" height="50" locked="1">
@@ -8,7 +8,7 @@
   </data>
  </layer>
  <objectgroup id="2" name="PlayerStartingPos">
-  <object id="135" x="1442.33" y="2063">
+  <object id="135" x="1513.33" y="1996">
    <point/>
   </object>
   <object id="137" x="2270" y="1640">
@@ -17,7 +17,7 @@
  </objectgroup>
  <layer id="3" name="FirsrtFloor" width="50" height="50">
   <data encoding="base64" compression="zlib">
-   eJztwQENAAAAwqD3T20ON6AAAAAAAAAAAADg3wAnEAAB
+   eJzt1jEKgDAQRNE0GtD739fGaQIhqJHdCf81aSz2oyspBQAAAADWcUYPMIEaaugU37TvwbGl9y05tYz2wWFfaMiBhhyNKzRs99n7lzo0SG1OcWqQtsWxQdSwD57L3CCjO4dDg7zd+Yye7nxmajlCp5jD6Y4OAAAA4H8XE6wBrA==
   </data>
  </layer>
  <objectgroup id="4" name="Barrier">
@@ -36,5 +36,11 @@
    </properties>
    <polyline points="1101.33,-342 470.926,284.848 526.26,339.333 1152.93,-285.091"/>
   </object>
+  <object id="214" x="988" y="1632">
+   <properties>
+    <property name="boundary_type" value="barrier"/>
+   </properties>
+   <polyline points="-3,1 -70,72 514,640 588,572"/>
+  </object>
  </objectgroup>
 </map>

frontend/assets/resources/pbfiles/geometry.proto

@@ -0,0 +1,26 @@
+syntax = "proto3";
+option go_package = "dnmshared/sharedprotos"; // here "./" corresponds to the "--go_out" value in "protoc" command  
+package sharedprotos;
+
+message Direction {
+  int32 dx = 1;
+  int32 dy = 2;
+}
+
+message Vec2D {
+  double x = 1;
+  double y = 2;
+}
+
+message Polygon2D {
+  Vec2D anchor = 1;
+  repeated Vec2D points = 2;
+}
+
+message Vec2DList {
+  repeated Vec2D eles = 1;
+}
+
+message Polygon2DList {
+  repeated Polygon2D eles = 1;
+}

frontend/assets/resources/pbfiles/geometry.proto.meta

@@ -0,0 +1,5 @@
+{
+  "ver": "2.0.0",
+  "uuid": "2ba698f8-1af7-4c47-9d43-b2730b62c692",
+  "subMetas": {}
+}

frontend/assets/resources/pbfiles/room_downsync_frame.proto

@@ -1,35 +1,13 @@
 syntax = "proto3";
-option go_package = "."; // "./" corresponds to the "--go_out" value in "protoc" command 
+option go_package = "battle_srv/protos"; // here "./" corresponds to the "--go_out" value in "protoc" command 
 
-package treasurehunterx;
-
-message Direction {
-  int32 dx = 1;
-  int32 dy = 2;
-}
-
-message Vec2D {
-  double x = 1;
-  double y = 2;
-}
-
-message Polygon2D {
-  Vec2D Anchor = 1;
-  repeated Vec2D Points = 2;
-}
-
-message Vec2DList {
-  repeated Vec2D vec2DList = 1;
-}
-
-message Polygon2DList {
-  repeated Polygon2D polygon2DList = 1;
-}
+package protos;
+import "geometry.proto"; // The import path here is only w.r.t. the proto file, not the Go package.
 
 message BattleColliderInfo {
   string stageName = 1;
-  map<string, Vec2DList> strToVec2DListMap = 2; 
-  map<string, Polygon2DList> strToPolygon2DListMap = 3; 
+  map<string, sharedprotos.Vec2DList> strToVec2DListMap = 2; 
+  map<string, sharedprotos.Polygon2DList> strToPolygon2DListMap = 3; 
   int32 stageDiscreteW = 4;
   int32 stageDiscreteH = 5;
   int32 stageTileW = 6;
@@ -46,17 +24,19 @@ message BattleColliderInfo {
   int32 inputFrameUpsyncDelayTolerance = 16;  
   int32 maxChasingRenderFramesPerUpdate = 17;
   int32 playerBattleState = 18;
-  double rollbackEstimatedDt = 19;
-  double rollbackEstimatedDtMillis = 20;
-  int64 rollbackEstimatedDtNanos = 21;
+  double rollbackEstimatedDtMillis = 19;
+  int64 rollbackEstimatedDtNanos = 20;
+ 
+  double worldToVirtualGridRatio = 21;
+  double virtualGridToWorldRatio = 22;
 }
 
-message Player {
+message PlayerDownsync {
   int32 id = 1;
-  double x = 2; 
-  double y = 3; 
-  Direction dir = 4;
-  double speed = 5;
+  int32 virtualGridX = 2; 
+  int32 virtualGridY = 3; 
+  sharedprotos.Direction dir = 4;
+  int32 speed = 5; // in terms of virtual grid units
   int32 battleState = 6;
   int32 lastMoveGmtMillis = 7;
   int32 score = 10;
@@ -64,12 +44,13 @@ message Player {
   int32 joinIndex = 12;
 }
 
-message PlayerMeta {
+message PlayerDownsyncMeta {
   int32 id = 1;
   string name = 2;
   string displayName = 3;
   string avatar = 4;
   int32 joinIndex = 5;
+  double colliderRadius = 6;
 }
 
 message InputFrameUpsync {
@@ -89,9 +70,9 @@ message HeartbeatUpsync {
 
 message RoomDownsyncFrame {
   int32 id = 1;
-  map<int32, Player> players = 2;
+  map<int32, PlayerDownsync> players = 2;
   int64 countdownNanos = 3;
-  map<int32, PlayerMeta> playerMetas = 4;
+  map<int32, PlayerDownsyncMeta> playerMetas = 4;
 }
 
 message WsReq {

frontend/assets/resources/prefabs/Pacman1.prefab

@@ -100,7 +100,7 @@
       "__id__": 1
     },
     "_children": [],
-    "_active": false,
+    "_active": true,
     "_components": [
       {
         "__id__": 3
@@ -119,8 +119,8 @@
     },
     "_contentSize": {
       "__type__": "cc.Size",
-      "width": 93.36,
-      "height": 40
+      "width": 46.68,
+      "height": 27.72
     },
     "_anchorPoint": {
       "__type__": "cc.Vec2",
@@ -132,7 +132,7 @@
       "ctor": "Float64Array",
       "array": [
         -5,
-        101,
+        50,
         0,
         0,
         0,
@@ -164,12 +164,16 @@
       "__id__": 2
     },
     "_enabled": true,
-    "_materials": [],
+    "_materials": [
+      {
+        "__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
+      }
+    ],
     "_useOriginalSize": false,
     "_string": "(0, 0)",
     "_N$string": "(0, 0)",
-    "_fontSize": 40,
-    "_lineHeight": 40,
+    "_fontSize": 20,
+    "_lineHeight": 22,
     "_enableWrapText": true,
     "_N$file": null,
     "_isSystemFontUsed": true,
@@ -557,15 +561,13 @@
     },
     "_enabled": true,
     "animComp": null,
-    "baseSpeed": 50,
-    "speed": 50,
     "lastMovedAt": 0,
-    "eps": 0.1,
-    "magicLeanLowerBound": 0.414,
-    "magicLeanUpperBound": 2.414,
     "arrowTipNode": {
       "__id__": 8
     },
+    "coordLabel": {
+      "__id__": 3
+    },
     "_id": ""
   },
   {

frontend/assets/resources/prefabs/Pacman2.prefab

@@ -100,7 +100,7 @@
       "__id__": 1
     },
     "_children": [],
-    "_active": false,
+    "_active": true,
     "_components": [
       {
         "__id__": 3
@@ -119,8 +119,8 @@
     },
     "_contentSize": {
       "__type__": "cc.Size",
-      "width": 93.36,
-      "height": 40
+      "width": 46.68,
+      "height": 27.72
     },
     "_anchorPoint": {
       "__type__": "cc.Vec2",
@@ -132,7 +132,7 @@
       "ctor": "Float64Array",
       "array": [
         -5,
-        101,
+        50,
         0,
         0,
         0,
@@ -164,12 +164,16 @@
       "__id__": 2
     },
     "_enabled": true,
-    "_materials": [],
+    "_materials": [
+      {
+        "__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
+      }
+    ],
     "_useOriginalSize": false,
     "_string": "(0, 0)",
     "_N$string": "(0, 0)",
-    "_fontSize": 40,
-    "_lineHeight": 40,
+    "_fontSize": 20,
+    "_lineHeight": 22,
     "_enableWrapText": true,
     "_N$file": null,
     "_isSystemFontUsed": true,
@@ -557,15 +561,13 @@
     },
     "_enabled": true,
     "animComp": null,
-    "baseSpeed": 50,
-    "speed": 50,
     "lastMovedAt": 0,
-    "eps": 0.1,
-    "magicLeanLowerBound": 0.414,
-    "magicLeanUpperBound": 2.414,
     "arrowTipNode": {
       "__id__": 8
     },
+    "coordLabel": {
+      "__id__": 3
+    },
     "_id": ""
   },
   {

frontend/assets/scenes/default_map.fire

@@ -539,7 +539,7 @@
       "array": [
         0,
         0,
-        210.4441731196186,
+        342.9460598986377,
         0,
         0,
         0,

frontend/assets/scenes/login.fire

@@ -440,7 +440,7 @@
       "array": [
         0,
         0,
-        209.57814771583418,
+        237.35666382819272,
         0,
         0,
         0,

frontend/assets/scripts/BasePlayer.js

@@ -6,30 +6,10 @@ module.export = cc.Class({
       type: cc.Animation,
       default: null,
     },
-    baseSpeed: {
-      type: cc.Float,
-      default: 50,
-    },
-    speed: {
-      type: cc.Float,
-      default: 50
-    },
     lastMovedAt: {
       type: cc.Float,
       default: 0 // In "GMT milliseconds"
-    },
-    eps: {
-      default: 0.10,
-      type: cc.Float
-    },
-    magicLeanLowerBound: {
-      default: 0.414, // Tangent of (PI/8).
-      type: cc.Float
-    },
-    magicLeanUpperBound: {
-      default: 2.414, // Tangent of (3*PI/8).
-      type: cc.Float
-    },
+    }
   },
 
   // LIFE-CYCLE CALLBACKS:
@@ -44,14 +24,14 @@ module.export = cc.Class({
   onLoad() {
     const self = this;
     self.clips = {
-      '01': 'Top',
-      '0-1': 'Bottom',
+      '02': 'Top',
+      '0-2': 'Bottom',
       '-20': 'Left',
       '20': 'Right',
-      '-21': 'TopLeft',
-      '21': 'TopRight',
-      '-2-1': 'BottomLeft',
-      '2-1': 'BottomRight'
+      '-11': 'TopLeft',
+      '11': 'TopRight',
+      '-1-1': 'BottomLeft',
+      '1-1': 'BottomRight'
     };
     const canvasNode = self.mapNode.parent;
     self.mapIns = self.mapNode.getComponent("Map");
@@ -70,7 +50,7 @@ module.export = cc.Class({
       this.activeDirection = newScheduledDirection;
       this.activeDirection = newScheduledDirection;
       const clipKey = newScheduledDirection.dx.toString() + newScheduledDirection.dy.toString();
-      const clips = (this.attacked ? this.attackedClips : this.clips); 
+      const clips = (this.attacked ? this.attackedClips : this.clips);
       let clip = clips[clipKey];
       if (!clip) {
         // Keep playing the current anim.
@@ -86,11 +66,9 @@ module.export = cc.Class({
     }
   },
 
-  update(dt) {
-  },
+  update(dt) {},
 
-  lateUpdate(dt) {
-  },
+  lateUpdate(dt) {},
 
   _generateRandomDirection() {
     return ALL_DISCRETE_DIRECTIONS_CLOCKWISE[Math.floor(Math.random() * ALL_DISCRETE_DIRECTIONS_CLOCKWISE.length)];
@@ -117,16 +95,16 @@ module.export = cc.Class({
 
   updateSpeed(proposedSpeed) {
     if (0 == proposedSpeed && 0 < this.speed) {
-      this.startFrozenDisplay(); 
-    } 
+      this.startFrozenDisplay();
+    }
     if (0 < proposedSpeed && 0 == this.speed) {
-      this.stopFrozenDisplay(); 
-    } 
-    this.speed = proposedSpeed; 
+      this.stopFrozenDisplay();
+    }
+    this.speed = proposedSpeed;
   },
 
   startFrozenDisplay() {
-    const self =  this;
+    const self = this;
     self.attacked = true;
   },
 

frontend/assets/scripts/Login.js

@@ -1,6 +1,8 @@
 const i18n = require('LanguageData');
 i18n.init(window.language); // languageID should be equal to the one we input in New Language ID input field
 
+window.pb = require("./modules/room_downsync_frame_proto_bundle.forcemsg");
+
 cc.Class({
   extends: cc.Component,
 
@@ -67,19 +69,6 @@ cc.Class({
 
   onLoad() {
 
-    //kobako: 腾讯统计代码
-    //WARN: 打包到微信小游戏的时候会导致出错
-    /*
-    (function() {
-        var mta = document.createElement("script");
-        mta.src = "//pingjs.qq.com/h5/stats.js?v2.0.4";
-        mta.setAttribute("name", "MTAH5");
-        mta.setAttribute("sid", "500674632");
-        var s = document.getElementsByTagName("script")[0];
-        s.parentNode.insertBefore(mta, s);
-    })();
-    */
-
     window.atFirstLocationHref = window.location.href.split('#')[0];
     const self = this;
     self.getRetCodeList();
@@ -97,9 +86,7 @@ cc.Class({
     self.smsLoginCaptchaLabel.active = true;
 
     self.loginButton.active = true;
-    self.checkPhoneNumber = self.checkPhoneNumber.bind(self);
-    self.checkIntAuthTokenExpire = self.checkIntAuthTokenExpire.bind(self);
-    self.checkCaptcha = self.checkCaptcha.bind(self);
+    self.onLoginButtonClicked = self.onLoginButtonClicked.bind(self);
     self.onSMSCaptchaGetButtonClicked = self.onSMSCaptchaGetButtonClicked.bind(self);
     self.smsLoginCaptchaButton.on('click', self.onSMSCaptchaGetButtonClicked);
 
@@ -112,28 +99,16 @@ cc.Class({
       window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
     }
 
-    cc.loader.loadRes("pbfiles/room_downsync_frame", function(err, textAsset /* cc.TextAsset */ ) {
-      if (err) {
-        cc.error(err.message || err);
-        return;
+    self.checkIntAuthTokenExpire().then(
+      (intAuthToken) => {
+        console.log("Successfully found `intAuthToken` in local cache");
+        self.useTokenLogin(intAuthToken);
+      },
+      () => {
+        console.warn("Failed to find `intAuthToken` in local cache");
+        window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
       }
-      // Otherwise, `window.RoomDownsyncFrame` is already assigned.
-      let protoRoot = new protobuf.Root;
-      window.protobuf.parse(textAsset.text, protoRoot);
-      window.RoomDownsyncFrame = protoRoot.lookupType("treasurehunterx.RoomDownsyncFrame"); 
-      window.BattleColliderInfo = protoRoot.lookupType("treasurehunterx.BattleColliderInfo"); 
-      window.WsReq = protoRoot.lookupType("treasurehunterx.WsReq"); 
-      window.WsResp = protoRoot.lookupType("treasurehunterx.WsResp"); 
-      self.checkIntAuthTokenExpire().then(
-        () => {
-          const intAuthToken = JSON.parse(cc.sys.localStorage.getItem('selfPlayer')).intAuthToken;
-          self.useTokenLogin(intAuthToken);
-        },
-        () => {
-          window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
-        }
-      );
-    });
+    );
   },
 
   getRetCodeList() {
@@ -221,11 +196,28 @@ cc.Class({
   checkIntAuthTokenExpire() {
     return new Promise((resolve, reject) => {
       if (!cc.sys.localStorage.getItem('selfPlayer')) {
+        console.warn("Couldn't find selfPlayer key in local cache");
         reject();
         return;
       }
       const selfPlayer = JSON.parse(cc.sys.localStorage.getItem('selfPlayer'));
-      (selfPlayer.intAuthToken && new Date().getTime() < selfPlayer.expiresAt) ? resolve() : reject();
+      if (null == selfPlayer) {
+        console.warn("Couldn't find selfPlayer object in local cache");
+        reject();
+        return;
+      }
+
+      if (null == selfPlayer.intAuthToken) {
+        console.warn("Couldn't find selfPlayer object with key `intAuthToken` in local cache");
+        reject();
+        return;
+      }
+      if (new Date().getTime() > selfPlayer.expiresAt) {
+        console.warn("Couldn't find unexpired selfPlayer `intAuthToken` in local cache");
+        reject();
+        return;
+      }
+      resolve(selfPlayer.intAuthToken);
     })
   },
 
@@ -278,13 +270,15 @@ cc.Class({
         intAuthToken: _intAuthToken
       },
       success: function(resp) {
+        console.log("Login attempt `useTokenLogin` succeeded.");
         self.onLoggedIn(resp);
       },
       error: function(xhr, status, errMsg) {
-        console.log("Login attempt `useTokenLogin` failed, about to execute `clearBoundRoomIdInBothVolatileAndPersistentStorage`.");
+        console.warn("Login attempt `useTokenLogin` failed, about to execute `clearBoundRoomIdInBothVolatileAndPersistentStorage`.");
         window.clearBoundRoomIdInBothVolatileAndPersistentStorage()
       },
       timeout: function() {
+        console.warn("Login attempt `useTokenLogin` timed out, about to enable interactive controls.");
         self.enableInteractiveControls(true);
       },
     });
@@ -335,7 +329,7 @@ cc.Class({
 
   onLoggedIn(res) {
     const self = this;
-    cc.log(`OnLoggedIn ${JSON.stringify(res)}.`)
+    console.log("OnLoggedIn ", JSON.stringify(res))
     if (res.ret === self.retCodeDict.OK) {
       self.enableInteractiveControls(false);
       const date = Number(res.expiresAt);
@@ -360,6 +354,7 @@ cc.Class({
       );
       cc.director.loadScene('default_map');
     } else {
+      console.log("OnLoggedIn failed, about to remove `selfPlayer` in local cache.")
       cc.sys.localStorage.removeItem("selfPlayer");
       window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
       self.enableInteractiveControls(true);

frontend/assets/scripts/Map.js

@@ -111,7 +111,7 @@ cc.Class({
       type: cc.Integer,
       default: 4 // implies (renderFrameIdLagTolerance >> inputScaleFrames) count of inputFrameIds
     },
-    teleportEps1D: {
+    jigglingEps1D: {
       type: cc.Float,
       default: 1e-3
     },
@@ -121,19 +121,19 @@ cc.Class({
     return (0 == inputFrameId % 10);
   },
 
-  dumpToRenderCache: function(roomDownsyncFrame) {
+  dumpToRenderCache: function(rdf) {
     const self = this;
     const minToKeepRenderFrameId = self.lastAllConfirmedRenderFrameId;
     while (0 < self.recentRenderCache.cnt && self.recentRenderCache.stFrameId < minToKeepRenderFrameId) {
       self.recentRenderCache.pop();
     }
-    const ret = self.recentRenderCache.setByFrameId(roomDownsyncFrame, roomDownsyncFrame.id);
+    const ret = self.recentRenderCache.setByFrameId(rdf, rdf.id);
     return ret;
   },
 
   dumpToInputCache: function(inputFrameDownsync) {
     const self = this;
-    let minToKeepInputFrameId = self._convertToInputFrameId(self.lastAllConfirmedRenderFrameId, self.inputDelayFrames); // [WARNING] This could be different from "self.lastAllConfirmedInputFrameId". We'd like to keep the corresponding inputFrame for "self.lastAllConfirmedRenderFrameId" such that a rollback could place "self.chaserRenderFrameId = self.lastAllConfirmedRenderFrameId" for the worst case incorrect prediction.
+    let minToKeepInputFrameId = self._convertToInputFrameId(self.lastAllConfirmedRenderFrameId, self.inputDelayFrames); // [WARNING] This could be different from "self.lastAllConfirmedInputFrameId". We'd like to keep the corresponding delayedInputFrame for "self.lastAllConfirmedRenderFrameId" such that a rollback could place "self.chaserRenderFrameId = self.lastAllConfirmedRenderFrameId" for the worst case incorrect prediction.
     if (minToKeepInputFrameId > self.lastAllConfirmedInputFrameId) {
       minToKeepInputFrameId = self.lastAllConfirmedInputFrameId;
     }
@@ -174,9 +174,16 @@ cc.Class({
     }
 
     const joinIndex = self.selfPlayerInfo.joinIndex;
-    const discreteDir = self.ctrl.getDiscretizedDirection();
     const previousInputFrameDownsyncWithPrediction = self.getCachedInputFrameDownsyncWithPrediction(inputFrameId);
+    const previousSelfInput = (null == previousInputFrameDownsyncWithPrediction ? null : previousInputFrameDownsyncWithPrediction.inputList[joinIndex - 1]);
+
+    // If "forceConfirmation" is active on backend, we shouldn't override the already downsynced "inputFrameDownsync"s.  
+    const existingInputFrame = self.recentInputCache.getByFrameId(inputFrameId);
+    if (null != existingInputFrame && self._allConfirmed(existingInputFrame.confirmedList)) {
+      return [previousSelfInput, existingInputFrame.inputList[joinIndex - 1]];
+    }
     const prefabbedInputList = (null == previousInputFrameDownsyncWithPrediction ? new Array(self.playerRichInfoDict.size).fill(0) : previousInputFrameDownsyncWithPrediction.inputList.slice());
+    const discreteDir = self.ctrl.getDiscretizedDirection();
     prefabbedInputList[(joinIndex - 1)] = discreteDir.encodedIdx;
     const prefabbedInputFrameDownsync = {
       inputFrameId: inputFrameId,
@@ -186,7 +193,6 @@ cc.Class({
 
     self.dumpToInputCache(prefabbedInputFrameDownsync); // A prefabbed inputFrame, would certainly be adding a new inputFrame to the cache, because server only downsyncs "all-confirmed inputFrames" 
 
-    const previousSelfInput = (null == previousInputFrameDownsyncWithPrediction ? null : previousInputFrameDownsyncWithPrediction.inputList[joinIndex - 1]);
     return [previousSelfInput, discreteDir.encodedIdx];
   },
 
@@ -223,7 +229,7 @@ cc.Class({
         inputFrameUpsyncBatch.push(inputFrameUpsync);
       }
     }
-    const reqData = window.WsReq.encode({
+    const reqData = window.pb.protos.WsReq.encode({
       msgId: Date.now(),
       playerId: self.selfPlayerInfo.id,
       act: window.UPSYNC_MSG_ACT_PLAYER_CMD,
@@ -253,8 +259,8 @@ cc.Class({
     if (null != window.handleBattleColliderInfo) {
       window.handleBattleColliderInfo = null;
     }
-    if (null != window.handleClientSessionCloseOrError) {
-      window.handleClientSessionCloseOrError = null;
+    if (null != window.handleClientSessionError) {
+      window.handleClientSessionError = null;
     }
   },
 
@@ -324,12 +330,10 @@ cc.Class({
     self.selfPlayerInfo = null; // This field is kept for distinguishing "self" and "others".
     self.recentInputCache = new RingBuffer(1024);
 
-    self.latestCollisionSys = new collisions.Collisions();
-    self.chaserCollisionSys = new collisions.Collisions();
+    self.collisionSys = new collisions.Collisions();
 
     self.collisionBarrierIndexPrefix = (1 << 16); // For tracking the movements of barriers, though not yet actually used 
-    self.latestCollisionSysMap = new Map();
-    self.chaserCollisionSysMap = new Map();
+    self.collisionSysMap = new Map();
 
     self.transitToState(ALL_MAP_STATES.VISUAL);
 
@@ -348,9 +352,11 @@ cc.Class({
     window.mapIns = self;
     window.forceBigEndianFloatingNumDecoding = self.forceBigEndianFloatingNumDecoding;
 
+    self.showCriticalCoordinateLabels = false;
+
     console.warn("+++++++ Map onLoad()");
-    window.handleClientSessionCloseOrError = function() {
-      console.warn('+++++++ Common handleClientSessionCloseOrError()');
+    window.handleClientSessionError = function() {
+      console.warn('+++++++ Common handleClientSessionError()');
 
       if (ALL_BATTLE_STATES.IN_SETTLEMENT == self.battleState) {
         console.log("Battled ended by settlement");
@@ -422,9 +428,11 @@ cc.Class({
       self.rollbackEstimatedDt = parsedBattleColliderInfo.rollbackEstimatedDt;
       self.rollbackEstimatedDtMillis = parsedBattleColliderInfo.rollbackEstimatedDtMillis;
       self.rollbackEstimatedDtNanos = parsedBattleColliderInfo.rollbackEstimatedDtNanos;
-      self.rollbackEstimatedDtToleranceMillis = self.rollbackEstimatedDtMillis / 1000.0;
       self.maxChasingRenderFramesPerUpdate = parsedBattleColliderInfo.maxChasingRenderFramesPerUpdate;
 
+      self.worldToVirtualGridRatio = parsedBattleColliderInfo.worldToVirtualGridRatio;
+      self.virtualGridToWorldRatio = parsedBattleColliderInfo.virtualGridToWorldRatio;
+
       const tiledMapIns = self.node.getComponent(cc.TiledMap);
 
       const fullPathOfTmxFile = cc.js.formatStr("map/%s/map", parsedBattleColliderInfo.stageName);
@@ -467,17 +475,44 @@ cc.Class({
           const x0 = boundaryObj[0].x,
             y0 = boundaryObj[0].y;
           let pts = [];
-          // TODO: Simplify this redundant coordinate conversion within "extractBoundaryObjects", but since this routine is only called once per battle, not urgent.
           for (let i = 0; i < boundaryObj.length; ++i) {
-            pts.push([boundaryObj[i].x - x0, boundaryObj[i].y - y0]);
+            const dx = boundaryObj[i].x - x0;
+            const dy = boundaryObj[i].y - y0;
+            pts.push([dx, dy]);
+          /*
+          if (self.showCriticalCoordinateLabels) {
+            const barrierVertLabelNode = new cc.Node();
+            switch (i % 4) {
+              case 0:
+                barrierVertLabelNode.color = cc.Color.RED;
+                break;
+              case 1:
+                barrierVertLabelNode.color = cc.Color.GRAY;
+                break;
+              case 2:
+                barrierVertLabelNode.color = cc.Color.BLACK;
+                break;
+              default:
+                barrierVertLabelNode.color = cc.Color.MAGENTA;
+                break;
+            }
+            barrierVertLabelNode.setPosition(cc.v2(x0+0.95*dx, y0+0.5*dy));
+            const barrierVertLabel = barrierVertLabelNode.addComponent(cc.Label);
+            barrierVertLabel.fontSize = 20;
+            barrierVertLabel.lineHeight = 22;
+            barrierVertLabel.string = `(${boundaryObj[i].x.toFixed(1)}, ${boundaryObj[i].y.toFixed(1)})`;
+            safelyAddChild(self.node, barrierVertLabelNode);
+            setLocalZOrder(barrierVertLabelNode, 5);
+
+            barrierVertLabelNode.active = true;
           }
-          const newBarrierLatest = self.latestCollisionSys.createPolygon(x0, y0, pts);
-          console.log("Created barrier: ", newBarrierLatest);
-          const newBarrierChaser = self.chaserCollisionSys.createPolygon(x0, y0, pts);
+          */
+          }
+          const newBarrier = self.collisionSys.createPolygon(x0, y0, pts);
+          // console.log("Created barrier: ", newBarrier);
           ++barrierIdCounter;
           const collisionBarrierIndex = (self.collisionBarrierIndexPrefix + barrierIdCounter);
-          self.latestCollisionSysMap.set(collisionBarrierIndex, newBarrierLatest);
-          self.chaserCollisionSysMap.set(collisionBarrierIndex, newBarrierChaser);
+          self.collisionSysMap.set(collisionBarrierIndex, newBarrier);
         }
 
         self.selfPlayerInfo = JSON.parse(cc.sys.localStorage.getItem('selfPlayer'));
@@ -500,7 +535,7 @@ cc.Class({
           self.backgroundMapTiledIns.node.setContentSize(newBackgroundMapSize.width * newBackgroundMapTileSize.width, newBackgroundMapSize.height * newBackgroundMapTileSize.height);
           self.backgroundMapTiledIns.node.setPosition(cc.v2(0, 0));
 
-          const reqData = window.WsReq.encode({
+          const reqData = window.pb.protos.WsReq.encode({
             msgId: Date.now(),
             act: window.UPSYNC_MSG_ACT_PLAYER_COLLIDER_ACK,
           }).finish();
@@ -574,6 +609,7 @@ cc.Class({
     if (rdf.id < self.lastAllConfirmedRenderFrameId) {
       return window.RING_BUFF_FAILED_TO_SET;
     }
+
     const dumpRenderCacheRet = self.dumpToRenderCache(rdf);
     if (window.RING_BUFF_FAILED_TO_SET == dumpRenderCacheRet) {
       console.error("Something is wrong while setting the RingBuffer by frameId!");
@@ -582,20 +618,18 @@ cc.Class({
     if (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START < rdf.id && window.RING_BUFF_CONSECUTIVE_SET == dumpRenderCacheRet) {
       /*
       Don't change 
-      - lastAllConfirmedRenderFrameId, it's updated only in "rollbackAndChase > _createRoomDownsyncFrameLocally" (except for when RING_BUFF_NON_CONSECUTIVE_SET) 
-      - chaserRenderFrameId, it's updated only in "onInputFrameDownsyncBatch" (except for when RING_BUFF_NON_CONSECUTIVE_SET)
+      - 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;
     }
 
-    // The logic below applies to (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START == rdf.id || window.RING_BUFF_NON_CONSECUTIVE_SET == dumpRenderCacheRet)
-    console.log('On battle started or resynced! renderFrameId=', rdf.id);
-
-    self.renderFrameId = rdf.id;
-    self.lastRenderFrameIdTriggeredAt = performance.now();
-    // In this case it must be true that "rdf.id > chaserRenderFrameId >= lastAllConfirmedRenderFrameId".
-    self.lastAllConfirmedRenderFrameId = rdf.id;
-    self.chaserRenderFrameId = rdf.id;
+    // The logic below applies to ( || window.RING_BUFF_NON_CONSECUTIVE_SET == dumpRenderCacheRet)
+    if (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START == rdf.id) {
+      console.log('On battle started! renderFrameId=', rdf.id);
+    } else {
+      console.log('On battle resynced! renderFrameId=', rdf.id);
+    }
 
     const players = rdf.players;
     const playerMetas = rdf.playerMetas;
@@ -608,6 +642,12 @@ cc.Class({
       playersInfoScriptIns.updateData(playerMeta);
     }
 
+    self.renderFrameId = rdf.id;
+    self.lastRenderFrameIdTriggeredAt = performance.now();
+    // In this case it must be true that "rdf.id > chaserRenderFrameId >= lastAllConfirmedRenderFrameId".
+    self.lastAllConfirmedRenderFrameId = rdf.id;
+    self.chaserRenderFrameId = rdf.id;
+
     if (null != rdf.countdownNanos) {
       self.countdownNanos = rdf.countdownNanos;
     }
@@ -637,7 +677,7 @@ cc.Class({
     return true;
   },
 
-  onInputFrameDownsyncBatch(batch, dumpRenderCacheRet /* second param is default to null */ ) {
+  onInputFrameDownsyncBatch(batch) {
     const self = this;
     if (ALL_BATTLE_STATES.IN_BATTLE != self.battleState
       && ALL_BATTLE_STATES.IN_SETTLEMENT != self.battleState) {
@@ -651,49 +691,44 @@ cc.Class({
       if (inputFrameDownsyncId < self.lastAllConfirmedInputFrameId) {
         continue;
       }
-      if (window.RING_BUFF_NON_CONSECUTIVE_SET == dumpRenderCacheRet) {
-        // Deliberately left blank, in this case "chaserRenderFrameId" is already reset to proper value.
-      } else {
-        const inputFrameIdConsecutive = (inputFrameDownsyncId == self.lastAllConfirmedInputFrameId + 1);
-        const localInputFrame = self.recentInputCache.getByFrameId(inputFrameDownsyncId);
-        if (null == localInputFrame && false == inputFrameIdConsecutive) {
-          throw "localInputFrame not existing and is NOT CONSECUTIVELY EXTENDING recentInputCache: inputFrameDownsyncId=" + inputFrameDownsyncId + ", lastAllConfirmedInputFrameId=" + self.lastAllConfirmedInputFrameId + ", recentInputCache=" + self._stringifyRecentInputCache(false);
-        } else if (null == firstPredictedYetIncorrectInputFrameId && null != localInputFrame && !self.equalInputLists(localInputFrame.inputList, inputFrameDownsync.inputList)) {
-          firstPredictedYetIncorrectInputFrameId = inputFrameDownsyncId;
-        }
+      const localInputFrame = self.recentInputCache.getByFrameId(inputFrameDownsyncId);
+      if (null != localInputFrame
+        &&
+        null == firstPredictedYetIncorrectInputFrameId
+        &&
+        !self.equalInputLists(localInputFrame.inputList, inputFrameDownsync.inputList)
+      ) {
+        firstPredictedYetIncorrectInputFrameId = inputFrameDownsyncId;
       }
       self.lastAllConfirmedInputFrameId = inputFrameDownsyncId;
+      // [WARNING] Take all "inputFrameDownsync" from backend as all-confirmed, it'll be later checked by "rollbackAndChase". 
+      inputFrameDownsync.confirmedList = (1 << self.playerRichInfoDict.size) - 1;
       self.dumpToInputCache(inputFrameDownsync);
     }
 
-    if (null != firstPredictedYetIncorrectInputFrameId) {
-      const inputFrameId1 = firstPredictedYetIncorrectInputFrameId;
-      const renderFrameId1 = self._convertToFirstUsedRenderFrameId(inputFrameId1, self.inputDelayFrames); // a.k.a. "firstRenderFrameIdUsingIncorrectInputFrameId"
-      if (renderFrameId1 < self.renderFrameId) {
-        /*
-        A typical case is as follows.
-        --------------------------------------------------------
-        [self.lastAllConfirmedRenderFrameId]       :              22
+    if (null == firstPredictedYetIncorrectInputFrameId) return;
+    const inputFrameId1 = firstPredictedYetIncorrectInputFrameId;
+    const renderFrameId1 = self._convertToFirstUsedRenderFrameId(inputFrameId1, self.inputDelayFrames); // a.k.a. "firstRenderFrameIdUsingIncorrectInputFrameId"
+    if (renderFrameId1 >= self.renderFrameId) return; // No need to rollback when "renderFrameId1 == self.renderFrameId", because the "corresponding delayedInputFrame for renderFrameId1" is NOT YET EXECUTED BY NOW, it just went through "++self.renderFrameId" in "update(dt)" and javascript-runtime is mostly single-threaded in our programmable range.
 
-        <renderFrameId1>                           :              36
+    if (renderFrameId1 >= self.chaserRenderFrameId) return;
+
+    /*
+    A typical case is as follows.
+    --------------------------------------------------------
+    [self.lastAllConfirmedRenderFrameId]       :              22
+
+    <renderFrameId1>                           :              36
 
 
-        <self.chaserRenderFrameId>                 :              62
+    <self.chaserRenderFrameId>                 :              62
 
-        [self.renderFrameId]                       :              64
-        --------------------------------------------------------
-        */
-        if (renderFrameId1 < self.chaserRenderFrameId) {
-          // The actual rollback-and-chase would later be executed in update(dt). 
-          console.warn("Mismatched input detected, resetting chaserRenderFrameId: inputFrameId1:", inputFrameId1, ", renderFrameId1:", renderFrameId1, ", chaserRenderFrameId before reset: ", self.chaserRenderFrameId);
-          self.chaserRenderFrameId = renderFrameId1;
-        } else {
-          // Deliberately left blank, chasing is ongoing.
-        }
-      } else {
-        // No need to rollback when "renderFrameId1 == self.renderFrameId", because the "corresponding delayedInputFrame for renderFrameId2" is NOT YET EXECUTED BY NOW, it just went through "++self.renderFrameId" in "update(dt)" and javascript-runtime is mostly single-threaded in our programmable range. 
-      }
-    }
+    [self.renderFrameId]                       :              64
+    --------------------------------------------------------
+    */
+    // 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}`);
+    self.chaserRenderFrameId = renderFrameId1;
   },
 
   onPlayerAdded(rdf) {
@@ -709,7 +744,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);
+    s.push(`Battle stats: renderFrameId=${self.renderFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastUpsyncInputFrameId=${self.lastUpsyncInputFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, chaserRenderFrameId=${self.chaserRenderFrameId}`);
 
     for (let i = self.recentInputCache.stFrameId; i < self.recentInputCache.edFrameId; ++i) {
       const inputFrameDownsync = self.recentInputCache.getByFrameId(i);
@@ -741,18 +776,22 @@ cc.Class({
     self.playersInfoNode.getComponent("PlayersInfo").clearInfo();
   },
 
-  spawnPlayerNode(joinIndex, x, y) {
+  spawnPlayerNode(joinIndex, vx, vy, playerRichInfo) {
     const self = this;
     const newPlayerNode = 1 == joinIndex ? cc.instantiate(self.player1Prefab) : cc.instantiate(self.player2Prefab); // hardcoded for now, car color determined solely by joinIndex
-    newPlayerNode.setPosition(cc.v2(x, y));
-    newPlayerNode.getComponent("SelfPlayer").mapNode = self.node;
-    const currentSelfColliderCircle = newPlayerNode.getComponent(cc.CircleCollider);
+    const wpos = self.virtualGridToWorldPos(vx, vy);
 
-    const newPlayerColliderLatest = self.latestCollisionSys.createCircle(x, y, currentSelfColliderCircle.radius);
-    const newPlayerColliderChaser = self.chaserCollisionSys.createCircle(x, y, currentSelfColliderCircle.radius);
+    newPlayerNode.setPosition(cc.v2(wpos[0], wpos[1]));
+    newPlayerNode.getComponent("SelfPlayer").mapNode = self.node;
+    const cpos = self.virtualGridToPlayerColliderPos(vx, vy, playerRichInfo);
+    const d = playerRichInfo.colliderRadius * 2,
+      x0 = cpos[0],
+      y0 = cpos[1];
+    let pts = [[0, 0], [d, 0], [d, d], [0, d]];
+
+    const newPlayerCollider = self.collisionSys.createPolygon(x0, y0, pts);
     const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
-    self.latestCollisionSysMap.set(collisionPlayerIndex, newPlayerColliderLatest);
-    self.chaserCollisionSysMap.set(collisionPlayerIndex, newPlayerColliderChaser);
+    self.collisionSysMap.set(collisionPlayerIndex, newPlayerCollider);
 
     safelyAddChild(self.node, newPlayerNode);
     setLocalZOrder(newPlayerNode, 5);
@@ -760,8 +799,8 @@ cc.Class({
     newPlayerNode.active = true;
     const playerScriptIns = newPlayerNode.getComponent("SelfPlayer");
     playerScriptIns.scheduleNewDirection({
-      dx: 0,
-      dy: 0
+      dx: playerRichInfo.dir.dx,
+      dy: playerRichInfo.dir.dy
     }, true);
 
     return [newPlayerNode, playerScriptIns];
@@ -799,12 +838,11 @@ cc.Class({
         if (nextChaserRenderFrameId > self.renderFrameId) {
           nextChaserRenderFrameId = self.renderFrameId;
         }
-        self.rollbackAndChase(prevChaserRenderFrameId, nextChaserRenderFrameId, self.chaserCollisionSys, self.chaserCollisionSysMap);
-        self.chaserRenderFrameId = nextChaserRenderFrameId; // Move the cursor "self.chaserRenderFrameId", keep in mind that "self.chaserRenderFrameId" is not monotonic!
+        self.rollbackAndChase(prevChaserRenderFrameId, nextChaserRenderFrameId, self.collisionSys, self.collisionSysMap, true);
         let t2 = performance.now();
 
-        // Inside "self.rollbackAndChase", the "self.latestCollisionSys" is ALWAYS ROLLED BACK to "self.recentRenderCache.get(self.renderFrameId)" before being applied dynamics from corresponding inputFrameDownsync, REGARDLESS OF whether or not "self.chaserRenderFrameId == self.renderFrameId" now. 
-        const rdf = self.rollbackAndChase(self.renderFrameId, self.renderFrameId + 1, self.latestCollisionSys, self.latestCollisionSysMap);
+        // 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 rdf = self.rollbackAndChase(self.renderFrameId, self.renderFrameId + 1, self.collisionSys, self.collisionSysMap, false);
         /*
         const nonTrivialChaseEnded = (prevChaserRenderFrameId < nextChaserRenderFrameId && nextChaserRenderFrameId == self.renderFrameId); 
         if (nonTrivialChaseEnded) {
@@ -818,7 +856,7 @@ cc.Class({
       } finally {
         // Update countdown
         if (null != self.countdownNanos) {
-          self.countdownNanos = self.battleDurationNanos - self.renderFrameId*self.rollbackEstimatedDtNanos;
+          self.countdownNanos = self.battleDurationNanos - self.renderFrameId * self.rollbackEstimatedDtNanos;
           if (self.countdownNanos <= 0) {
             self.onBattleStopped(self.playerRichInfoDict);
             return;
@@ -907,15 +945,28 @@ cc.Class({
     setLocalZOrder(toShowNode, 10);
   },
 
-  hideFindingPlayersGUI() {
+  hideFindingPlayersGUI(rdf) {
     const self = this;
     if (null == self.findingPlayerNode.parent) return;
     self.findingPlayerNode.parent.removeChild(self.findingPlayerNode);
+    if (null != rdf) {
+      self._initPlayerRichInfoDict(rdf.players, rdf.playerMetas);
+    }
   },
 
-  onBattleReadyToStart(playerMetas) {
-    console.log("Calling `onBattleReadyToStart` with:", playerMetas);
+  onBattleReadyToStart(rdf) {
     const self = this;
+    const players = rdf.players;
+    const playerMetas = rdf.playerMetas;
+    self._initPlayerRichInfoDict(players, playerMetas);
+
+    // Show the top status indicators for IN_BATTLE 
+    const playersInfoScriptIns = self.playersInfoNode.getComponent("PlayersInfo");
+    for (let i in playerMetas) {
+      const playerMeta = playerMetas[i];
+      playersInfoScriptIns.updateData(playerMeta);
+    }
+    console.log("Calling `onBattleReadyToStart` with:", playerMetas);
     const findingPlayerScriptIns = self.findingPlayerNode.getComponent("FindingPlayer");
     findingPlayerScriptIns.hideExitButton();
     findingPlayerScriptIns.updatePlayersInfo(playerMetas);
@@ -929,74 +980,22 @@ cc.Class({
     }, 1500);
   },
 
-  _createRoomDownsyncFrameLocally(renderFrameId, collisionSys, collisionSysMap) {
-    const self = this;
-    const prevRenderFrameId = renderFrameId - 1;
-    const inputFrameAppliedOnPrevRenderFrame = (
-    0 > prevRenderFrameId
-      ?
-      null
-      :
-      self.getCachedInputFrameDownsyncWithPrediction(self._convertToInputFrameId(prevRenderFrameId, self.inputDelayFrames))
-    );
-
-    // TODO: Find a better way to assign speeds instead of using "speedRefRenderFrameId".
-    const speedRefRenderFrameId = prevRenderFrameId;
-    const speedRefRenderFrame = (
-    0 > speedRefRenderFrameId
-      ?
-      null
-      :
-      self.recentRenderCache.getByFrameId(speedRefRenderFrameId)
-    );
-
-    const rdf = {
-      id: renderFrameId,
-      refFrameId: renderFrameId,
-      players: {}
-    };
-    self.playerRichInfoDict.forEach((playerRichInfo, playerId) => {
-      const joinIndex = playerRichInfo.joinIndex;
-      const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
-      const playerCollider = collisionSysMap.get(collisionPlayerIndex);
-      rdf.players[playerRichInfo.id] = {
-        id: playerRichInfo.id,
-        x: playerCollider.x,
-        y: playerCollider.y,
-        dir: self.ctrl.decodeDirection(null == inputFrameAppliedOnPrevRenderFrame ? 0 : inputFrameAppliedOnPrevRenderFrame.inputList[joinIndex - 1]),
-        speed: (null == speedRefRenderFrame ? playerRichInfo.speed : speedRefRenderFrame.players[playerRichInfo.id].speed),
-        joinIndex: joinIndex
-      };
-    });
-    if (
-      null != inputFrameAppliedOnPrevRenderFrame && self._allConfirmed(inputFrameAppliedOnPrevRenderFrame.confirmedList)
-      &&
-      self.lastAllConfirmedRenderFrameId >= prevRenderFrameId
-      &&
-      rdf.id > self.lastAllConfirmedRenderFrameId
-    ) {
-      self.lastAllConfirmedRenderFrameId = rdf.id;
-      self.chaserRenderFrameId = rdf.id; // it must be true that "chaserRenderFrameId >= lastAllConfirmedRenderFrameId"  
-    }
-    self.dumpToRenderCache(rdf);
-    return rdf;
-  },
-
   applyRoomDownsyncFrameDynamics(rdf) {
     const self = this;
 
     self.playerRichInfoDict.forEach((playerRichInfo, playerId) => {
       const immediatePlayerInfo = rdf.players[playerId];
-      const dx = (immediatePlayerInfo.x-playerRichInfo.node.x); 
-      const dy = (immediatePlayerInfo.y-playerRichInfo.node.y);
-      const selfJiggling = (playerId == self.selfPlayerInfo.playerId && (0 != dx && self.teleportEps1D >= Math.abs(dx) && 0 != dy && self.teleportEps1D >= Math.abs(dy))); 
-      if (!selfJiggling) {
-        playerRichInfo.node.setPosition(immediatePlayerInfo.x, immediatePlayerInfo.y);
-      } else {
-        console.log("selfJiggling: dx = ", dx, ", dy = ", dy);
+      const wpos = self.virtualGridToWorldPos(immediatePlayerInfo.virtualGridX, immediatePlayerInfo.virtualGridY);
+      const dx = (wpos[0] - playerRichInfo.node.x);
+      const dy = (wpos[1] - playerRichInfo.node.y);
+      const justJiggling = (self.jigglingEps1D >= Math.abs(dx) && self.jigglingEps1D >= Math.abs(dy));
+      if (!justJiggling) {
+        playerRichInfo.node.setPosition(wpos[0], wpos[1]);
+        playerRichInfo.virtualGridX = immediatePlayerInfo.virtualGridX;
+        playerRichInfo.virtualGridY = immediatePlayerInfo.virtualGridY;
+        playerRichInfo.scriptIns.scheduleNewDirection(immediatePlayerInfo.dir, false);
+        playerRichInfo.scriptIns.updateSpeed(immediatePlayerInfo.speed);
       }
-      playerRichInfo.scriptIns.scheduleNewDirection(immediatePlayerInfo.dir, false);
-      playerRichInfo.scriptIns.updateSpeed(immediatePlayerInfo.speed);
     });
   },
 
@@ -1014,71 +1013,140 @@ cc.Class({
     return inputFrameDownsync;
   },
 
-  rollbackAndChase(renderFrameIdSt, renderFrameIdEd, collisionSys, collisionSysMap) {
+  // TODO: Write unit-test for this function to compare with its backend counter part
+  applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame, currRenderFrame, collisionSys, collisionSysMap) {
     const self = this;
-    let latestRdf = self.recentRenderCache.getByFrameId(renderFrameIdSt); // typed "RoomDownsyncFrame"
-    if (null == latestRdf) {
-      console.error("Couldn't find renderFrameId=", renderFrameIdSt, " to rollback, lastAllConfirmedRenderFrameId=", self.lastAllConfirmedRenderFrameId, ", lastAllConfirmedInputFrameId=", self.lastAllConfirmedInputFrameId, ", recentRenderCache=", self._stringifyRecentRenderCache(false), ", recentInputCache=", self._stringifyRecentInputCache(false));
+    const nextRenderFramePlayers = {}
+    for (let playerId in currRenderFrame.players) {
+      const currPlayerDownsync = currRenderFrame.players[playerId];
+      nextRenderFramePlayers[playerId] = {
+        id: playerId,
+        virtualGridX: currPlayerDownsync.virtualGridX,
+        virtualGridY: currPlayerDownsync.virtualGridY,
+        dir: {
+          dx: currPlayerDownsync.dir.dx,
+          dy: currPlayerDownsync.dir.dy,
+        },
+        speed: currPlayerDownsync.speed,
+        battleState: currPlayerDownsync.battleState,
+        score: currPlayerDownsync.score,
+        removed: currPlayerDownsync.removed,
+        joinIndex: currPlayerDownsync.joinIndex,
+      };
     }
 
-    if (renderFrameIdSt >= renderFrameIdEd) {
-      return latestRdf;
-    }
-    /* 
-    Reset "position" of players in "collisionSys" according to "renderFrameIdSt". The easy part is that we don't have path-dependent-integrals to worry about like that of thermal dynamics.
-    */
-    self.playerRichInfoDict.forEach((playerRichInfo, playerId) => {
-      const joinIndex = playerRichInfo.joinIndex;
-      const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
-      const playerCollider = collisionSysMap.get(collisionPlayerIndex);
-      const player = latestRdf.players[playerId];
-      playerCollider.x = player.x;
-      playerCollider.y = player.y;
-    });
+    const toRet = {
+      id: currRenderFrame.id + 1,
+      players: nextRenderFramePlayers,
+    };
 
-    /*
-    This function eventually calculates a "RoomDownsyncFrame" where "RoomDownsyncFrame.id == renderFrameIdEd".
-    */
-    for (let i = renderFrameIdSt; i < renderFrameIdEd; ++i) {
-      const renderFrame = self.recentRenderCache.getByFrameId(i); // typed "RoomDownsyncFrame"
-      const j = self._convertToInputFrameId(i, self.inputDelayFrames);
-      const inputFrameDownsync = self.getCachedInputFrameDownsyncWithPrediction(j);
-      if (null == inputFrameDownsync) {
-        console.error("Failed to get cached inputFrameDownsync for renderFrameId=", i, ", inputFrameId=", j, "lastAllConfirmedRenderFrameId=", self.lastAllConfirmedRenderFrameId, ", lastAllConfirmedInputFrameId=", self.lastAllConfirmedInputFrameId, ", recentRenderCache=", self._stringifyRecentRenderCache(false), ", recentInputCache=", self._stringifyRecentInputCache(false));
+    if (null != delayedInputFrame) {
+      const inputList = delayedInputFrame.inputList;
+      const effPushbacks = new Array(self.playerRichInfoArr.length); // Guaranteed determinism regardless of traversal order
+      for (let j in self.playerRichInfoArr) {
+        const joinIndex = parseInt(j) + 1;
+        effPushbacks[joinIndex - 1] = [0.0, 0.0];
+        const playerId = self.playerRichInfoArr[j].id;
+        const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
+        const playerCollider = collisionSysMap.get(collisionPlayerIndex);
+        const player = currRenderFrame.players[playerId];
+
+        const encodedInput = inputList[joinIndex - 1];
+        const decodedInput = self.ctrl.decodeDirection(encodedInput);
+
+        // console.log(`Got non-zero inputs for playerId=${playerId}, decodedInput=${JSON.stringify(decodedInput)} @currRenderFrame.id=${currRenderFrame.id}, delayedInputFrame.id=${delayedInputFrame.id}`);
+        /* 
+        Reset "position" of players in "collisionSys" according to "virtual grid position". The easy part is that we don't have path-dependent-integrals to worry about like that of thermal dynamics.
+        */
+        const newVx = player.virtualGridX + (decodedInput.dx + player.speed * decodedInput.dx);
+        const newVy = player.virtualGridY + (decodedInput.dy + player.speed * decodedInput.dy);
+        const newCpos = self.virtualGridToPlayerColliderPos(newVx, newVy, self.playerRichInfoArr[joinIndex - 1]);
+        playerCollider.x = newCpos[0];
+        playerCollider.y = newCpos[1];
+        // Update directions and thus would eventually update moving animation accordingly
+        nextRenderFramePlayers[playerId].dir.dx = decodedInput.dx;
+        nextRenderFramePlayers[playerId].dir.dy = decodedInput.dy;
       }
-      const inputList = inputFrameDownsync.inputList;
-      // [WARNING] Traverse in the order of joinIndices to guarantee determinism.
+
+      collisionSys.update();
+      const result = collisionSys.createResult(); // Can I reuse a "self.collisionSysResult" object throughout the whole battle?
+
       for (let j in self.playerRichInfoArr) {
         const joinIndex = parseInt(j) + 1;
         const playerId = self.playerRichInfoArr[j].id;
         const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
         const playerCollider = collisionSysMap.get(collisionPlayerIndex);
-        const player = renderFrame.players[playerId];
-        const encodedInput = inputList[joinIndex - 1];
-        const decodedInput = self.ctrl.decodeDirection(encodedInput);
-        const baseChange = player.speed * self.rollbackEstimatedDt * decodedInput.speedFactor;
-        playerCollider.x += baseChange * decodedInput.dx;
-        playerCollider.y += baseChange * decodedInput.dy;
-      }
-
-      collisionSys.update();
-      const result = collisionSys.createResult(); // Can I reuse a "self.latestCollisionSysResult" object throughout the whole battle?
-
-      for (let i in self.playerRichInfoArr) {
-        const joinIndex = parseInt(i) + 1;
-        const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
-        const playerCollider = collisionSysMap.get(collisionPlayerIndex);
         const potentials = playerCollider.potentials();
-        for (const barrier of potentials) {
+        for (const potential of potentials) {
           // Test if the player collides with the wall
-          if (!playerCollider.collides(barrier, result)) continue;
+          if (!playerCollider.collides(potential, result)) continue;
           // Push the player out of the wall
-          playerCollider.x -= result.overlap * result.overlap_x;
-          playerCollider.y -= result.overlap * result.overlap_y;
+          effPushbacks[joinIndex - 1][0] += result.overlap * result.overlap_x;
+          effPushbacks[joinIndex - 1][1] += result.overlap * result.overlap_y;
         }
       }
 
-      latestRdf = self._createRoomDownsyncFrameLocally(i + 1, collisionSys, collisionSysMap);
+      for (let j in self.playerRichInfoArr) {
+        const joinIndex = parseInt(j) + 1;
+        const playerId = self.playerRichInfoArr[j].id;
+        const collisionPlayerIndex = self.collisionPlayerIndexPrefix + joinIndex;
+        const playerCollider = collisionSysMap.get(collisionPlayerIndex);
+        const newVpos = self.playerColliderAnchorToVirtualGridPos(playerCollider.x - effPushbacks[joinIndex - 1][0], playerCollider.y - effPushbacks[joinIndex - 1][1], self.playerRichInfoArr[j]);
+        nextRenderFramePlayers[playerId].virtualGridX = newVpos[0];
+        nextRenderFramePlayers[playerId].virtualGridY = newVpos[1];
+      }
+    }
+
+    return toRet;
+  },
+
+  rollbackAndChase(renderFrameIdSt, renderFrameIdEd, collisionSys, collisionSysMap, isChasing) {
+    /*
+    This function eventually calculates a "RoomDownsyncFrame" where "RoomDownsyncFrame.id == renderFrameIdEd" if not interruptted.
+    */
+    const self = this;
+    let latestRdf = self.recentRenderCache.getByFrameId(renderFrameIdSt); // typed "RoomDownsyncFrame"
+    if (null == latestRdf) {
+      console.error(`Couldn't find renderFrameId=${renderFrameIdSt}, to rollback, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}, recentRenderCache=${self._stringifyRecentRenderCache(false)}, recentInputCache=${self._stringifyRecentInputCache(false)}`);
+      return latestRdf;
+    }
+
+    if (renderFrameIdSt >= renderFrameIdEd) {
+      return latestRdf;
+    }
+
+    for (let i = renderFrameIdSt; i < renderFrameIdEd; ++i) {
+      const currRenderFrame = 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"!
+      if (null == currRenderFrame) {
+        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`);
+        return latestRdf;
+      }
+      const j = self._convertToInputFrameId(i, self.inputDelayFrames);
+      const delayedInputFrame = self.getCachedInputFrameDownsyncWithPrediction(j);
+      if (null == delayedInputFrame) {
+        console.warn(`Failed to get cached delayedInputFrame for i=${i}, j=${j}, self.renderFrameId=${self.renderFrameId}, lastAllConfirmedRenderFrameId=${self.lastAllConfirmedRenderFrameId}, lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}`);
+        return latestRdf;
+      }
+
+      latestRdf = self.applyInputFrameDownsyncDynamicsOnSingleRenderFrame(delayedInputFrame, currRenderFrame, 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;
+        }
+      }
+
+      if (true == isChasing) {
+        // Move the cursor "self.chaserRenderFrameId", keep in mind that "self.chaserRenderFrameId" is not monotonic!
+        self.chaserRenderFrameId = latestRdf.id;
+      }
+      self.dumpToRenderCache(latestRdf);
     }
 
     return latestRdf;
@@ -1091,8 +1159,10 @@ cc.Class({
       if (self.playerRichInfoDict.has(playerId)) continue; // Skip already put keys
       const immediatePlayerInfo = players[playerId];
       const immediatePlayerMeta = playerMetas[playerId];
-      const nodeAndScriptIns = self.spawnPlayerNode(immediatePlayerInfo.joinIndex, immediatePlayerInfo.x, immediatePlayerInfo.y);
       self.playerRichInfoDict.set(playerId, immediatePlayerInfo);
+      Object.assign(self.playerRichInfoDict.get(playerId), immediatePlayerMeta);
+
+      const nodeAndScriptIns = self.spawnPlayerNode(immediatePlayerInfo.joinIndex, immediatePlayerInfo.virtualGridX, immediatePlayerInfo.virtualGridY, self.playerRichInfoDict.get(playerId));
 
       Object.assign(self.playerRichInfoDict.get(playerId), {
         node: nodeAndScriptIns[0],
@@ -1120,7 +1190,7 @@ cc.Class({
 
       return s.join('\n');
     }
-    return "[stInputFrameId=" + self.recentInputCache.stFrameId + ", edInputFrameId=" + self.recentInputCache.edFrameId + ")";
+    return `[stInputFrameId=${self.recentInputCache.stFrameId}, edInputFrameId=${self.recentInputCache.edFrameId})`;
   },
 
   _stringifyRecentRenderCache(usefullOutput) {
@@ -1133,7 +1203,43 @@ cc.Class({
 
       return s.join('\n');
     }
-    return "[stRenderFrameId=" + self.recentRenderCache.stFrameId + ", edRenderFrameId=" + self.recentRenderCache.edFrameId + ")";
+    return `[stRenderFrameId=${self.recentRenderCache.stFrameId}, edRenderFrameId=${self.recentRenderCache.edFrameId})`;
   },
 
+  worldToVirtualGridPos(x, y) {
+    // [WARNING] Introduces loss of precision!
+    const self = this;
+    // In JavaScript floating numbers suffer from seemingly non-deterministic arithmetics, and even if certain libs solved this issue by approaches such as fixed-point-number, they might not be used in other libs -- e.g. the "collision libs" we're interested in -- thus couldn't kill all pains.
+    let virtualGridX = Math.round(x * self.worldToVirtualGridRatio);
+    let virtualGridY = Math.round(y * self.worldToVirtualGridRatio);
+    return [virtualGridX, virtualGridY];
+  },
+
+  virtualGridToWorldPos(vx, vy) {
+    // No loss of precision
+    const self = this;
+    let wx = parseFloat(vx) * self.virtualGridToWorldRatio;
+    let wy = parseFloat(vy) * self.virtualGridToWorldRatio;
+    return [wx, wy];
+  },
+
+  playerWorldToCollisionPos(wx, wy, playerRichInfo) {
+    return [wx - playerRichInfo.colliderRadius, wy - playerRichInfo.colliderRadius];
+  },
+
+  playerColliderAnchorToWorldPos(cx, cy, playerRichInfo) {
+    return [cx + playerRichInfo.colliderRadius, cy + playerRichInfo.colliderRadius];
+  },
+
+  playerColliderAnchorToVirtualGridPos(cx, cy, playerRichInfo) {
+    const self = this;
+    const wpos = self.playerColliderAnchorToWorldPos(cx, cy, playerRichInfo);
+    return self.worldToVirtualGridPos(wpos[0], wpos[1])
+  },
+
+  virtualGridToPlayerColliderPos(vx, vy, playerRichInfo) {
+    const self = this;
+    const wpos = self.virtualGridToWorldPos(vx, vy);
+    return self.playerWorldToCollisionPos(wpos[0], wpos[1], playerRichInfo)
+  },
 });

frontend/assets/scripts/SelfPlayer.js

@@ -1,4 +1,4 @@
-const BasePlayer = require("./BasePlayer"); 
+const BasePlayer = require("./BasePlayer");
 
 cc.Class({
   extends: BasePlayer,
@@ -7,6 +7,10 @@ cc.Class({
     arrowTipNode: {
       type: cc.Node,
       default: null
+    },
+    coordLabel: {
+      type: cc.Label,
+      default: null
     }
   },
   start() {
@@ -26,6 +30,10 @@ cc.Class({
       '2-1': 'attackedRight'
     };
     this.arrowTipNode.active = false;
+
+    if (!this.mapIns.showCriticalCoordinateLabels) {
+      this.coordLabel.node.active = false;
+    }
   },
 
   showArrowTipNode() {
@@ -34,7 +42,7 @@ cc.Class({
       return;
     }
     self.arrowTipNode.active = true;
-    window.setTimeout(function(){
+    window.setTimeout(function() {
       if (null == self.arrowTipNode) {
         return;
       }
@@ -44,6 +52,9 @@ cc.Class({
 
   update(dt) {
     BasePlayer.prototype.update.call(this, dt);
+    if (this.mapIns.showCriticalCoordinateLabels) {
+      this.coordLabel.string = `(${this.node.x.toFixed(2)}, ${this.node.y.toFixed(2)})`;
+    }
   },
 
 });

frontend/assets/scripts/TileCollisionManagerSingleton.js

@@ -372,7 +372,7 @@ TileCollisionManager.prototype.extractBoundaryObjects = function (withTiledMapNo
   for (let tsxFilenameIdx = 0; tsxFilenameIdx < tsxFileNames.length; ++tsxFilenameIdx) {
     const tsxOrientation = tileSets[tsxFilenameIdx].orientation;
     if (cc.TiledMap.Orientation.ORTHO == tsxOrientation) {
-      cc.error("Error at tileset %s: We proceed with ONLY tilesets in ORTHO orientation for all map orientations by now.", tsxFileNames[tsxFilenameIdx]);
+      cc.error("Error at tileset %s: We don't proceed with tilesets in ORTHO orientation by now.", tsxFileNames[tsxFilenameIdx]);
       continue;
     };
 

frontend/assets/scripts/TouchEventsManager.js

@@ -1,18 +1,14 @@
 window.DIRECTION_DECODER = [
-    // The 3rd value matches low-precision constants in backend.
-    [0, 0, 0.0],
-    [0, +1, 1.0],
-    [0, -1, 1.0],
-    [+2, 0, 0.5],
-    [-2, 0, 0.5],
-    [+2, +1, 0.4472],
-    [-2, -1, 0.4472],
-    [+2, -1, 0.4472],
-    [-2, +1, 0.4472],
-    [+2, 0, 0.5],
-    [-2, 0, 0.5],
-    [0, +1, 1.0],
-    [0, -1, 1.0],
+  // The 3rd value matches low-precision constants in backend.
+  [0, 0],
+  [0, +2],
+  [0, -2],
+  [+2, 0],
+  [-2, 0],
+  [+1, +1],
+  [-1, -1],
+  [+1, -1],
+  [-1, +1],
 ];
 
 cc.Class({
@@ -40,11 +36,11 @@ cc.Class({
       type: cc.Float
     },
     magicLeanLowerBound: {
-      default: 0.414, // Tangent of (PI/8).
+      default: 0.1,
       type: cc.Float
     },
     magicLeanUpperBound: {
-      default: 2.414, // Tangent of (3*PI/8).
+      default: 0.9,
       type: cc.Float
     },
     // For joystick ends.
@@ -117,8 +113,8 @@ cc.Class({
 
   _initTouchEvent() {
     const self = this;
-    const translationListenerNode = (self.translationListenerNode ? self.translationListenerNode : self.mapNode);  
-    const zoomingListenerNode = (self.zoomingListenerNode ? self.zoomingListenerNode : self.mapNode); 
+    const translationListenerNode = (self.translationListenerNode ? self.translationListenerNode : self.mapNode);
+    const zoomingListenerNode = (self.zoomingListenerNode ? self.zoomingListenerNode : self.mapNode);
 
     translationListenerNode.on(cc.Node.EventType.TOUCH_START, function(event) {
       self._touchStartEvent(event);
@@ -132,7 +128,7 @@ cc.Class({
     translationListenerNode.on(cc.Node.EventType.TOUCH_CANCEL, function(event) {
       self._touchEndEvent(event);
     });
-    translationListenerNode.inTouchPoints = new Map(); 
+    translationListenerNode.inTouchPoints = new Map();
 
     zoomingListenerNode.on(cc.Node.EventType.TOUCH_START, function(event) {
       self._touchStartEvent(event);
@@ -146,7 +142,7 @@ cc.Class({
     zoomingListenerNode.on(cc.Node.EventType.TOUCH_CANCEL, function(event) {
       self._touchEndEvent(event);
     });
-    zoomingListenerNode.inTouchPoints = new Map(); 
+    zoomingListenerNode.inTouchPoints = new Map();
   },
 
   _isMapOverMoved(mapTargetPos) {
@@ -155,7 +151,7 @@ cc.Class({
   },
 
   _touchStartEvent(event) {
-    const theListenerNode = event.target; 
+    const theListenerNode = event.target;
     for (let touch of event._touches) {
       theListenerNode.inTouchPoints.set(touch._id, touch);
     }
@@ -165,12 +161,12 @@ cc.Class({
     if (ALL_MAP_STATES.VISUAL != this.mapScriptIns.state) {
       return;
     }
-    const theListenerNode = event.target; 
+    const theListenerNode = event.target;
     const linearScaleFacBase = this.linearScaleFacBase; // Not used yet.
     if (1 != theListenerNode.inTouchPoints.size) {
       return;
     }
-    if (!theListenerNode.inTouchPoints.has(event.currentTouch._id))  {
+    if (!theListenerNode.inTouchPoints.has(event.currentTouch._id)) {
       return;
     }
     const diffVec = event.currentTouch._point.sub(event.currentTouch._startPoint);
@@ -189,9 +185,9 @@ cc.Class({
     if (ALL_MAP_STATES.VISUAL != this.mapScriptIns.state) {
       return;
     }
-    const theListenerNode = event.target; 
+    const theListenerNode = event.target;
     if (2 != theListenerNode.inTouchPoints.size) {
-       return;
+      return;
     }
     if (2 == event._touches.length) {
       const firstTouch = event._touches[0];
@@ -219,13 +215,13 @@ cc.Class({
       }
       this.mainCamera.zoomRatio = targetScale;
       for (let child of this.mainCameraNode.children) {
-        child.setScale(1/targetScale); 
+        child.setScale(1 / targetScale);
       }
     }
   },
 
   _touchEndEvent(event) {
-    const theListenerNode = event.target; 
+    const theListenerNode = event.target;
     do {
       if (!theListenerNode.inTouchPoints.has(event.currentTouch._id)) {
         break;
@@ -241,7 +237,7 @@ cc.Class({
         break;
       }
 
-      // TODO: Handle single-finger-click event.
+    // TODO: Handle single-finger-click event.
     } while (false);
     this.cachedStickHeadPosition = cc.v2(0.0, 0.0);
     for (let touch of event._touches) {
@@ -266,19 +262,11 @@ cc.Class({
       encodedIdx: 0
     };
     if (Math.abs(continuousDx) < eps && Math.abs(continuousDy) < eps) {
-        return ret;
+      return ret;
     }
 
-    if (Math.abs(continuousDx) < eps) {
-      ret.dx = 0;
-      if (0 < continuousDy) {
-        ret.dy = +1; // up
-        ret.encodedIdx = 1;
-      } else {
-        ret.dy = -1; // down
-        ret.encodedIdx = 2;
-      }
-    } else if (Math.abs(continuousDy) < eps) {
+    const criticalRatio = continuousDy / continuousDx;
+    if (Math.abs(criticalRatio) < this.magicLeanLowerBound) {
       ret.dy = 0;
       if (0 < continuousDx) {
         ret.dx = +2; // right 
@@ -287,66 +275,55 @@ cc.Class({
         ret.dx = -2; // left 
         ret.encodedIdx = 4;
       }
+    } else if (Math.abs(criticalRatio) > this.magicLeanUpperBound) {
+      ret.dx = 0;
+      if (0 < continuousDy) {
+        ret.dy = +2; // up
+        ret.encodedIdx = 1;
+      } else {
+        ret.dy = -2; // down
+        ret.encodedIdx = 2;
+      }
     } else {
-      const criticalRatio = continuousDy / continuousDx;
-      if (criticalRatio > this.magicLeanLowerBound && criticalRatio < this.magicLeanUpperBound) {
-        if (0 < continuousDx) {
-          ret.dx = +2; 
+      if (0 < continuousDx) {
+        if (0 < continuousDy) {
+          ret.dx = +1;
           ret.dy = +1;
           ret.encodedIdx = 5;
         } else {
-          ret.dx = -2; 
+          ret.dx = +1;
+          ret.dy = -1;
+          ret.encodedIdx = 7;
+        }
+      } else {
+        // 0 >= continuousDx
+        if (0 < continuousDy) {
+          ret.dx = -1;
+          ret.dy = +1;
+          ret.encodedIdx = 8;
+        } else {
+          ret.dx = -1;
           ret.dy = -1;
           ret.encodedIdx = 6;
         }
-      } else if (criticalRatio > -this.magicLeanUpperBound && criticalRatio < -this.magicLeanLowerBound) {
-        if (0 < continuousDx) {
-          ret.dx = +2; 
-          ret.dy = -1;
-          ret.encodedIdx = 7;
-        } else {
-          ret.dx = -2; 
-          ret.dy = +1;
-          ret.encodedIdx = 8;
-        }
-      } else {
-        if (Math.abs(criticalRatio) < 1) {
-          ret.dy = 0;
-          if (0 < continuousDx) {
-            ret.dx = +2; 
-            ret.encodedIdx = 9;
-          } else {
-            ret.dx = -2; 
-            ret.encodedIdx = 10;
-          }
-        } else {
-          ret.dx = 0;
-          if (0 < continuousDy) {
-            ret.dy = +1; 
-            ret.encodedIdx = 11;
-          } else {
-            ret.dy = -1; 
-            ret.encodedIdx = 12;
-          }
-        }
       }
     }
+
     return ret;
   },
 
   decodeDirection(encodedDirection) {
     const mapped = window.DIRECTION_DECODER[encodedDirection];
     if (null == mapped) {
-        console.error("Unexpected encodedDirection = ", encodedDirection);
+      console.error("Unexpected encodedDirection = ", encodedDirection);
     }
     return {
       dx: mapped[0],
-      dy: mapped[1], 
-      speedFactor: mapped[2],
-    }
+      dy: mapped[1],
+    };
   },
 
   getDiscretizedDirection() {
-    return this.discretizeDirection(this.cachedStickHeadPosition.x, this.cachedStickHeadPosition.y, this.joyStickEps); 
+    return this.discretizeDirection(this.cachedStickHeadPosition.x, this.cachedStickHeadPosition.y, this.joyStickEps);
   }
 });

frontend/assets/scripts/WsSessionMgr.js

@@ -104,18 +104,6 @@ window.getExpectedRoomIdSync = function() {
   return null;
 };
 
-window.unsetClientSessionCloseOrErrorFlag = function() {
-  cc.sys.localStorage.removeItem("ClientSessionCloseOrErrorFlag");
-  return;
-}
-
-window.setClientSessionCloseOrErrorFlag = function() {
-  const oldVal = cc.sys.localStorage.getItem("ClientSessionCloseOrErrorFlag");
-  if (true == oldVal) return false;
-  cc.sys.localStorage.setItem("ClientSessionCloseOrErrorFlag", true);
-  return true;
-}
-
 window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
   if (window.clientSession && window.clientSession.readyState == WebSocket.OPEN) {
     if (null != onopenCb) {
@@ -124,7 +112,9 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
     return;
   }
 
-  const intAuthToken = cc.sys.localStorage.getItem("selfPlayer") ? JSON.parse(cc.sys.localStorage.getItem('selfPlayer')).intAuthToken : "";
+  const selfPlayerStr = cc.sys.localStorage.getItem("selfPlayer");
+  const selfPlayer = null == selfPlayerStr ? null : JSON.parse(selfPlayerStr);
+  const intAuthToken = null == selfPlayer ? "" : selfPlayer.intAuthToken;
 
   let urlToConnect = backendAddress.PROTOCOL.replace('http', 'ws') + '://' + backendAddress.HOST + ":" + backendAddress.PORT + backendAddress.WS_PATH_PREFIX + "?intAuthToken=" + intAuthToken;
 
@@ -144,19 +134,19 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
   const clientSession = new WebSocket(urlToConnect);
   clientSession.binaryType = 'arraybuffer'; // Make 'event.data' of 'onmessage' an "ArrayBuffer" instead of a "Blob"
 
-  clientSession.onopen = function(event) {
-    console.log("The WS clientSession is opened.");
+  clientSession.onopen = function(evt) {
+    console.log("The WS clientSession is opened. clientSession.id=", clientSession.id);
     window.clientSession = clientSession;
     if (null == onopenCb) return;
     onopenCb();
   };
 
-  clientSession.onmessage = function(event) {
-    if (null == event || null == event.data) {
+  clientSession.onmessage = function(evt) {
+    if (null == evt || null == evt.data) {
       return;
     }
     try {
-      const resp = window.WsResp.decode(new Uint8Array(event.data));
+      const resp = window.pb.protos.WsResp.decode(new Uint8Array(evt.data));
       switch (resp.act) {
         case window.DOWNSYNC_MSG_ACT_HB_REQ:
           window.handleHbRequirements(resp); // 获取boundRoomId并存储到localStorage
@@ -166,10 +156,10 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
           break;
         case window.DOWNSYNC_MSG_ACT_PLAYER_READDED_AND_ACKED:
           // Deliberately left blank for now
-          mapIns.hideFindingPlayersGUI();
+          mapIns.hideFindingPlayersGUI(resp.rdf);
           break;
         case window.DOWNSYNC_MSG_ACT_BATTLE_READY_TO_START:
-          mapIns.onBattleReadyToStart(resp.rdf.playerMetas);
+          mapIns.onBattleReadyToStart(resp.rdf);
           break;
         case window.DOWNSYNC_MSG_ACT_BATTLE_START:
           mapIns.onRoomDownsyncFrame(resp.rdf);
@@ -182,72 +172,61 @@ window.initPersistentSessionClient = function(onopenCb, expectedRoomId) {
           break;
         case window.DOWNSYNC_MSG_ACT_FORCED_RESYNC:
           if (null == resp.inputFrameDownsyncBatch || 0 >= resp.inputFrameDownsyncBatch.length) {
-            console.error("Got empty inputFrameDownsyncBatch upon resync@localRenderFrameId=", mapIns.renderFrameId, ", @lastAllConfirmedRenderFrameId=", mapIns.lastAllConfirmedRenderFrameId, "@lastAllConfirmedInputFrameId=", mapIns.lastAllConfirmedInputFrameId, ", @localRecentInputCache=", mapIns._stringifyRecentInputCache(false), ", the incoming resp=\n", JSON.stringify(resp, null, 2));
+            console.error(`Got empty inputFrameDownsyncBatch upon resync@localRenderFrameId=${mapIns.renderFrameId}, @lastAllConfirmedRenderFrameId=${mapIns.lastAllConfirmedRenderFrameId}, @lastAllConfirmedInputFrameId=${mapIns.lastAllConfirmedInputFrameId}, @chaserRenderFrameId=${mapIns.chaserRenderFrameId}, @localRecentInputCache=${mapIns._stringifyRecentInputCache(false)}, the incoming resp=
+${JSON.stringify(resp, null, 2)}`);
             return;
           }
-          // Unless upon ws session lost and reconnected, it's maintained true that "inputFrameDownsyncBatch[0].inputFrameId == frontend.lastAllConfirmedInputFrameId+1", and in this case we should try to keep frontend moving only by "frontend.recentInputCache" to avoid jiggling of synced positions 
           const inputFrameIdConsecutive = (resp.inputFrameDownsyncBatch[0].inputFrameId == mapIns.lastAllConfirmedInputFrameId + 1);
           const renderFrameIdConsecutive = (resp.rdf.id <= mapIns.renderFrameId + mapIns.renderFrameIdLagTolerance);
-          if (inputFrameIdConsecutive && renderFrameIdConsecutive) {
-            console.log("Got consecutive resync@localRenderFrameId=", mapIns.renderFrameId, ", @lastAllConfirmedRenderFrameId=", mapIns.lastAllConfirmedRenderFrameId, "@lastAllConfirmedInputFrameId=", mapIns.lastAllConfirmedInputFrameId, ", @localRecentInputCache=", mapIns._stringifyRecentInputCache(false), ", the incoming resp=\n", JSON.stringify(resp));
-            mapIns.onInputFrameDownsyncBatch(resp.inputFrameDownsyncBatch);
-          } else {
-            console.warn("Got forced resync@localRenderFrameId=", mapIns.renderFrameId, ", @lastAllConfirmedRenderFrameId=", mapIns.lastAllConfirmedRenderFrameId, "@lastAllConfirmedInputFrameId=", mapIns.lastAllConfirmedInputFrameId, ", @localRecentInputCache=", mapIns._stringifyRecentInputCache(false), ", the incoming resp=\n", JSON.stringify(resp, null, 2));
-            // The following order of execution is important 
-            const dumpRenderCacheRet = mapIns.onRoomDownsyncFrame(resp.rdf);
-            mapIns.onInputFrameDownsyncBatch(resp.inputFrameDownsyncBatch, dumpRenderCacheRet);
-          }
+          console.warn(`Got resync@localRenderFrameId=${mapIns.renderFrameId}, @lastAllConfirmedRenderFrameId=${mapIns.lastAllConfirmedRenderFrameId}, @lastAllConfirmedInputFrameId=${mapIns.lastAllConfirmedInputFrameId}, @chaserRenderFrameId=${mapIns.chaserRenderFrameId}, @localRecentInputCache=${mapIns._stringifyRecentInputCache(false)}, inputFrameIdConsecutive=${inputFrameIdConsecutive}, renderFrameIdConsecutive=${renderFrameIdConsecutive}`);
+          // The following order of execution is important 
+          mapIns.onRoomDownsyncFrame(resp.rdf);
+          mapIns.onInputFrameDownsyncBatch(resp.inputFrameDownsyncBatch);
           break;
         default:
           break;
       }
     } catch (e) {
-      console.error("Unexpected error when parsing data of:", event.data, e);
+      console.error("Unexpected error when parsing data of:", evt.data, e);
     }
   };
 
-  clientSession.onerror = function(event) {
-    if (!window.setClientSessionCloseOrErrorFlag()) {
-      return;
+  clientSession.onerror = function(evt) {
+    console.error("Error caught on the WS clientSession: ", evt);
+    if (window.handleClientSessionError) {
+      window.handleClientSessionError();
     }
-    console.error("Error caught on the WS clientSession: ", event);
-    if (window.clientSessionPingInterval) {
-      clearInterval(window.clientSessionPingInterval);
-    }
-    if (window.handleClientSessionCloseOrError) {
-      window.handleClientSessionCloseOrError();
-    }
-    window.unsetClientSessionCloseOrErrorFlag();
   };
 
-  clientSession.onclose = function(event) {
-    if (!window.setClientSessionCloseOrErrorFlag()) {
-      return;
-    }
-    console.warn("The WS clientSession is closed: ", event);
-    if (window.clientSessionPingInterval) {
-      clearInterval(window.clientSessionPingInterval);
-    }
-    if (false == event.wasClean) {
-      // Chrome doesn't allow the use of "CustomCloseCode"s (yet) and will callback with a "WebsocketStdCloseCode 1006" and "false == event.wasClean" here. See https://tools.ietf.org/html/rfc6455#section-7.4 for more information.
-      if (window.handleClientSessionCloseOrError) {
-        window.handleClientSessionCloseOrError();
+  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);
+    if (false == evt.wasClean) {
+      /*
+      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.
+      */
+      if (window.handleClientSessionError) {
+        window.handleClientSessionError();
       }
     } else {
-      switch (event.code) {
+      switch (evt.code) {
+        case constants.RET_CODE.PLAYER_NOT_ADDABLE_TO_ROOM:
+        case constants.RET_CODE.PLAYER_NOT_READDABLE_TO_ROOM:
+          window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
+          break;
+        case constants.RET_CODE.UNKNOWN_ERROR:
+        case constants.RET_CODE.MYSQL_ERROR:
         case constants.RET_CODE.PLAYER_NOT_FOUND:
         case constants.RET_CODE.PLAYER_CHEATING:
-          window.clearBoundRoomIdInBothVolatileAndPersistentStorage();
+        case 1006: // Peer(i.e. the backend) gone unexpectedly 
+          if (window.handleClientSessionError) {
+            window.handleClientSessionError();
+          }
           break;
         default:
           break;
       }
-
-      if (window.handleClientSessionCloseOrError) {
-        window.handleClientSessionCloseOrError();
-      }
     }
-    window.unsetClientSessionCloseOrErrorFlag();
   };
 };
 
@@ -258,17 +237,17 @@ window.clearLocalStorageAndBackToLoginScene = function(shouldRetainBoundRoomIdIn
     window.mapIns.musicEffectManagerScriptIns.stopAllMusic();
   }
   /**
-   * Here I deliberately removed the callback in the "common `handleClientSessionCloseOrError` callback"
+   * 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.handleClientSessionCloseOrError = () => {
-    console.warn("+++++++ Special handleClientSessionCloseOrError() assigned within `clearLocalStorageAndBackToLoginScene`");
+  window.handleClientSessionError = () => {
+    console.warn("+++++++ Special handleClientSessionError() assigned within `clearLocalStorageAndBackToLoginScene`");
     // TBD.
-    window.handleClientSessionCloseOrError = null; // To ensure that it's called at most once. 
+    window.handleClientSessionError = null; // To ensure that it's called at most once. 
   };
   window.closeWSConnection();
   window.clearSelfPlayer();

frontend/assets/scripts/modules/protobuf-with-floating-num-decoding-endianess-toggle.js.meta

@@ -1,6 +1,6 @@
 {
   "ver": "1.0.5",
-  "uuid": "f9cd97f6-3533-4a27-afc8-cf302da003b2",
+  "uuid": "1ef4a156-5c54-45b9-85ac-86734985e13a",
   "isPlugin": false,
   "loadPluginInWeb": true,
   "loadPluginInNative": true,

frontend/assets/scripts/modules/protobuf.js.map.meta

@@ -1,5 +0,0 @@
-{
-  "ver": "1.0.1",
-  "uuid": "e646fbd9-7821-4567-9846-fb6e45aeb921",
-  "subMetas": {}
-}

frontend/collision_test_nodejs.js

@@ -0,0 +1,39 @@
+const collisions = require('./assets/scripts/modules/Collisions');
+
+const collisionSys = new collisions.Collisions();
+
+function polygonStr(body) {
+  let coords = [];
+  let cnt = body._coords.length;
+  for (let ix = 0, iy = 1; ix < cnt; ix += 2, iy += 2) {
+    coords.push([body._coords[ix], body._coords[iy]]);
+  }
+  return JSON.stringify(coords);
+}
+
+const playerCollider = collisionSys.createPolygon(1269.665, 1353.335, [[0, 0], [64, 0], [64, 64], [0, 64]]);
+
+const barrierCollider1 = collisionSys.createPolygon(1277.7159000000001, 1570.5575, [[642.5696, 319.159], [0, 319.15680000000003], [5.7286, 0], [643.7451, 0.9014999999999986]]);
+const barrierCollider2 = collisionSys.createPolygon(1289.039, 1318.0805, [[628.626, 54.254500000000064], [0, 56.03250000000003], [0.42449999999999477, 1.1229999999999905], [625.9715000000001, 0]]);
+const barrierCollider3 = collisionSys.createPolygon(1207, 1310, [[69, 581], [0, 579], [8, 3], [79, 0]]);
+
+playerCollider.x += -2.98;
+playerCollider.y += -50.0;
+collisionSys.update();
+
+const effPushback = [0.0, 0.0];
+
+const result = collisionSys.createResult();
+
+const potentials = playerCollider.potentials();
+
+for (const barrier of potentials) {
+  if (!playerCollider.collides(barrier, result)) continue;
+  const pushbackX = result.overlap * result.overlap_x; 
+  const pushbackY = result.overlap * result.overlap_y; 
+  console.log(`Overlapped: a=${polygonStr(result.a)}, b=${polygonStr(result.b)}, pushbackX=${pushbackX}, pushbackY=${pushbackY}`);
+  effPushback[0] += pushbackX;
+  effPushback[1] += pushbackY;
+}
+
+console.log(`effPushback=${effPushback}`);

proto_gen_shortcut.sh

@@ -2,11 +2,16 @@
 
 # GOLANG part
 # You have to download the OS binary "protoc" from `https://developers.google.com/protocol-buffers/docs/downloads` and set it to $PATH appropriately.
-# You have to install `proto-gen-go` by `go get -u github.com/golang/protobuf/protoc-gen-go` as instructed in https://developers.google.com/protocol-buffers/docs/gotutorial too.
+# You have to install `proto-gen-go` by `go install google.golang.org/protobuf/cmd/protoc-gen-go@latest` as instructed in https://developers.google.com/protocol-buffers/docs/gotutorial#compiling-your-protocol-buffers too.
 
-golang_basedir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/battle_srv
-mkdir -p $golang_basedir/pb_output
-protoc -I=$golang_basedir/../frontend/assets/resources/pbfiles/ --go_out=$golang_basedir/pb_output room_downsync_frame.proto 
+golang_basedir_1=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/dnmshared
+protoc -I=$golang_basedir_1/../frontend/assets/resources/pbfiles/ --go_out=. geometry.proto 
+echo "GOLANG part 1 done"
+
+# [WARNING] The following "room_downsync_frame.proto" is generated in another Go package than "geometry.proto", but the generated Go codes are also required to work with imports correctly!
+golang_basedir_2=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/battle_srv
+protoc -I=$golang_basedir_2/../frontend/assets/resources/pbfiles/ --go_out=. room_downsync_frame.proto 
+echo "GOLANG part 2 done"
 
 # JS part
 js_basedir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/frontend
@@ -17,6 +22,8 @@ js_outdir=$js_basedir/assets/scripts/modules
 # npm install -g protobufjs-cli 
 
 # The specific filename is respected by "frontend/build-templates/wechatgame/game.js".
-pbjs -t static-module -w commonjs --keep-case --force-message -o $js_outdir/room_downsync_frame_proto_bundle.forcemsg.js $js_basedir/assets/resources/pbfiles/room_downsync_frame.proto
+pbjs -t static-module -w commonjs --keep-case --force-message -o $js_outdir/room_downsync_frame_proto_bundle.forcemsg.js $js_basedir/assets/resources/pbfiles/geometry.proto $js_basedir/assets/resources/pbfiles/room_downsync_frame.proto
 
-sed -i 's#require("protobufjs/minimal")#require("./protobuf-with-floating-num-decoding-endianess-toggle")#g' $js_outdir/room_downsync_frame_proto_bundle.forcemsg.js
+sed -i 's#require("protobufjs/minimal")#require("./protobuf-with-floating-num-decoding-endianess-toggle")#g' $js_outdir/room_downsync_frame_proto_bundle.forcemsg.js # Not working in OSX, needs further investigation
+
+echo "JavaScript part done"