Fixed frontend debug drawer.

jsexport/battle/battle.go

@@ -32,6 +32,8 @@ const (
 
 	NO_SKILL     = -1
 	NO_SKILL_HIT = -1
+
+	NO_LOCK_VEL = int32(-1)
 )
 
 // These directions are chosen such that when speed is changed to "(speedX+delta, speedY+delta)" for any of them, the direction is unchanged.
@@ -86,7 +88,17 @@ var invinsibleSet = map[int32]bool{
 	ATK_CHARACTER_STATE_GET_UP1:   true,
 }
 
-var nonAttackingSet = map[int32]bool{}
+var nonAttackingSet = map[int32]bool{
+	ATK_CHARACTER_STATE_IDLE1:               true,
+	ATK_CHARACTER_STATE_WALKING:             true,
+	ATK_CHARACTER_STATE_INAIR_IDLE1_NO_JUMP: true,
+	ATK_CHARACTER_STATE_INAIR_IDLE1_BY_JUMP: true,
+	ATK_CHARACTER_STATE_ATKED1:              true,
+	ATK_CHARACTER_STATE_INAIR_ATKED1:        true,
+	ATK_CHARACTER_STATE_BLOWN_UP1:           true,
+	ATK_CHARACTER_STATE_LAY_DOWN1:           true,
+	ATK_CHARACTER_STATE_GET_UP1:             true,
+}
 
 func ShouldPrefabInputFrameDownsync(prevRenderFrameId int32, renderFrameId int32) (bool, int32) {
 	for i := prevRenderFrameId + 1; i <= renderFrameId; i++ {
@@ -426,31 +438,39 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 	// Make a copy first
 	for i, currPlayerDownsync := range currRenderFrame.PlayersArr {
 		nextRenderFramePlayers[i] = &PlayerDownsync{
-			Id:              currPlayerDownsync.Id,
-			VirtualGridX:    currPlayerDownsync.VirtualGridX,
-			VirtualGridY:    currPlayerDownsync.VirtualGridY,
-			DirX:            currPlayerDownsync.DirX,
-			DirY:            currPlayerDownsync.DirY,
-			VelX:            currPlayerDownsync.VelX,
-			VelY:            currPlayerDownsync.VelY,
-			CharacterState:  currPlayerDownsync.CharacterState,
-			InAir:           true,
-			Speed:           currPlayerDownsync.Speed,
-			BattleState:     currPlayerDownsync.BattleState,
-			Score:           currPlayerDownsync.Score,
-			Removed:         currPlayerDownsync.Removed,
-			JoinIndex:       currPlayerDownsync.JoinIndex,
-			Hp:              currPlayerDownsync.Hp,
-			MaxHp:           currPlayerDownsync.MaxHp,
-			FramesToRecover: currPlayerDownsync.FramesToRecover - 1,
-			FramesInChState: currPlayerDownsync.FramesInChState + 1,
-			ActiveSkillId:   currPlayerDownsync.ActiveSkillId,
-			ActiveSkillHit:  currPlayerDownsync.ActiveSkillHit,
-			ColliderRadius:  currPlayerDownsync.ColliderRadius,
+			Id:                currPlayerDownsync.Id,
+			VirtualGridX:      currPlayerDownsync.VirtualGridX,
+			VirtualGridY:      currPlayerDownsync.VirtualGridY,
+			DirX:              currPlayerDownsync.DirX,
+			DirY:              currPlayerDownsync.DirY,
+			VelX:              currPlayerDownsync.VelX,
+			VelY:              currPlayerDownsync.VelY,
+			CharacterState:    currPlayerDownsync.CharacterState,
+			InAir:             true,
+			Speed:             currPlayerDownsync.Speed,
+			BattleState:       currPlayerDownsync.BattleState,
+			Score:             currPlayerDownsync.Score,
+			Removed:           currPlayerDownsync.Removed,
+			JoinIndex:         currPlayerDownsync.JoinIndex,
+			Hp:                currPlayerDownsync.Hp,
+			MaxHp:             currPlayerDownsync.MaxHp,
+			FramesToRecover:   currPlayerDownsync.FramesToRecover - 1,
+			FramesInChState:   currPlayerDownsync.FramesInChState + 1,
+			ActiveSkillId:     currPlayerDownsync.ActiveSkillId,
+			ActiveSkillHit:    currPlayerDownsync.ActiveSkillHit,
+			FramesInvinsible:  currPlayerDownsync.FramesInvinsible - 1,
+			FramesSelfLockVel: currPlayerDownsync.FramesSelfLockVel - 1,
+			ColliderRadius:    currPlayerDownsync.ColliderRadius,
 		}
 		if nextRenderFramePlayers[i].FramesToRecover < 0 {
 			nextRenderFramePlayers[i].FramesToRecover = 0
 		}
+		if nextRenderFramePlayers[i].FramesInvinsible < 0 {
+			nextRenderFramePlayers[i].FramesInvinsible = 0
+		}
+		if nextRenderFramePlayers[i].FramesSelfLockVel < 0 {
+			nextRenderFramePlayers[i].FramesSelfLockVel = 0
+		}
 	}
 
 	nextRenderFrameMeleeBullets := make([]*MeleeBullet, 0, len(currRenderFrame.MeleeBullets)) // Is there any better way to reduce malloc/free impact, e.g. smart prediction for fixed memory allocation?
@@ -475,8 +495,6 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 			thatPlayerInNextFrame.ActiveSkillId = int32(skillId)
 			thatPlayerInNextFrame.ActiveSkillHit = 0
 
-			// TODO: Respect non-zero "selfLockVel"
-
 			// Hardcoded to use only the first hit for now
 			switch v := skillConfig.Hits[thatPlayerInNextFrame.ActiveSkillHit].(type) {
 			case *MeleeBullet:
@@ -485,12 +503,30 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 				newBullet.OffenderJoinIndex = joinIndex
 				nextRenderFrameMeleeBullets = append(nextRenderFrameMeleeBullets, &newBullet)
 				thatPlayerInNextFrame.FramesToRecover = skillConfig.RecoveryFrames
+
+				hasLockVel := false
+				if NO_LOCK_VEL != v.SelfLockVelX {
+					hasLockVel = true
+					xfac := int32(1)
+					if 0 > thatPlayerInNextFrame.DirX {
+						xfac = -xfac
+					}
+					thatPlayerInNextFrame.VelX = xfac * v.SelfLockVelX
+                    thatPlayerInNextFrame.FramesSelfLockVel = v.FramesSelfLockVel
+				}
+				if NO_LOCK_VEL != v.SelfLockVelY {
+					hasLockVel = true
+					thatPlayerInNextFrame.VelY = v.SelfLockVelY
+                    thatPlayerInNextFrame.FramesSelfLockVel = v.FramesSelfLockVel
+				}
+				if false == hasLockVel {
+					if false == currPlayerDownsync.InAir {
+						thatPlayerInNextFrame.VelX = 0
+					}
+				}
 			}
 
 			thatPlayerInNextFrame.CharacterState = skillConfig.BoundChState
-			if false == currPlayerDownsync.InAir {
-				thatPlayerInNextFrame.VelX = 0
-			}
 			continue // Don't allow movement if skill is used
 		}
 
@@ -640,9 +676,9 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 						thatPlayerInNextFrame.FramesToRecover = chConfig.GetUpFramesToRecover
 					}
 				} else if ATK_CHARACTER_STATE_GET_UP1 == thatPlayerInNextFrame.CharacterState {
-					if thatPlayerInNextFrame.FramesInChState == chConfig.GetUpFrames {
-						// [WARNING] Before reaching here, the player had 3 invinsible frames to either attack or jump, if it ever took any action then this condition wouldn't have been met, thus we hereby only transit it back to IDLE as it took no action
+					if 0 == thatPlayerInNextFrame.FramesToRecover {
 						thatPlayerInNextFrame.CharacterState = ATK_CHARACTER_STATE_IDLE1
+						thatPlayerInNextFrame.FramesInvinsible = chConfig.GetUpInvinsibleFrames
 					}
 				}
 			}
@@ -671,6 +707,9 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 					if _, existent := invinsibleSet[t.CharacterState]; existent {
 						continue
 					}
+					if 0 < t.FramesInvinsible {
+						continue
+					}
 					overlapped, _, _, _ := CalcPushbacks(0, 0, bulletShape, defenderShape)
 					if !overlapped {
 						continue

jsexport/battle/characterConfig.go

@@ -12,8 +12,8 @@ type CharacterConfig struct {
 	LayDownFrames          int32
 	LayDownFramesToRecover int32
 
-	GetUpFrames          int32
-	GetUpFramesToRecover int32
+	GetUpInvinsibleFrames int32
+	GetUpFramesToRecover  int32
 
 	Speed           int32
 	JumpingInitVelY int32
@@ -32,8 +32,8 @@ var Characters = map[int]*CharacterConfig{
 		LayDownFrames:          int32(16),
 		LayDownFramesToRecover: int32(16),
 
-		GetUpFrames:          int32(33),
-		GetUpFramesToRecover: int32(30), // 3 invinsible frames for just-blown-up character to make a comeback
+		GetUpInvinsibleFrames: int32(10),
+		GetUpFramesToRecover:  int32(27),
 
 		Speed:           int32(float64(1.2) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingInitVelY: int32(float64(8) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -75,8 +75,8 @@ var Characters = map[int]*CharacterConfig{
 		LayDownFrames:          int32(16),
 		LayDownFramesToRecover: int32(16),
 
-		GetUpFrames:          int32(30),
-		GetUpFramesToRecover: int32(27), // 3 invinsible frames for just-blown-up character to make a comeback
+		GetUpInvinsibleFrames: int32(10),
+		GetUpFramesToRecover:  int32(27),
 
 		Speed:           int32(float64(1.4) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingInitVelY: int32(float64(7.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -125,6 +125,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:      int32(13),
 					BlockStunFrames:    int32(9),
 					Damage:             int32(5),
+					SelfLockVelX:       int32(float64(0.05) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:       NO_LOCK_VEL,
 					PushbackVelX:       int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:       int32(0),
 					HitboxOffsetX:      int32(float64(12) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -156,6 +158,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:      int32(18),
 					BlockStunFrames:    int32(9),
 					Damage:             int32(5),
+					SelfLockVelX:       int32(float64(0.1) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:       NO_LOCK_VEL,
 					PushbackVelX:       int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:       int32(0),
 					HitboxOffsetX:      int32(float64(18) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -172,24 +176,26 @@ var skills = map[int]*Skill{
 		},
 	},
 	3: &Skill{
-		RecoveryFrames:        int32(60),
-		RecoveryFramesOnBlock: int32(60),
-		RecoveryFramesOnHit:   int32(60),
+		RecoveryFrames:        int32(70),
+		RecoveryFramesOnBlock: int32(70),
+		RecoveryFramesOnHit:   int32(70),
 		ReleaseTriggerType:    int32(1),
 		BoundChState:          ATK_CHARACTER_STATE_ATK3,
 		Hits: []interface{}{
 			&MeleeBullet{
 				Bullet: Bullet{
 					StartupFrames:   int32(15),
-					ActiveFrames:    int32(40),
+					ActiveFrames:    int32(30),
 					HitStunFrames:   MAX_INT32,
 					BlockStunFrames: int32(9),
 					Damage:          int32(10),
+					SelfLockVelX:    NO_LOCK_VEL,
+					SelfLockVelY:    NO_LOCK_VEL,
 					PushbackVelX:    int32(float64(2) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:    int32(float64(7) * WORLD_TO_VIRTUAL_GRID_RATIO),
-					HitboxOffsetX:   int32(float64(24) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					HitboxOffsetX:   int32(float64(32) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					HitboxOffsetY:   int32(0),
-					HitboxSizeX:     int32(float64(32) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					HitboxSizeX:     int32(float64(48) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					HitboxSizeY:     int32(float64(32) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					BlowUp:          true,
 				},
@@ -210,6 +216,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:      int32(13),
 					BlockStunFrames:    int32(9),
 					Damage:             int32(5),
+					SelfLockVelX:       int32(float64(0.05) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:       NO_LOCK_VEL,
 					PushbackVelX:       int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:       int32(0),
 					HitboxOffsetX:      int32(float64(12) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -241,6 +249,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:      int32(18),
 					BlockStunFrames:    int32(9),
 					Damage:             int32(5),
+					SelfLockVelX:       int32(float64(0.1) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:       NO_LOCK_VEL,
 					PushbackVelX:       int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:       int32(0),
 					HitboxOffsetX:      int32(float64(18) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -270,6 +280,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:   MAX_INT32,
 					BlockStunFrames: int32(9),
 					Damage:          int32(10),
+					SelfLockVelX:    int32(float64(-0.1) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:    NO_LOCK_VEL,
 					PushbackVelX:    int32(float64(2) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:    int32(float64(7) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					HitboxOffsetX:   int32(float64(24) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -295,6 +307,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:   int32(18),
 					BlockStunFrames: int32(9),
 					Damage:          int32(5),
+					SelfLockVelX:    NO_LOCK_VEL,
+					SelfLockVelY:    NO_LOCK_VEL,
 					PushbackVelX:    int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:    int32(0),
 					HitboxOffsetX:   int32(float64(12) * WORLD_TO_VIRTUAL_GRID_RATIO),
@@ -319,6 +333,8 @@ var skills = map[int]*Skill{
 					HitStunFrames:   int32(18),
 					BlockStunFrames: int32(9),
 					Damage:          int32(5),
+					SelfLockVelX:    NO_LOCK_VEL,
+					SelfLockVelY:    NO_LOCK_VEL,
 					PushbackVelX:    int32(float64(0.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 					PushbackVelY:    int32(0),
 					HitboxOffsetX:   int32(float64(12) * WORLD_TO_VIRTUAL_GRID_RATIO),

jsexport/battle/room_downsync_frame.go

@@ -36,6 +36,9 @@ type PlayerDownsync struct {
 
 	ActiveSkillId  int32
 	ActiveSkillHit int32
+
+	FramesInvinsible  int32
+	FramesSelfLockVel int32
 }
 
 type InputFrameDecoded struct {
@@ -70,8 +73,9 @@ type Bullet struct {
 	PushbackVelY    int32
 	Damage          int32
 
-	SelfLockVelX int32
-	SelfLockVelY int32
+	SelfLockVelX      int32
+	SelfLockVelY      int32
+	FramesSelfLockVel int32
 
 	HitboxOffsetX int32
 	HitboxOffsetY int32