Minor update.

battle_srv/api/v1/player.go

@@ -85,7 +85,6 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 		c.Set(api.RET, Constants.RetCode.SmsCaptchaRequestedTooFrequently)
 		return
 	}
-	Logger.Info("A new SmsCaptcha record is needed for: ", zap.String("key", redisKey))
 	pass := false
 	var succRet int
 	if Conf.General.ServerEnv == SERVER_ENV_TEST {
@@ -93,32 +92,28 @@ func (p *playerController) SMSCaptchaGet(c *gin.Context) {
 		if nil == err && nil != player {
 			pass = true
 			succRet = Constants.RetCode.IsTestAcc
+			Logger.Info("A new SmsCaptcha record is needed for: ", zap.String("key", redisKey), zap.Any("player", player))
 		}
 	}
 
-	if !pass {
+	/*
-		player, err := models.GetPlayerByName(req.Num)
+		    // Real phonenum is not supported yet!
-		if nil == err && nil != player {
+			if !pass {
-			pass = true
+				if RE_PHONE_NUM.MatchString(req.Num) {
-			succRet = Constants.RetCode.IsBotAcc
+					succRet = Constants.RetCode.Ok
-		}
+					pass = true
-	}
+				}
-
+				if req.CountryCode == "86" {
-	if !pass {
+					if RE_CHINA_PHONE_NUM.MatchString(req.Num) {
-		if RE_PHONE_NUM.MatchString(req.Num) {
+						succRet = Constants.RetCode.Ok
-			succRet = Constants.RetCode.Ok
+						pass = true
-			pass = true
+					} else {
-		}
+						succRet = Constants.RetCode.InvalidRequestParam
-		if req.CountryCode == "86" {
+						pass = false
-			if RE_CHINA_PHONE_NUM.MatchString(req.Num) {
+					}
-				succRet = Constants.RetCode.Ok
+				}
-				pass = true
-			} else {
-				succRet = Constants.RetCode.InvalidRequestParam
-				pass = false
 			}
-		}
+	*/
-	}
 	if !pass {
 		c.Set(api.RET, Constants.RetCode.InvalidRequestParam)
 		return
@@ -481,16 +476,6 @@ 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 {
-		botPlayer, err := models.GetPlayerByName(req.Num)
-		if err != nil {
-			Logger.Error("Seeking bot player error:", zap.Error(err))
-			return nil, err
-		}
-		if botPlayer != nil {
-			Logger.Info("Got a bot player:", zap.Any("phonenum", req.Num), zap.Any("playerId", botPlayer.Id))
-			return botPlayer, nil
-		}
 	}
 
 	bind, err := models.GetPlayerAuthBinding(Constants.AuthChannel.Sms, extAuthID)

battle_srv/api/v1/player_test.go

@@ -74,7 +74,7 @@ func Test_SMSCaptchaGet_illegalPhone(t *testing.T) {
 
 func Test_SMSCaptchaGet_testAcc(t *testing.T) {
 	player, err := getTestPlayer()
-	if err == nil && player != nil {
+	if nil == err && nil != player {
 		resp := mustDoSmsCaptchaGetReq(fakeSMSCaptchReq(player.Name), t)
 		if resp.Ret != Constants.RetCode.IsTestAcc {
 			t.Fail()

battle_srv/models/player.go

@@ -77,13 +77,14 @@ func getPlayer(cond sq.Eq) (*Player, error) {
 		return nil, err
 	}
 	rows, err := storage.MySQLManagerIns.Queryx(query, args...)
-	if err != nil {
+	if nil != err {
 		return nil, err
 	}
 	cols, err := rows.Columns()
 	if nil != err {
 		panic(err)
 	}
+	cnt := 0
 	for rows.Next() {
 		// TODO: Do it more elegantly, but by now I don't have time to learn reflection of Golang
 		vals := rowValues(rows, cols)
@@ -105,9 +106,14 @@ func getPlayer(cond sq.Eq) (*Player, error) {
 			}
 		}
 		Logger.Debug("Queried player from db", zap.Any("cond", cond), zap.Any("p", p), zap.Any("pd", pd), zap.Any("cols", cols), zap.Any("rowValues", vals))
+		cnt++
+	}
+	if 0 < cnt {
+		p.PlayerDownsync = pd
+		return &p, nil
+	} else {
+		return nil, nil
 	}
-	p.PlayerDownsync = pd
-	return &p, nil
 }
 
 func (p *Player) Insert(tx *sqlx.Tx) error {

battle_srv/models/room.go

@@ -407,6 +407,9 @@ func (pR *Room) rdfIdToActuallyUsedInputString() string {
 		}
 		fireballsStrBldr := make([]string, 0, len(rdf.FireballBullets))
 		for _, fireball := range rdf.FireballBullets {
+			if 0 > fireball.BattleAttr.BulletLocalId {
+				break
+			}
 			fireballsStrBldr = append(fireballsStrBldr, pR.fireballDownsyncStr(fireball))
 		}
 		s = append(s, fmt.Sprintf("rdfId:%d\nplayers:[%v]\nfireballs:[%v]\nactuallyUsedinputList:{%v}", rdfId, strings.Join(playersStrBldr, ","), strings.Join(fireballsStrBldr, ","), pR.inputFrameDownsyncStr(pR.rdfIdToActuallyUsedInput[rdfId])))
@@ -801,7 +804,7 @@ func (pR *Room) OnDismissed() {
 	pR.PlayerSignalToCloseDict = make(map[int32]SignalToCloseConnCbType)
 	pR.PlayerSecondarySignalToCloseDict = make(map[int32]SignalToCloseConnCbType)
 	pR.JoinIndexBooleanArr = make([]bool, pR.Capacity)
-	pR.RenderCacheSize = 256
+	pR.RenderCacheSize = 1024
 	pR.RenderFrameBuffer = resolv.NewRingBuffer(pR.RenderCacheSize)
 	pR.InputsBuffer = resolv.NewRingBuffer((pR.RenderCacheSize >> 1) + 1)
 	pR.rdfIdToActuallyUsedInput = make(map[int32]*pb.InputFrameDownsync)
@@ -1313,7 +1316,7 @@ func (pR *Room) forceConfirmationIfApplicable(prevRenderFrameId int32) uint64 {
 			pR.onInputFrameDownsyncAllConfirmed(inputFrameDownsync, -1)
 		}
 		if 0 < unconfirmedMask {
-			Logger.Info(fmt.Sprintf("[type#1 forceConfirmation] For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, LatestPlayerUpsyncedInputFrameId:%d, oldLastAllConfirmedInputFrameId:%d, newLastAllConfirmedInputFrameId:%d, InputFrameUpsyncDelayTolerance:%d, unconfirmedMask=%d; there's a slow ticker suspect, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LatestPlayerUpsyncedInputFrameId, oldLastAllConfirmedInputFrameId, pR.LastAllConfirmedInputFrameId, pR.InputFrameUpsyncDelayTolerance, unconfirmedMask))
+			Logger.Info(fmt.Sprintf("[type#1 forceConfirmation] For roomId=%d@renderFrameId=%d, curDynamicsRenderFrameId=%d, LatestPlayerUpsyncedInputFrameId:%d, LastAllConfirmedInputFrameId:%d -> %d, InputFrameUpsyncDelayTolerance:%d, unconfirmedMask=%d; there's a slow ticker suspect, forcing all-confirmation", pR.Id, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, pR.LatestPlayerUpsyncedInputFrameId, oldLastAllConfirmedInputFrameId, pR.LastAllConfirmedInputFrameId, pR.InputFrameUpsyncDelayTolerance, unconfirmedMask))
 		}
 	} else {
 		// Type#2 helps resolve the edge case when all players are disconnected temporarily
@@ -1539,6 +1542,7 @@ func (pR *Room) downsyncToAllPlayers(inputsBufferSnapshot *pb.InputsBufferSnapsh
 				break
 			}
 		}
+
 	}
 
 	for _, player := range pR.PlayersArr {
@@ -1555,11 +1559,16 @@ func (pR *Room) downsyncToAllPlayers(inputsBufferSnapshot *pb.InputsBufferSnapsh
 
 		if playerDownsyncChan, existent := pR.PlayerDownsyncChanDict[player.Id]; existent {
 			playerDownsyncChan <- (*inputsBufferSnapshot)
-			//Logger.Info(fmt.Sprintf("Sent inputsBufferSnapshot(refRenderFrameId:%d, unconfirmedMask:%v) to for (roomId: %d, playerId:%d, playerDownsyncChan:%p)#1", inputsBufferSnapshot.RefRenderFrameId, inputsBufferSnapshot.UnconfirmedMask, pR.Id, player.Id, playerDownsyncChan))
+			//Logger.Info(fmt.Sprintf("Sent inputsBufferSnapshot{refRenderFrameId:%d, unconfirmedMask:%v} to {roomId: %d, playerId:%d, playerDownsyncChan:%p}#1", inputsBufferSnapshot.RefRenderFrameId, inputsBufferSnapshot.UnconfirmedMask, pR.Id, player.Id, playerDownsyncChan))
 		} else {
 			Logger.Warn(fmt.Sprintf("playerDownsyncChan for (roomId: %d, playerId:%d) is gone", pR.Id, player.Id))
 		}
 	}
+	/*
+		toSendInputFrameDownsyncs := inputsBufferSnapshot.ToSendInputFrameDownsyncs
+		toSendInputFrameIdSt, toSendInputFrameIdEd := toSendInputFrameDownsyncs[0].InputFrameId, toSendInputFrameDownsyncs[len(toSendInputFrameDownsyncs)-1].InputFrameId+1
+		Logger.Info(fmt.Sprintf("Sent inputsBufferSnapshot{refRenderFrameId:%d, unconfirmedMask:%v, inputFrameIdRange:[%d, %d)} to {roomId: %d}", inputsBufferSnapshot.RefRenderFrameId, inputsBufferSnapshot.UnconfirmedMask, toSendInputFrameIdSt, toSendInputFrameIdEd, pR.Id))
+	*/
 }
 
 func (pR *Room) downsyncToSinglePlayer(playerId int32, player *Player, refRenderFrameId int32, unconfirmedMask uint64, toSendInputFrameDownsyncsSnapshot []*pb.InputFrameDownsync, shouldForceResync bool) {
@@ -1602,9 +1611,10 @@ func (pR *Room) downsyncToSinglePlayer(playerId int32, player *Player, refRender
 		pbRefRenderFrame := toPbRoomDownsyncFrame(refRenderFrame)
 		pbRefRenderFrame.SpeciesIdList = pR.SpeciesIdList
 		pR.sendSafely(pbRefRenderFrame, toSendInputFrameDownsyncsSnapshot, DOWNSYNC_MSG_ACT_FORCED_RESYNC, playerId, false, MAGIC_JOIN_INDEX_DEFAULT)
-		//Logger.Warn(fmt.Sprintf("Sent refRenderFrameId=%v & inputFrameIds [%d, %d), for roomId=%v, playerId=%d, playerJoinIndex=%d, renderFrameId=%d, curDynamicsRenderFrameId=%d, playerLastSentInputFrameId=%d: InputsBuffer=%v", refRenderFrameId, toSendInputFrameIdSt, toSendInputFrameIdEd, pR.Id, playerId, player.JoinIndex, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, player.LastSentInputFrameId, pR.InputsBufferString(false)))
 		if shouldResync1 || shouldResync3 {
 			Logger.Debug(fmt.Sprintf("Sent refRenderFrameId=%v & inputFrameIds [%d, %d), for roomId=%v, playerId=%d, playerJoinIndex=%d, renderFrameId=%d, curDynamicsRenderFrameId=%d, playerLastSentInputFrameId=%d: shouldResync1=%v, shouldResync2=%v, shouldResync3=%v, playerBattleState=%d", refRenderFrameId, toSendInputFrameIdSt, toSendInputFrameIdEd, pR.Id, playerId, player.JoinIndex, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, player.LastSentInputFrameId, shouldResync1, shouldResync2, shouldResync3, playerBattleState))
+		} else {
+			//Logger.Debug(fmt.Sprintf("Sent refRenderFrameId=%v & inputFrameIds [%d, %d), for roomId=%v, playerId=%d, playerJoinIndex=%d, renderFrameId=%d, curDynamicsRenderFrameId=%d, playerLastSentInputFrameId=%d: InputsBuffer=%v", refRenderFrameId, toSendInputFrameIdSt, toSendInputFrameIdEd, pR.Id, playerId, player.JoinIndex, pR.RenderFrameId, pR.CurDynamicsRenderFrameId, player.LastSentInputFrameId, pR.InputsBufferString(false)))
 		}
 	} else {
 		pR.sendSafely(nil, toSendInputFrameDownsyncsSnapshot, DOWNSYNC_MSG_ACT_INPUT_BATCH, playerId, false, MAGIC_JOIN_INDEX_DEFAULT)

frontend/assets/resources/prefabs/FindingPlayer.prefab

@@ -241,7 +241,7 @@
       "ctor": "Float64Array",
       "array": [
         -379.577,
-        90.576,
+        140,
         0,
         0,
         0,
@@ -468,7 +468,7 @@
       "ctor": "Float64Array",
       "array": [
         0,
-        -68.939,
+        -13.057,
         0,
         0,
         0,

frontend/assets/scenes/default_map.fire

@@ -400,7 +400,7 @@
       "ctor": "Float64Array",
       "array": [
         0,
-        0,
+        32,
         0,
         0,
         0,
@@ -536,7 +536,7 @@
       "array": [
         0,
         0,
-        216.05530045313827,
+        210.43877906529718,
         0,
         0,
         0,
@@ -2129,7 +2129,7 @@
     "_left": 0,
     "_right": 0,
     "_top": 0,
-    "_bottom": 640,
+    "_bottom": 672,
     "_verticalCenter": 0,
     "_horizontalCenter": 0,
     "_isAbsLeft": true,

frontend/assets/scenes/login.fire

@@ -461,7 +461,7 @@
       "array": [
         0,
         0,
-        210.43877906529718,
+        209.57814771583418,
         0,
         0,
         0,

frontend/assets/scenes/offline_map.fire

@@ -382,7 +382,7 @@
       "ctor": "Float64Array",
       "array": [
         0,
-        0,
+        32,
         0,
         0,
         0,
@@ -518,7 +518,7 @@
       "array": [
         0,
         0,
-        216.50635094610968,
+        217.5376534000385,
         0,
         0,
         0,

frontend/assets/scripts/Map.js

@@ -714,6 +714,11 @@ cc.Class({
       shouldForceDumping2 = false;
       shouldForceResync = false;
       self.othersForcedDownsyncRenderFrameDict.set(rdfId, rdf);
+      if (CC_DEBUG) {
+        console.warn(`Someone else is forced to resync! renderFrameId=${rdf.GetId()}
+backendUnconfirmedMask=${pbRdf.backendUnconfirmedMask}
+accompaniedInputFrameDownsyncBatchRange=[${null == accompaniedInputFrameDownsyncBatch ? null : accompaniedInputFrameDownsyncBatch[0].inputFrameId}, ${null == accompaniedInputFrameDownsyncBatch ? null : accompaniedInputFrameDownsyncBatch[accompaniedInputFrameDownsyncBatch.length - 1].inputFrameId}]`);
+      }
     }
     /*
     TODO
@@ -744,10 +749,15 @@ cc.Class({
       // In fact, not having "window.RING_BUFF_CONSECUTIVE_SET == dumpRenderCacheRet" should already imply that "self.renderFrameId <= rdfId", but here we double check and log the anomaly  
 
       if (window.MAGIC_ROOM_DOWNSYNC_FRAME_ID.BATTLE_START == rdfId) {
-        console.log('On battle started! renderFrameId=', rdfId);
+        console.log(`On battle started! renderFrameId=${rdfId}`);
       } else {
         self.hideFindingPlayersGUI();
-        console.warn('On battle resynced! renderFrameId=', rdf.GetId());
+        if (CC_DEBUG) {
+          console.warn(`On battle resynced! renderFrameId=${rdf.GetId()}
+accompaniedInputFrameDownsyncBatchRange=[${accompaniedInputFrameDownsyncBatch[0].inputFrameId}, ${accompaniedInputFrameDownsyncBatch[accompaniedInputFrameDownsyncBatch.length - 1].inputFrameId}]`);
+        } else {
+          console.warn(`On battle resynced! renderFrameId=${rdf.GetId()}`);
+        }
       }
 
       self.renderFrameId = rdfId;
@@ -865,13 +875,20 @@ cc.Class({
   _markConfirmationIfApplicable() {
     const self = this;
     let newAllConfirmedCnt = 0;
-    while (self.recentInputCache.GetStFrameId() <= self.lastAllConfirmedInputFrameId && self.lastAllConfirmedInputFrameId < self.recentInputCache.GetEdFrameId()) {
+    let candidateInputFrameId = (self.lastAllConfirmedInputFrameId + 1);
-      const inputFrameDownsync = self.recentInputCache.GetByFrameId(self.lastAllConfirmedInputFrameId);
+    if (candidateInputFrameId < self.recentInputCache.GetStFrameId()) {
+      candidateInputFrameId = self.recentInputCache.GetStFrameId();
+    }
+    while (self.recentInputCache.GetStFrameId() <= candidateInputFrameId && candidateInputFrameId < self.recentInputCache.GetEdFrameId()) {
+      const inputFrameDownsync = gopkgs.GetInputFrameDownsync(self.recentInputCache, candidateInputFrameId);
       if (null == inputFrameDownsync) break;
-      if (self._allConfirmed(inputFrameDownsync.ConfirmedList)) break;
+      if (false == self._allConfirmed(inputFrameDownsync.GetConfirmedList())) break;
-      ++self.lastAllConfirmedInputFrameId;
+      ++candidateInputFrameId;
       ++newAllConfirmedCnt;
     }
+    if (0 < newAllConfirmedCnt) {
+      self.lastAllConfirmedInputFrameId = candidateInputFrameId - 1;
+    }
     return newAllConfirmedCnt;
   },
 
@@ -898,18 +915,17 @@ cc.Class({
       }
       // [WARNING] Now that "inputFrameDownsyncId > self.lastAllConfirmedInputFrameId", we should make an update immediately because unlike its backend counterpart "Room.LastAllConfirmedInputFrameId", the frontend "mapIns.lastAllConfirmedInputFrameId" might inevitably get gaps among discrete values due to "either type#1 or type#2 forceConfirmation" -- and only "onInputFrameDownsyncBatch" can catch this! 
       self.lastAllConfirmedInputFrameId = inputFrameDownsyncId;
-
+      const localInputFrame = gopkgs.GetInputFrameDownsync(self.recentInputCache, inputFrameDownsyncId);
-      const localInputFrame = self.recentInputCache.GetByFrameId(inputFrameDownsyncId);
       if (null != localInputFrame
         &&
         null == firstPredictedYetIncorrectInputFrameId
         &&
-        !self.equalInputLists(localInputFrame.InputList, inputFrameDownsync.inputList)
+        !self.equalInputLists(localInputFrame.GetInputList(), inputFrameDownsync.inputList)
       ) {
         firstPredictedYetIncorrectInputFrameId = inputFrameDownsyncId;
       }
       // [WARNING] Take all "inputFrameDownsync" from backend as all-confirmed, it'll be later checked by "rollbackAndChase". 
-      inputFrameDownsync.confirmedList = (1 << self.playerRichInfoDict.size) - 1;
+      inputFrameDownsync.confirmedList = (1 << window.boundRoomCapacity) - 1;
       const inputFrameDownsyncLocal = gopkgs.NewInputFrameDownsync(inputFrameDownsync.inputFrameId, inputFrameDownsync.inputList, inputFrameDownsync.confirmedList); // "battle.InputFrameDownsync" in "jsexport"
       for (let j in self.playerRichInfoArr) {
         const jj = parseInt(j);
@@ -952,7 +968,7 @@ cc.Class({
 firstPredictedYetIncorrectInputFrameId: ${firstPredictedYetIncorrectInputFrameId}
 lastAllConfirmedInputFrameId=${self.lastAllConfirmedInputFrameId}
 recentInputCache=${self._stringifyRecentInputCache(false)}
-batchInputFrameIdRange=[${batch[0].inputFrameId}, ${batch[batch.length - 1].inputFrameId}]
+batchInputFrameIdRange=[${null == batch ? null : batch[0].inputFrameId}, ${null == batch ? null : batch[batch.length - 1].inputFrameId}]
 fromUDP=${fromUDP}`);
     }
     self.chaserRenderFrameId = renderFrameId1;
@@ -995,8 +1011,9 @@ fromUDP=${fromUDP}`);
       }
       const peerJoinIndexMask = (1 << (peerJoinIndex - 1));
       self.getOrPrefabInputFrameUpsync(inputFrameId, false); // Make sure that inputFrame exists locally
-      const existingInputFrame = self.recentInputCache.GetByFrameId(inputFrameId);
+      const existingInputFrame = gopkgs.GetInputFrameDownsync(self.recentInputCache, inputFrameId);
-      if (0 < (existingInputFrame.ConfirmedList & peerJoinIndexMask)) {
+      const existingConfirmedList = existingInputFrame.GetConfirmedList();
+      if (0 < (existingConfirmedList & peerJoinIndexMask)) {
         continue;
       }
       if (inputFrameId > self.lastIndividuallyConfirmedInputFrameId[peerJoinIndex - 1]) {
@@ -1005,9 +1022,10 @@ fromUDP=${fromUDP}`);
       }
       effCnt += 1;
       // the returned "gopkgs.NewInputFrameDownsync.InputList" is immutable, thus we can only modify the values in "newInputList" and "newConfirmedList"!
-      let newInputList = existingInputFrame.InputList.slice();
+      const existingInputList = existingInputFrame.GetInputList();
+      let newInputList = existingInputFrame.GetInputList().slice();
       newInputList[peerJoinIndex - 1] = peerEncodedInput;
-      let newConfirmedList = (existingInputFrame.ConfirmedList | peerJoinIndex);
+      let newConfirmedList = (existingConfirmedList | peerJoinIndexMask);
       const newInputFrameDownsyncLocal = gopkgs.NewInputFrameDownsync(inputFrameId, newInputList, newConfirmedList);
       //console.log(`Updated encoded input of peerJoinIndex=${peerJoinIndex} to ${peerEncodedInput} for inputFrameId=${inputFrameId}/renderedInputFrameIdUpper=${renderedInputFrameIdUpper} from ${JSON.stringify(inputFrame)}; newInputFrameDownsyncLocal=${self.gopkgsInputFrameDownsyncStr(newInputFrameDownsyncLocal)}; existingInputFrame=${self.gopkgsInputFrameDownsyncStr(existingInputFrame)}`);
       self.recentInputCache.SetByFrameId(newInputFrameDownsyncLocal, inputFrameId);
@@ -1018,7 +1036,7 @@ fromUDP=${fromUDP}`);
         if (
           null == firstPredictedYetIncorrectInputFrameId
           &&
-          existingInputFrame.InputList[peerJoinIndex - 1] != peerEncodedInput
+          existingInputList[peerJoinIndex - 1] != peerEncodedInput
         ) {
           firstPredictedYetIncorrectInputFrameId = inputFrameId;
         }
@@ -1159,9 +1177,11 @@ fromUDP=${fromUDP}`);
           const delayedInputFrameId = gopkgs.ConvertToDelayedInputFrameId(rdf.GetId());
           const othersForcedDownsyncRenderFrame = self.othersForcedDownsyncRenderFrameDict.get(rdf.GetId());
           if (self.lastAllConfirmedInputFrameId >= delayedInputFrameId && !self.equalRoomDownsyncFrames(othersForcedDownsyncRenderFrame, rdf)) {
-            console.warn(`Mismatched render frame@rdf.id=${rdf.GetId()} w/ inputFrameId=${delayedInputFrameId}:
+            if (CC_DEBUG) {
-rdf=${JSON.stringify(rdf)}
+              console.warn(`Mismatched render frame@rdf.id=${rdf.GetId()} w/ inputFrameId=${delayedInputFrameId}:
-othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame)}`);
+rdf=${self._stringifyGopkgRdfForFrameDataLogging(rdf)}
+othersForcedDownsyncRenderFrame=${self._stringifyGopkgRdfForFrameDataLogging(othersForcedDownsyncRenderFrame)}`);
+            }
             rdf = othersForcedDownsyncRenderFrame;
             self.othersForcedDownsyncRenderFrameDict.delete(rdf.GetId());
           }
@@ -1418,8 +1438,22 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
       const j = gopkgs.ConvertToDelayedInputFrameId(i);
       const delayedInputFrame = gopkgs.GetInputFrameDownsync(self.recentInputCache, j);
 
+      const allowUpdateInputFrameInPlaceUponDynamics = (!isChasing);
+      const hasInputFrameUpdatedOnDynamics = gopkgs.ApplyInputFrameDownsyncDynamicsOnSingleRenderFrameJs(self.recentInputCache, i, collisionSys, collisionSysMap, self.spaceOffsetX, self.spaceOffsetY, self.chConfigsOrderedByJoinIndex, self.recentRenderCache, self.collisionHolder, self.effPushbacks, self.hardPushbackNormsArr, self.jumpedOrNotList, self.dynamicRectangleColliders, self.lastIndividuallyConfirmedInputFrameId, self.lastIndividuallyConfirmedInputList, allowUpdateInputFrameInPlaceUponDynamics, self.selfPlayerInfo.joinIndex);
+      if (hasInputFrameUpdatedOnDynamics) {
+        const ii = gopkgs.ConvertToFirstUsedRenderFrameId(j);
+        if (ii < i) {
+          /*
+          The backend counterpart doesn't need this rollback because 
+          1. Backend only applies all-confirmed inputFrames to calc dynamics.
+          2. Backend applies an all-confirmed inputFrame to all applicable render frames at once.
+          */
+          self._handleIncorrectlyRenderedPrediction(j, null, false);
+        }
+      }
       if (self.frameDataLoggingEnabled) {
-        const actuallyUsedInputClone = delayedInputFrame.GetInputList();
+        // [WARNING] The "inputList" of "delayedInputFrame" could be mutated in "ApplyInputFrameDownsyncDynamicsOnSingleRenderFrameJs", thus should clone after dynamics is applied!  
+        const actuallyUsedInputClone = delayedInputFrame.GetInputList().slice();
         const inputFrameDownsyncClone = {
           inputFrameId: j,
           inputList: actuallyUsedInputClone,
@@ -1427,8 +1461,6 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
         };
         self.rdfIdToActuallyUsedInput.set(i, inputFrameDownsyncClone);
       }
-      const allowUpdateInputFrameInPlaceUponDynamics = (!isChasing);
-      const renderRes = gopkgs.ApplyInputFrameDownsyncDynamicsOnSingleRenderFrameJs(self.recentInputCache, i, collisionSys, collisionSysMap, self.spaceOffsetX, self.spaceOffsetY, self.chConfigsOrderedByJoinIndex, self.recentRenderCache, self.collisionHolder, self.effPushbacks, self.hardPushbackNormsArr, self.jumpedOrNotList, self.dynamicRectangleColliders, self.lastIndividuallyConfirmedInputFrameId, self.lastIndividuallyConfirmedInputList, allowUpdateInputFrameInPlaceUponDynamics, self.selfPlayerInfo.joinIndex);
       const nextRdf = gopkgs.GetRoomDownsyncFrame(self.recentRenderCache, i + 1);
 
       if (true == isChasing) {
@@ -1544,34 +1576,41 @@ othersForcedDownsyncRenderFrame=${JSON.stringify(othersForcedDownsyncRenderFrame
     if (null == inputFrameDownsync) return "{}";
     const self = this;
     let s = [];
-    s.push(`InputFrameId:${inputFrameDownsync.InputFrameId}`);
+    s.push(`InputFrameId:${inputFrameDownsync.GetInputFrameId()}`);
     let ss = [];
     for (let k = 0; k < window.boundRoomCapacity; ++k) {
-      ss.push(`"${inputFrameDownsync.InputList[k]}"`);
+      ss.push(`"${inputFrameDownsync.GetInputList()[k]}"`);
     }
     s.push(`InputList:[${ss.join(',')}]`);
-    s.push(`ConfirmedList:${inputFrameDownsync.ConfirmedList}`);
+    s.push(`ConfirmedList:${inputFrameDownsync.GetConfirmedList()}`);
 
     return `{${s.join(',')}}`;
   },
 
+  _stringifyGopkgRdfForFrameDataLogging(rdf) {
+    const playersStrBldr = [];
+    for (let k = 0; k < window.boundRoomCapacity; k++) {
+      playersStrBldr.push(this.playerDownsyncStr(gopkgs.GetPlayer(rdf, k)));
+    }
+    const fireballsStrBldr = [];
+    for (let k = 0;; k++) {
+      const fireball = gopkgs.GetFireballBullet(rdf, k);
+      if (null == fireball) break;
+      fireballsStrBldr.push(this.fireballDownsyncStr(fireball));
+    }
+    return `rdfId:${rdf.GetId()}
+players:[${playersStrBldr.join(',')}]
+fireballs:[${fireballsStrBldr.join(',')}]`;
+  },
+
   _stringifyRdfIdToActuallyUsedInput() {
     const self = this;
     let s = [];
     for (let i = self.recentRenderCache.GetStFrameId(); i < self.recentRenderCache.GetEdFrameId(); i++) {
       const actuallyUsedInputClone = self.rdfIdToActuallyUsedInput.get(i);
-      const rdf = self.recentRenderCache.GetByFrameId(i);
+      const rdf = gopkgs.GetRoomDownsyncFrame(self.recentRenderCache, i);
-      const playersStrBldr = [];
+      const rdfStr = self._stringifyGopkgRdfForFrameDataLogging(rdf);
-      for (let k in rdf.GetPlayersArr()) {
+      s.push(`${rdfStr}
-        playersStrBldr.push(self.playerDownsyncStr(rdf.GetPlayersArr()[k]));
-      }
-      const fireballsStrBldr = [];
-      for (let k in rdf.FireballBullets) {
-        fireballsStrBldr.push(self.fireballDownsyncStr(rdf.FireballBullets[k]));
-      }
-      s.push(`rdfId:${i}
-players:[${playersStrBldr.join(',')}]
-fireballs:[${fireballsStrBldr.join(',')}]
 actuallyUsedinputList:{${self.inputFrameDownsyncStr(actuallyUsedInputClone)}}`);
     }
 

jsexport/battle/battle.go

@@ -22,7 +22,7 @@ const (
 	GRAVITY_X = int32(0)
 	GRAVITY_Y = -int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO) // makes all "playerCollider.Y" a multiple of 0.5 in all cases
 
-	INPUT_DELAY_FRAMES = int32(6) // in the count of render frames
+	INPUT_DELAY_FRAMES = int32(4) // in the count of render frames
 
 	/*
 	   [WARNING]
@@ -490,7 +490,8 @@ func calcHardPushbacksNorms(joinIndex int32, currPlayerDownsync, thatPlayerInNex
 	return retCnt
 }
 
-func UpdateInputFrameInPlaceUponDynamics(inputFrameId int32, roomCapacity int, confirmedList uint64, inputList []uint64, lastIndividuallyConfirmedInputFrameId []int32, lastIndividuallyConfirmedInputList []uint64, toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics int32) {
+func UpdateInputFrameInPlaceUponDynamics(inputFrameId int32, roomCapacity int, confirmedList uint64, inputList []uint64, lastIndividuallyConfirmedInputFrameId []int32, lastIndividuallyConfirmedInputList []uint64, toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics int32) bool {
+	hasInputFrameUpdatedOnDynamics := false
 	for i := 0; i < roomCapacity; i++ {
 		if int32(i+1) == toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics {
 			// On frontend, a "self input" is only confirmed by websocket downsync, which is quite late and might get the "self input" incorrectly overwritten if not excluded here
@@ -503,8 +504,13 @@ func UpdateInputFrameInPlaceUponDynamics(inputFrameId int32, roomCapacity int, c
 		if lastIndividuallyConfirmedInputFrameId[i] >= inputFrameId {
 			continue
 		}
-		inputList[i] = (lastIndividuallyConfirmedInputList[i] & uint64(15))
+		newVal := (lastIndividuallyConfirmedInputList[i] & uint64(15))
+		if newVal != inputList[i] {
+			inputList[i] = newVal
+			hasInputFrameUpdatedOnDynamics = true
+		}
 	}
+	return hasInputFrameUpdatedOnDynamics
 }
 
 func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync, currRenderFrame *RoomDownsyncFrame, chConfig *CharacterConfig, inputsBuffer *resolv.RingBuffer) (int, bool, int32, int32) {
@@ -585,6 +591,7 @@ func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync,
 The function "ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame" is creating new heap-memory blocks at 60fps, e.g. nextRenderFramePlayers & nextRenderFrameMeleeBullets & nextRenderFrameFireballBullets & effPushbacks & hardPushbackNorms & jumpedOrNotList & dynamicRectangleColliders("player" & "bullet"), which would induce "possibly performance impacting garbage collections" when many rooms are running simultaneously.
 */
 func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *resolv.RingBuffer, currRenderFrameId int32, collisionSys *resolv.Space, collisionSysMap map[int32]*resolv.Object, collisionSpaceOffsetX, collisionSpaceOffsetY float64, chConfigsOrderedByJoinIndex []*CharacterConfig, renderFrameBuffer *resolv.RingBuffer, collision *resolv.Collision, effPushbacks []*Vec2D, hardPushbackNormsArr [][]*Vec2D, jumpedOrNotList []bool, dynamicRectangleColliders []*resolv.Object, lastIndividuallyConfirmedInputFrameId []int32, lastIndividuallyConfirmedInputList []uint64, allowUpdateInputFrameInPlaceUponDynamics bool, toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics int32) bool {
+	hasInputFrameUpdatedOnDynamics := false
 	currRenderFrame := renderFrameBuffer.GetByFrameId(currRenderFrameId).(*RoomDownsyncFrame)
 	nextRenderFrameId := currRenderFrameId + 1
 	roomCapacity := len(currRenderFrame.PlayersArr)
@@ -637,7 +644,7 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *resolv.Rin
 		delayedInputList := delayedInputFrameDownsync.InputList
 		roomCapacity := len(delayedInputList)
 		if allowUpdateInputFrameInPlaceUponDynamics {
-			UpdateInputFrameInPlaceUponDynamics(delayedInputFrameId, roomCapacity, delayedInputFrameDownsync.ConfirmedList, delayedInputList, lastIndividuallyConfirmedInputFrameId, lastIndividuallyConfirmedInputList, toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics)
+			hasInputFrameUpdatedOnDynamics = UpdateInputFrameInPlaceUponDynamics(delayedInputFrameId, roomCapacity, delayedInputFrameDownsync.ConfirmedList, delayedInputList, lastIndividuallyConfirmedInputFrameId, lastIndividuallyConfirmedInputList, toExcludeJoinIndexUpdateInputFrameInPlaceUponDynamics)
 		}
 	}
 
@@ -731,7 +738,7 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *resolv.Rin
 				} else {
 					// Updates CharacterState and thus the animation to make user see graphical feedback asap.
 					thatPlayerInNextFrame.CharacterState = ATK_CHARACTER_STATE_WALKING
-					thatPlayerInNextFrame.FramesToRecover = ((chConfig.InertiaFramesToRecover >> 1) + (chConfig.InertiaFramesToRecover >> 2))
+					thatPlayerInNextFrame.FramesToRecover = (chConfig.InertiaFramesToRecover >> 1)
 				}
 			} else {
 				thatPlayerInNextFrame.CapturedByInertia = false
@@ -1210,7 +1217,7 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *resolv.Rin
 	ret.Id = nextRenderFrameId
 	ret.BulletLocalIdCounter = bulletLocalId
 
-	return true
+	return hasInputFrameUpdatedOnDynamics
 }
 
 func GenerateRectCollider(wx, wy, w, h, topPadding, bottomPadding, leftPadding, rightPadding, spaceOffsetX, spaceOffsetY float64, data interface{}, tag string) *resolv.Object {

resolv_tailored/asm_axpyunitaryto_amd64.s

@@ -1,164 +0,0 @@
-// This file contains code from the gonum repository:
-// https://github.com/gonum/gonum/blob/master/internal/asm/f64/scalunitaryto_amd64.s
-// it is distributed under the 3-Clause BSD license:
-//
-// Copyright ©2013 The Gonum Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above copyright
-//       notice, this list of conditions and the following disclaimer in the
-//       documentation and/or other materials provided with the distribution.
-//     * Neither the name of the Gonum project nor the names of its authors and
-//       contributors may be used to endorse or promote products derived from this
-//       software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Some of the loop unrolling code is copied from:
-// http://golang.org/src/math/big/arith_amd64.s
-// which is distributed under these terms:
-//
-// Copyright (c) 2012 The Go Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-//      notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-//      copyright notice, this list of conditions and the following disclaimer
-//      in the documentation and/or other materials provided with the
-//      distribution.
-//    * Neither the name of Google Inc. nor the names of its
-//      contributors may be used to endorse or promote products derived from
-//      this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build !noasm
-
-#include "textflag.h"
-
-#define X_PTR SI
-#define Y_PTR DX
-#define DST_PTR DI
-#define IDX AX
-#define LEN CX
-#define TAIL BX
-#define ALPHA X0
-#define ALPHA_2 X1
-
-// func axpyUnitaryTo(dst []float64, alpha float64, x, y []float64)
-TEXT ·axpyUnitaryTo(SB), NOSPLIT, $0
-	MOVQ    dst_base+0(FP), DST_PTR // DST_PTR := &dst
-	MOVQ    x_base+32(FP), X_PTR    // X_PTR := &x
-	MOVQ    y_base+56(FP), Y_PTR    // Y_PTR := &y
-	MOVQ    x_len+40(FP), LEN       // LEN = min( len(x), len(y), len(dst) )
-	CMPQ    y_len+64(FP), LEN
-	CMOVQLE y_len+64(FP), LEN
-	CMPQ    dst_len+8(FP), LEN
-	CMOVQLE dst_len+8(FP), LEN
-
-	CMPQ LEN, $0
-	JE   end     // if LEN == 0 { return }
-
-	XORQ   IDX, IDX            // IDX = 0
-	MOVSD  alpha+24(FP), ALPHA
-	SHUFPD $0, ALPHA, ALPHA    // ALPHA := { alpha, alpha }
-	MOVQ   Y_PTR, TAIL         // Check memory alignment
-	ANDQ   $15, TAIL           // TAIL = &y % 16
-	JZ     no_trim             // if TAIL == 0 { goto no_trim }
-
-	// Align on 16-byte boundary
-	MOVSD (X_PTR), X2   // X2 := x[0]
-	MULSD ALPHA, X2     // X2 *= a
-	ADDSD (Y_PTR), X2   // X2 += y[0]
-	MOVSD X2, (DST_PTR) // y[0] = X2
-	INCQ  IDX           // i++
-	DECQ  LEN           // LEN--
-	JZ    end           // if LEN == 0 { return }
-
-no_trim:
-	MOVQ LEN, TAIL
-	ANDQ $7, TAIL   // TAIL := n % 8
-	SHRQ $3, LEN    // LEN = floor( n / 8 )
-	JZ   tail_start // if LEN == 0 { goto tail_start }
-
-	MOVUPS ALPHA, ALPHA_2 // ALPHA_2 := ALPHA  for pipelining
-
-loop:  // do {
-	// y[i] += alpha * x[i] unrolled 8x.
-	MOVUPS (X_PTR)(IDX*8), X2   // X_i = x[i]
-	MOVUPS 16(X_PTR)(IDX*8), X3
-	MOVUPS 32(X_PTR)(IDX*8), X4
-	MOVUPS 48(X_PTR)(IDX*8), X5
-
-	MULPD ALPHA, X2   // X_i *= alpha
-	MULPD ALPHA_2, X3
-	MULPD ALPHA, X4
-	MULPD ALPHA_2, X5
-
-	ADDPD (Y_PTR)(IDX*8), X2   // X_i += y[i]
-	ADDPD 16(Y_PTR)(IDX*8), X3
-	ADDPD 32(Y_PTR)(IDX*8), X4
-	ADDPD 48(Y_PTR)(IDX*8), X5
-
-	MOVUPS X2, (DST_PTR)(IDX*8)   // y[i] = X_i
-	MOVUPS X3, 16(DST_PTR)(IDX*8)
-	MOVUPS X4, 32(DST_PTR)(IDX*8)
-	MOVUPS X5, 48(DST_PTR)(IDX*8)
-
-	ADDQ $8, IDX  // i += 8
-	DECQ LEN
-	JNZ  loop     // } while --LEN > 0
-	CMPQ TAIL, $0 // if TAIL == 0 { return }
-	JE   end
-
-tail_start: // Reset loop registers
-	MOVQ TAIL, LEN // Loop counter: LEN = TAIL
-	SHRQ $1, LEN   // LEN = floor( TAIL / 2 )
-	JZ   tail_one  // if LEN == 0 { goto tail }
-
-tail_two: // do {
-	MOVUPS (X_PTR)(IDX*8), X2   // X2 = x[i]
-	MULPD  ALPHA, X2            // X2 *= alpha
-	ADDPD  (Y_PTR)(IDX*8), X2   // X2 += y[i]
-	MOVUPS X2, (DST_PTR)(IDX*8) // y[i] = X2
-	ADDQ   $2, IDX              // i += 2
-	DECQ   LEN
-	JNZ    tail_two             // } while --LEN > 0
-
-	ANDQ $1, TAIL
-	JZ   end      // if TAIL == 0 { goto end }
-
-tail_one:
-	MOVSD (X_PTR)(IDX*8), X2   // X2 = x[i]
-	MULSD ALPHA, X2            // X2 *= a
-	ADDSD (Y_PTR)(IDX*8), X2   // X2 += y[i]
-	MOVSD X2, (DST_PTR)(IDX*8) // y[i] = X2
-
-end:
-	RET

resolv_tailored/asm_scalunitaryto_amd64.s

@@ -1,137 +0,0 @@
-// This file contains code from the gonum repository:
-// https://github.com/gonum/gonum/blob/master/internal/asm/f64/axpyunitaryto_amd64.s
-// it is distributed under the 3-Clause BSD license:
-//
-// Copyright ©2013 The Gonum Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above copyright
-//       notice, this list of conditions and the following disclaimer in the
-//       documentation and/or other materials provided with the distribution.
-//     * Neither the name of the Gonum project nor the names of its authors and
-//       contributors may be used to endorse or promote products derived from this
-//       software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Some of the loop unrolling code is copied from:
-// http://golang.org/src/math/big/arith_amd64.s
-// which is distributed under these terms:
-//
-// Copyright (c) 2012 The Go Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-//      notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-//      copyright notice, this list of conditions and the following disclaimer
-//      in the documentation and/or other materials provided with the
-//      distribution.
-//    * Neither the name of Google Inc. nor the names of its
-//      contributors may be used to endorse or promote products derived from
-//      this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build !noasm
-
-#include "textflag.h"
-
-#define MOVDDUP_ALPHA    LONG $0x44120FF2; WORD $0x2024 // @ MOVDDUP 32(SP), X0  /*XMM0, 32[RSP]*/
-
-#define X_PTR SI
-#define DST_PTR DI
-#define IDX AX
-#define LEN CX
-#define TAIL BX
-#define ALPHA X0
-#define ALPHA_2 X1
-
-// func scalUnitaryTo(dst []float64, alpha float64, x []float64)
-// This function assumes len(dst) >= len(x).
-TEXT ·scalUnitaryTo(SB), NOSPLIT, $0
-	MOVQ x_base+32(FP), X_PTR    // X_PTR = &x
-	MOVQ dst_base+0(FP), DST_PTR // DST_PTR = &dst
-	MOVDDUP_ALPHA                // ALPHA = { alpha, alpha }
-	MOVQ x_len+40(FP), LEN       // LEN = len(x)
-	CMPQ LEN, $0
-	JE   end                     // if LEN == 0 { return }
-
-	XORQ IDX, IDX   // IDX = 0
-	MOVQ LEN, TAIL
-	ANDQ $7, TAIL   // TAIL = LEN % 8
-	SHRQ $3, LEN    // LEN = floor( LEN / 8 )
-	JZ   tail_start // if LEN == 0 { goto tail_start }
-
-	MOVUPS ALPHA, ALPHA_2 // ALPHA_2 = ALPHA for pipelining
-
-loop:  // do { // dst[i] = alpha * x[i] unrolled 8x.
-	MOVUPS (X_PTR)(IDX*8), X2   // X_i = x[i]
-	MOVUPS 16(X_PTR)(IDX*8), X3
-	MOVUPS 32(X_PTR)(IDX*8), X4
-	MOVUPS 48(X_PTR)(IDX*8), X5
-
-	MULPD ALPHA, X2   // X_i *= ALPHA
-	MULPD ALPHA_2, X3
-	MULPD ALPHA, X4
-	MULPD ALPHA_2, X5
-
-	MOVUPS X2, (DST_PTR)(IDX*8)   // dst[i] = X_i
-	MOVUPS X3, 16(DST_PTR)(IDX*8)
-	MOVUPS X4, 32(DST_PTR)(IDX*8)
-	MOVUPS X5, 48(DST_PTR)(IDX*8)
-
-	ADDQ $8, IDX  // i += 8
-	DECQ LEN
-	JNZ  loop     // while --LEN > 0
-	CMPQ TAIL, $0
-	JE   end      // if TAIL == 0 { return }
-
-tail_start: // Reset loop counters
-	MOVQ TAIL, LEN // Loop counter: LEN = TAIL
-	SHRQ $1, LEN   // LEN = floor( TAIL / 2 )
-	JZ   tail_one  // if LEN == 0 { goto tail_one }
-
-tail_two: // do {
-	MOVUPS (X_PTR)(IDX*8), X2   // X_i = x[i]
-	MULPD  ALPHA, X2            // X_i *= ALPHA
-	MOVUPS X2, (DST_PTR)(IDX*8) // dst[i] = X_i
-	ADDQ   $2, IDX              // i += 2
-	DECQ   LEN
-	JNZ    tail_two             // while --LEN > 0
-
-	ANDQ $1, TAIL
-	JZ   end      // if TAIL == 0 { return }
-
-tail_one:
-	MOVSD (X_PTR)(IDX*8), X2   // X_i = x[i]
-	MULSD ALPHA, X2            // X_i *= ALPHA
-	MOVSD X2, (DST_PTR)(IDX*8) // dst[i] = X_i
-
-end:
-	RET

resolv_tailored/asm_stubs_amd64.go

@@ -1,9 +0,0 @@
-//go:build !noasm
-// +build !noasm
-
-package resolv
-
-// functions from the gonum package that optimizes arithmetic
-// operations on lists of float64 values
-func axpyUnitaryTo(dst []float64, alpha float64, x, y []float64)
-func scalUnitaryTo(dst []float64, alpha float64, x []float64)

resolv_tailored/shape.go

@@ -33,20 +33,12 @@ func NewLine(x, y, x2, y2 float64) *Line {
 	}
 }
 
-func (line *Line) Project(axis Vector) Vector {
-	return line.Vector().Scale(axis.Dot(line.Start.Sub(line.End)))
-}
-
 func (line *Line) Normal() Vector {
 	dy := line.End[1] - line.Start[1]
 	dx := line.End[0] - line.Start[0]
 	return Vector{dy, -dx}.Unit()
 }
 
-func (line *Line) Vector() Vector {
-	return line.End.Clone().Sub(line.Start).Unit()
-}
-
 // IntersectionPointsLine returns the intersection point of a Line with another Line as a Vector. If no intersection is found, it will return nil.
 func (line *Line) IntersectionPointsLine(other *Line) Vector {
 
@@ -79,51 +71,6 @@ func (line *Line) IntersectionPointsLine(other *Line) Vector {
 
 }
 
-// IntersectionPointsCircle returns a slice of Vectors, each indicating the intersection point. If no intersection is found, it will return an empty slice.
-func (line *Line) IntersectionPointsCircle(circle *Circle) []Vector {
-
-	points := []Vector{}
-
-	cp := Vector{circle.X, circle.Y}
-	lStart := line.Start.Sub(cp)
-	lEnd := line.End.Sub(cp)
-	diff := lEnd.Sub(lStart)
-
-	a := diff[0]*diff[0] + diff[1]*diff[1]
-	b := 2 * ((diff[0] * lStart[0]) + (diff[1] * lStart[1]))
-	c := (lStart[0] * lStart[0]) + (lStart[1] * lStart[1]) - (circle.Radius * circle.Radius)
-
-	det := b*b - (4 * a * c)
-
-	if det < 0 {
-		// Do nothing, no intersections
-	} else if det == 0 {
-
-		t := -b / (2 * a)
-
-		if t >= 0 && t <= 1 {
-			points = append(points, Vector{line.Start[0] + t*diff[0], line.Start[1] + t*diff[1]})
-		}
-
-	} else {
-
-		t := (-b + math.Sqrt(det)) / (2 * a)
-
-		// We have to ensure t is between 0 and 1; otherwise, the collision points are on the circle as though the lines were infinite in length.
-		if t >= 0 && t <= 1 {
-			points = append(points, Vector{line.Start[0] + t*diff[0], line.Start[1] + t*diff[1]})
-		}
-		t = (-b - math.Sqrt(det)) / (2 * a)
-		if t >= 0 && t <= 1 {
-			points = append(points, Vector{line.Start[0] + t*diff[0], line.Start[1] + t*diff[1]})
-		}
-
-	}
-
-	return points
-
-}
-
 type ConvexPolygon struct {
 	Points *RingBuffer
 	X, Y   float64
@@ -294,24 +241,6 @@ func (cp *ConvexPolygon) MoveVec(vec Vector) {
 	cp.Y += vec.Y()
 }
 
-// Center returns the transformed Center of the ConvexPolygon.
-func (cp *ConvexPolygon) Center() Vector {
-
-	pos := Vector{0, 0}
-
-	vertices := cp.Transformed()
-	for _, v := range vertices {
-		pos.Add(v)
-	}
-
-	denom := float64(len(vertices))
-	pos[0] /= denom
-	pos[1] /= denom
-
-	return pos
-
-}
-
 // Project projects (i.e. flattens) the ConvexPolygon onto the provided axis.
 func (cp *ConvexPolygon) Project(axis Vector) Projection {
 	axis = axis.Unit()
@@ -453,13 +382,7 @@ func (cp *ConvexPolygon) Intersection(dx, dy float64, other Shape) *ContactSet {
 	cp.X += dx
 	cp.Y += dy
 
-	if circle, isCircle := other.(*Circle); isCircle {
+	if poly, isPoly := other.(*ConvexPolygon); isPoly {
-
-		for _, line := range cp.Lines() {
-			contactSet.Points = append(contactSet.Points, line.IntersectionPointsCircle(circle)...)
-		}
-
-	} else if poly, isPoly := other.(*ConvexPolygon); isPoly {
 
 		for _, line := range cp.Lines() {
 
@@ -476,29 +399,11 @@ func (cp *ConvexPolygon) Intersection(dx, dy float64, other Shape) *ContactSet {
 	}
 
 	if len(contactSet.Points) > 0 {
-
+		// Do nothing
-		for _, point := range contactSet.Points {
-			contactSet.Center = contactSet.Center.Add(point)
-		}
-
-		contactSet.Center[0] /= float64(len(contactSet.Points))
-		contactSet.Center[1] /= float64(len(contactSet.Points))
-
-		if mtv := cp.calculateMTV(contactSet, other); mtv != nil {
-			contactSet.MTV = mtv
-		}
-
 	} else {
 		contactSet = nil
 	}
 
-	// If dx or dy aren't 0, then the MTV will be greater to compensate; this adjusts the vector back.
-	if contactSet != nil && (dx != 0 || dy != 0) {
-		deltaMagnitude := Vector{dx, dy}.Magnitude()
-		ogMagnitude := contactSet.MTV.Magnitude()
-		contactSet.MTV = contactSet.MTV.Unit().Scale(ogMagnitude - deltaMagnitude)
-	}
-
 	cp.X = ogX
 	cp.Y = ogY
 
@@ -506,76 +411,6 @@ func (cp *ConvexPolygon) Intersection(dx, dy float64, other Shape) *ContactSet {
 
 }
 
-// calculateMTV returns the MTV, if possible, and a bool indicating whether it was possible or not.
-func (cp *ConvexPolygon) calculateMTV(contactSet *ContactSet, otherShape Shape) Vector {
-
-	delta := Vector{0, 0}
-
-	smallest := Vector{math.MaxFloat64, 0}
-
-	switch other := otherShape.(type) {
-
-	case *ConvexPolygon:
-
-		for _, axis := range cp.SATAxes() {
-			if !cp.Project(axis).Overlapping(other.Project(axis)) {
-				return nil
-			}
-
-			overlap := cp.Project(axis).Overlap(other.Project(axis))
-
-			if smallest.Magnitude() > overlap {
-				smallest = axis.Scale(overlap)
-			}
-
-		}
-
-		for _, axis := range other.SATAxes() {
-
-			if !cp.Project(axis).Overlapping(other.Project(axis)) {
-				return nil
-			}
-
-			overlap := cp.Project(axis).Overlap(other.Project(axis))
-
-			if smallest.Magnitude() > overlap {
-				smallest = axis.Scale(overlap)
-			}
-
-		}
-		// Removed support of "Circle" to remove dependency of "sort" module
-	}
-
-	delta[0] = smallest[0]
-	delta[1] = smallest[1]
-
-	return delta
-}
-
-// ContainedBy returns if the ConvexPolygon is wholly contained by the other shape provided.
-func (cp *ConvexPolygon) ContainedBy(otherShape Shape) bool {
-
-	switch other := otherShape.(type) {
-
-	case *ConvexPolygon:
-
-		for _, axis := range cp.SATAxes() {
-			if !cp.Project(axis).IsInside(other.Project(axis)) {
-				return false
-			}
-		}
-
-		for _, axis := range other.SATAxes() {
-			if !cp.Project(axis).IsInside(other.Project(axis)) {
-				return false
-			}
-		}
-
-	}
-
-	return true
-}
-
 // NewRectangle returns a rectangular ConvexPolygon with the vertices in clockwise order. In actuality, an AABBRectangle should be its own
 // "thing" with its own optimized Intersection code check.
 func NewRectangle(x, y, w, h float64) *ConvexPolygon {
@@ -587,143 +422,6 @@ func NewRectangle(x, y, w, h float64) *ConvexPolygon {
 	)
 }
 
-type Circle struct {
-	X, Y, Radius float64
-}
-
-// NewCircle returns a new Circle, with its center at the X and Y position given, and with the defined radius.
-func NewCircle(x, y, radius float64) *Circle {
-	circle := &Circle{
-		X:      x,
-		Y:      y,
-		Radius: radius,
-	}
-	return circle
-}
-
-func (circle *Circle) Clone() Shape {
-	return NewCircle(circle.X, circle.Y, circle.Radius)
-}
-
-// Bounds returns the top-left and bottom-right corners of the Circle.
-func (circle *Circle) Bounds() (Vector, Vector) {
-	return Vector{circle.X - circle.Radius, circle.Y - circle.Radius}, Vector{circle.X + circle.Radius, circle.Y + circle.Radius}
-}
-
-// Intersection tests to see if a Circle intersects with the other given Shape. dx and dy are delta movement variables indicating
-// movement to be applied before the intersection check (thereby allowing you to see if a Shape would collide with another if it
-// were in a different relative location). If an Intersection is found, a ContactSet will be returned, giving information regarding
-// the intersection.
-func (circle *Circle) Intersection(dx, dy float64, other Shape) *ContactSet {
-
-	var contactSet *ContactSet
-
-	ox := circle.X
-	oy := circle.Y
-
-	circle.X += dx
-	circle.Y += dy
-
-	// here
-
-	switch shape := other.(type) {
-	case *ConvexPolygon:
-		// Maybe this would work?
-		contactSet = shape.Intersection(-dx, -dy, circle)
-		if contactSet != nil {
-			contactSet.MTV = contactSet.MTV.Scale(-1)
-		}
-	case *Circle:
-
-		contactSet = NewContactSet()
-
-		contactSet.Points = circle.IntersectionPointsCircle(shape)
-
-		if len(contactSet.Points) == 0 {
-			return nil
-		}
-
-		contactSet.MTV = Vector{circle.X - shape.X, circle.Y - shape.Y}
-		dist := contactSet.MTV.Magnitude()
-		contactSet.MTV = contactSet.MTV.Unit().Scale(circle.Radius + shape.Radius - dist)
-
-		for _, point := range contactSet.Points {
-			contactSet.Center = contactSet.Center.Add(point)
-		}
-
-		contactSet.Center[0] /= float64(len(contactSet.Points))
-		contactSet.Center[1] /= float64(len(contactSet.Points))
-
-		// if contactSet != nil {
-		// 	contactSet.MTV[0] -= dx
-		// 	contactSet.MTV[1] -= dy
-		// }
-
-		// contactSet.MTV = Vector{circle.X - shape.X, circle.Y - shape.Y}
-	}
-
-	circle.X = ox
-	circle.Y = oy
-
-	return contactSet
-}
-
-// Move translates the Circle by the designated X and Y values.
-func (circle *Circle) Move(x, y float64) {
-	circle.X += x
-	circle.Y += y
-}
-
-// MoveVec translates the Circle by the designated Vector.
-func (circle *Circle) MoveVec(vec Vector) {
-	circle.X += vec.X()
-	circle.Y += vec.Y()
-}
-
-// SetPosition sets the center position of the Circle using the X and Y values given.
-func (circle *Circle) SetPosition(x, y float64) {
-	circle.X = x
-	circle.Y = y
-}
-
-// SetPosition sets the center position of the Circle using the Vector given.
-func (circle *Circle) SetPositionVec(vec Vector) {
-	circle.X = vec.X()
-	circle.Y = vec.Y()
-}
-
-// Position() returns the X and Y position of the Circle.
-func (circle *Circle) Position() (float64, float64) {
-	return circle.X, circle.Y
-}
-
-// PointInside returns if the given Vector is inside of the circle.
-func (circle *Circle) PointInside(point Vector) bool {
-	return point.Sub(Vector{circle.X, circle.Y}).Magnitude() <= circle.Radius
-}
-
-// IntersectionPointsCircle returns the intersection points of the two circles provided.
-func (circle *Circle) IntersectionPointsCircle(other *Circle) []Vector {
-
-	d := math.Sqrt(math.Pow(other.X-circle.X, 2) + math.Pow(other.Y-circle.Y, 2))
-
-	if d > circle.Radius+other.Radius || d < math.Abs(circle.Radius-other.Radius) || d == 0 && circle.Radius == other.Radius {
-		return nil
-	}
-
-	a := (math.Pow(circle.Radius, 2) - math.Pow(other.Radius, 2) + math.Pow(d, 2)) / (2 * d)
-	h := math.Sqrt(math.Pow(circle.Radius, 2) - math.Pow(a, 2))
-
-	x2 := circle.X + a*(other.X-circle.X)/d
-	y2 := circle.Y + a*(other.Y-circle.Y)/d
-
-	return []Vector{
-		{x2 + h*(other.Y-circle.Y)/d, y2 - h*(other.X-circle.X)/d},
-		{x2 - h*(other.Y-circle.Y)/d, y2 + h*(other.X-circle.X)/d},
-	}
-
-}
-
 type Projection struct {
 	Min, Max float64
 }

resolv_tailored/vector.go

@@ -31,6 +31,7 @@ func (v Vector) Clone() Vector {
 	return clone
 }
 
+/*
 // Add a vector with a vector or a set of vectors
 func Add(v1 Vector, vs ...Vector) Vector {
 	return v1.Clone().Add(vs...)
@@ -81,6 +82,7 @@ func (v Vector) Scale(size float64) Vector {
 	scalUnitaryTo(v, size, v)
 	return v
 }
+*/
 
 // Equal compares that two vectors are equal to each other
 func Equal(v1, v2 Vector) bool {