Added turn-around and dashing actual triggers.

frontend/assets/plugin_scripts/jsexport.js.meta

@@ -1,6 +1,6 @@
 {
   "ver": "1.0.5",
-  "uuid": "d41313ca-b2c3-4436-a05f-7e0eb290b1e6",
+  "uuid": "40edd08e-316c-44b8-a50f-bd173554c554",
   "isPlugin": true,
   "loadPluginInWeb": true,
   "loadPluginInNative": true,

frontend/assets/resources/animation/KnifeGirl/TurnAround1.anim

@@ -0,0 +1,43 @@
+{
+  "__type__": "cc.AnimationClip",
+  "_name": "TurnAround1",
+  "_objFlags": 0,
+  "_native": "",
+  "_duration": 0.15,
+  "sample": 60,
+  "speed": 1,
+  "wrapMode": 1,
+  "curveData": {
+    "comps": {
+      "cc.Sprite": {
+        "spriteFrame": [
+          {
+            "frame": 0,
+            "value": {
+              "__uuid__": "28ee1f29-e538-4d36-bb5c-275f9e3b392b"
+            }
+          },
+          {
+            "frame": 0.03333333333333333,
+            "value": {
+              "__uuid__": "211a73bb-31d7-4e6c-901e-f6939d9214e0"
+            }
+          },
+          {
+            "frame": 0.08333333333333333,
+            "value": {
+              "__uuid__": "048c41dc-fc00-4bc4-8041-6003e7c2b6e4"
+            }
+          },
+          {
+            "frame": 0.13333333333333333,
+            "value": {
+              "__uuid__": "9435195e-4560-495e-b1ae-083c0c87e8a0"
+            }
+          }
+        ]
+      }
+    }
+  },
+  "events": []
+}

frontend/assets/resources/animation/KnifeGirl/TurnAround1.anim.meta

@@ -0,0 +1,5 @@
+{
+  "ver": "2.1.0",
+  "uuid": "e906322d-a08b-4477-a2e9-98acd42fa034",
+  "subMetas": {}
+}

frontend/assets/resources/animation/Monk/TurnAround1.anim

@@ -0,0 +1,43 @@
+{
+  "__type__": "cc.AnimationClip",
+  "_name": "TurnAround1",
+  "_objFlags": 0,
+  "_native": "",
+  "_duration": 0.15,
+  "sample": 60,
+  "speed": 1,
+  "wrapMode": 1,
+  "curveData": {
+    "comps": {
+      "cc.Sprite": {
+        "spriteFrame": [
+          {
+            "frame": 0,
+            "value": {
+              "__uuid__": "ee5e05fa-b515-470f-bc3c-43544f02cb92"
+            }
+          },
+          {
+            "frame": 0.03333333333333333,
+            "value": {
+              "__uuid__": "ffa521b6-118e-46e8-be1c-51cc54381ec8"
+            }
+          },
+          {
+            "frame": 0.08333333333333333,
+            "value": {
+              "__uuid__": "0b27d2c9-c5a3-4020-adbe-0297c1ba3aeb"
+            }
+          },
+          {
+            "frame": 0.13333333333333333,
+            "value": {
+              "__uuid__": "a47f518e-62fb-4549-8897-4f2d387bd145"
+            }
+          }
+        ]
+      }
+    }
+  },
+  "events": []
+}

frontend/assets/resources/animation/Monk/TurnAround1.anim.meta

@@ -0,0 +1,5 @@
+{
+  "ver": "2.1.0",
+  "uuid": "edd23b2f-1caa-4836-88a7-e4af1f26743e",
+  "subMetas": {}
+}

frontend/assets/resources/animation/MonkGirl/TurnAround1.anim

@@ -0,0 +1,43 @@
+{
+  "__type__": "cc.AnimationClip",
+  "_name": "TurnAround1",
+  "_objFlags": 0,
+  "_native": "",
+  "_duration": 0.15,
+  "sample": 60,
+  "speed": 1,
+  "wrapMode": 1,
+  "curveData": {
+    "comps": {
+      "cc.Sprite": {
+        "spriteFrame": [
+          {
+            "frame": 0,
+            "value": {
+              "__uuid__": "c1a00209-f74d-41b5-a5da-df5720ac34b4"
+            }
+          },
+          {
+            "frame": 0.03333333333333333,
+            "value": {
+              "__uuid__": "2b52c0f1-2360-4a2b-9233-bf5662de09a5"
+            }
+          },
+          {
+            "frame": 0.08333333333333333,
+            "value": {
+              "__uuid__": "e3f9dfe7-ed91-4dc3-b68b-a3a3c2637074"
+            }
+          },
+          {
+            "frame": 0.13333333333333333,
+            "value": {
+              "__uuid__": "7515ef50-3a14-4e58-8811-a0c890fc40f3"
+            }
+          }
+        ]
+      }
+    }
+  },
+  "events": []
+}

frontend/assets/resources/animation/MonkGirl/TurnAround1.anim.meta

@@ -0,0 +1,5 @@
+{
+  "ver": "2.1.0",
+  "uuid": "6e1139d4-03dd-4bd4-9510-606e94f629fe",
+  "subMetas": {}
+}

frontend/assets/resources/prefabs/ControlledCharacter.prefab

@@ -482,6 +482,13 @@
       },
       {
         "__uuid__": "e8247e2a-1b5b-4618-86f8-224b25246b55"
+      },
+      null,
+      null,
+      null,
+      null,
+      {
+        "__uuid__": "6e1139d4-03dd-4bd4-9510-606e94f629fe"
       }
     ],
     "playOnLoad": false,
@@ -653,6 +660,9 @@
       },
       {
         "__uuid__": "411f964a-4dd8-424c-b2e2-d92b10474ce2"
+      },
+      {
+        "__uuid__": "e906322d-a08b-4477-a2e9-98acd42fa034"
       }
     ],
     "playOnLoad": false,
@@ -822,6 +832,11 @@
       },
       {
         "__uuid__": "0abbd156-980e-475e-9994-3c958bd913fc"
+      },
+      null,
+      null,
+      {
+        "__uuid__": "edd23b2f-1caa-4836-88a7-e4af1f26743e"
       }
     ],
     "playOnLoad": false,

frontend/assets/scenes/offline_map.fire

@@ -537,7 +537,7 @@
       "array": [
         0,
         0,
-        215.64032554232523,
+        209.73151519075364,
         0,
         0,
         0,

frontend/assets/scripts/AttackingCharacter.js

@@ -18,6 +18,7 @@ window.ATK_CHARACTER_STATE = {
   Atk5: [14, "Atk5"],
   Dashing: [15, "Dashing"],
   OnWall: [16, "OnWall"],
+  TurnAround1: [17, "TurnAround1"],
 };
 
 window.ATK_CHARACTER_STATE_ARR = [];
@@ -93,7 +94,7 @@ cc.Class({
       } else if (0 < rdfPlayer.DirX) {
         this.animNode.scaleX = (+1.0);
       }
-      if (ATK_CHARACTER_STATE.OnWall[0] == newCharacterState) {
+      if (ATK_CHARACTER_STATE.OnWall[0] == newCharacterState || ATK_CHARACTER_STATE.TurnAround1[0] == newCharacterState) {
         if (0 < rdfPlayer.OnWallNormX) {
           this.animNode.scaleX = (-1.0);
         } else {

frontend/assets/scripts/OfflineMap.js

@@ -96,7 +96,7 @@ cc.Class({
       const p2Vpos = gopkgs.WorldToVirtualGridPos(boundaryObjs.playerStartingPositions[1].x, boundaryObjs.playerStartingPositions[1].y);
       const colliderRadiusV = gopkgs.WorldToVirtualGridPos(12.0, 0);
 
-      const speciesIdList = [1, 4096];
+      const speciesIdList = [1,4096];
       const chConfigsOrderedByJoinIndex = gopkgs.GetCharacterConfigsOrderedByJoinIndex(speciesIdList);
 
       const startRdf = window.pb.protos.RoomDownsyncFrame.create({

jsexport/battle/battle.go

@@ -16,13 +16,13 @@ const (
 	PATTERN_ID_UNABLE_TO_OP = -2
 	PATTERN_ID_NO_OP        = -1
 
-	WORLD_TO_VIRTUAL_GRID_RATIO = float64(100)
+	WORLD_TO_VIRTUAL_GRID_RATIO = float64(100.0)
 	VIRTUAL_GRID_TO_WORLD_RATIO = float64(1.0) / WORLD_TO_VIRTUAL_GRID_RATIO
 
 	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(8)  // in the count of render frames
+	INPUT_DELAY_FRAMES = int32(4)  // in the count of render frames
 	INPUT_SCALE_FRAMES = uint32(2) // inputDelayedAndScaledFrameId = ((originalFrameId - InputDelayFrames) >> InputScaleFrames)
 	NST_DELAY_FRAMES   = int32(16) // network-single-trip delay in the count of render frames, proposed to be (InputDelayFrames >> 1) because we expect a round-trip delay to be exactly "InputDelayFrames"
 
@@ -448,7 +448,7 @@ func calcHardPushbacksNorms(joinIndex int32, currPlayerDownsync, thatPlayerInNex
 	return &ret
 }
 
-func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync, currRenderFrame *RoomDownsyncFrame, inputsBuffer *RingBuffer) (int, bool, int32, int32) {
+func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync, currRenderFrame *RoomDownsyncFrame, chConfig *CharacterConfig, inputsBuffer *RingBuffer) (int, bool, int32, int32) {
 	// returns (patternId, jumpedOrNot, effectiveDx, effectiveDy)
 	delayedInputFrameId := ConvertToDelayedInputFrameId(currRenderFrame.Id)
 	delayedInputFrameIdForPrevRdf := ConvertToDelayedInputFrameId(currRenderFrame.Id - 1)
@@ -478,11 +478,14 @@ func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync,
 		prevBtnBLevel = prevDecodedInput.BtnBLevel
 	}
 
-	if 0 == currPlayerDownsync.FramesToRecover {
+	patternId := PATTERN_ID_NO_OP
-		// Jumping and moving are only allowed here
+	if 0 == currPlayerDownsync.FramesToRecover || currPlayerDownsync.CapturedByInertia {
+		// Jumping is allowed within "CapturedByInertia", but moving is only allowed when "0 == FramesToRecover" (constrained later in "ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame")
 		effDx, effDy = decodedInput.Dx, decodedInput.Dy
 		if decodedInput.BtnBLevel > prevBtnBLevel {
-			if _, existent := inAirSet[currPlayerDownsync.CharacterState]; !existent {
+			if chConfig.DashingEnabled && 0 > effDy {
+				patternId = 5
+			} else if _, existent := inAirSet[currPlayerDownsync.CharacterState]; !existent {
 				jumpedOrNot = true
 			} else if ATK_CHARACTER_STATE_ONWALL == currPlayerDownsync.CharacterState {
 				jumpedOrNot = true
@@ -490,18 +493,19 @@ func deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame *PlayerDownsync,
 		}
 	}
 
-	patternId := PATTERN_ID_NO_OP
+	if PATTERN_ID_NO_OP == patternId {
-	if 0 < decodedInput.BtnALevel {
+		if 0 < decodedInput.BtnALevel {
-		if decodedInput.BtnALevel > prevBtnALevel {
+			if decodedInput.BtnALevel > prevBtnALevel {
-			if 0 > effDy {
+				if 0 > effDy {
-				patternId = 3
+					patternId = 3
-			} else if 0 < effDy {
+				} else if 0 < effDy {
-				patternId = 2
+					patternId = 2
+				} else {
+					patternId = 1
+				}
 			} else {
-				patternId = 1
+				patternId = 4 // Holding
 			}
-		} else {
-			patternId = 4 // Holding
 		}
 	}
 
@@ -562,7 +566,7 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 	for i, currPlayerDownsync := range currRenderFrame.PlayersArr {
 		chConfig := chConfigsOrderedByJoinIndex[i]
 		thatPlayerInNextFrame := nextRenderFramePlayers[i]
-		patternId, jumpedOrNot, effDx, effDy := deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame, currRenderFrame, inputsBuffer)
+		patternId, jumpedOrNot, effDx, effDy := deriveOpPattern(currPlayerDownsync, thatPlayerInNextFrame, currRenderFrame, chConfig, inputsBuffer)
 
 		jumpedOrNotList[i] = jumpedOrNot
 		joinIndex := currPlayerDownsync.JoinIndex
@@ -642,15 +646,17 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 			   }
 			*/
 			alignedWithInertia := true
+			exactTurningAround := false
 			if 0 == effDx && 0 != thatPlayerInNextFrame.VelX {
 				alignedWithInertia = false
 			} else if 0 != effDx && 0 == thatPlayerInNextFrame.VelX {
 				alignedWithInertia = false
 			} else if 0 > effDx*thatPlayerInNextFrame.VelX {
 				alignedWithInertia = false
+				exactTurningAround = true
 			}
 
-			if !isWallJumping && !prevCapturedByInertia && !alignedWithInertia {
+			if !jumpedOrNot && !isWallJumping && !prevCapturedByInertia && !alignedWithInertia {
 				/*
 				   [WARNING] A "turn-around", or in more generic direction schema a "change in direction" is a hurdle for our current "prediction+rollback" approach, yet applying a "FramesToRecover" for "turn-around" can alleviate the graphical inconsistence to a huge extent! For better operational experience, this is intentionally NOT APPLIED TO WALL JUMPING!
 
@@ -659,6 +665,9 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 				//fmt.Printf("joinIndex=%d is not wall jumping and not aligned w/ inertia\n{renderFrame.id: %d, effDx: %d, thatPlayerInNextFrame.VelX: %d}\n", currPlayerDownsync.JoinIndex, currRenderFrame.Id, effDx, thatPlayerInNextFrame.VelX)
 				thatPlayerInNextFrame.CapturedByInertia = true
 				thatPlayerInNextFrame.FramesToRecover = chConfig.InertiaFramesToRecover
+				if exactTurningAround {
+					thatPlayerInNextFrame.CharacterState = ATK_CHARACTER_STATE_TURNAROUND
+				}
 			} else {
 				thatPlayerInNextFrame.CapturedByInertia = false
 				if 0 != effDx {
@@ -1053,7 +1062,7 @@ func ApplyInputFrameDownsyncDynamicsOnSingleRenderFrame(inputsBuffer *RingBuffer
 		if thatPlayerInNextFrame.InAir {
 			oldNextCharacterState := thatPlayerInNextFrame.CharacterState
 			switch oldNextCharacterState {
-			case ATK_CHARACTER_STATE_IDLE1, ATK_CHARACTER_STATE_WALKING:
+			case ATK_CHARACTER_STATE_IDLE1, ATK_CHARACTER_STATE_WALKING, ATK_CHARACTER_STATE_TURNAROUND:
 				if thatPlayerInNextFrame.OnWall {
 					thatPlayerInNextFrame.CharacterState = ATK_CHARACTER_STATE_ONWALL
 				} else if jumpedOrNotList[i] || ATK_CHARACTER_STATE_INAIR_IDLE1_BY_JUMP == currPlayerDownsync.CharacterState {

jsexport/battle/characterConfig.go

@@ -45,11 +45,11 @@ var Characters = map[int]*CharacterConfig{
 		GetUpInvinsibleFrames: int32(10),
 		GetUpFramesToRecover:  int32(27),
 
-		Speed:                  int32(float64(2.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
+		Speed:                  int32(float64(2.1) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingInitVelY:        int32(float64(8) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingFramesToRecover: int32(2),
 
-		InertiaFramesToRecover: int32(5),
+		InertiaFramesToRecover: int32(8),
 
 		DashingEnabled: false,
 		OnWallEnabled:  false,
@@ -94,11 +94,11 @@ var Characters = map[int]*CharacterConfig{
 		GetUpInvinsibleFrames: int32(10),
 		GetUpFramesToRecover:  int32(27),
 
-		Speed:                  int32(float64(2.6) * WORLD_TO_VIRTUAL_GRID_RATIO),
+		Speed:                  int32(float64(2.19) * WORLD_TO_VIRTUAL_GRID_RATIO), // I don't know why "2.2" is so special that it throws a compile error
 		JumpingInitVelY:        int32(float64(7.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingFramesToRecover: int32(2),
 
-		InertiaFramesToRecover: int32(5),
+		InertiaFramesToRecover: int32(8),
 
 		DashingEnabled:             true,
 		OnWallEnabled:              true,
@@ -128,6 +128,8 @@ var Characters = map[int]*CharacterConfig{
 						}
 					}
 				}
+			} else if 5 == patternId {
+				return 12
 			}
 
 			// By default no skill can be fired
@@ -147,11 +149,11 @@ var Characters = map[int]*CharacterConfig{
 		GetUpInvinsibleFrames: int32(8),
 		GetUpFramesToRecover:  int32(30),
 
-		Speed:                  int32(float64(2.0) * WORLD_TO_VIRTUAL_GRID_RATIO),
+		Speed:                  int32(float64(1.8) * WORLD_TO_VIRTUAL_GRID_RATIO),
-		JumpingInitVelY:        int32(float64(7.5) * WORLD_TO_VIRTUAL_GRID_RATIO),
+		JumpingInitVelY:        int32(float64(7.8) * WORLD_TO_VIRTUAL_GRID_RATIO),
 		JumpingFramesToRecover: int32(2),
 
-		InertiaFramesToRecover: int32(5),
+		InertiaFramesToRecover: int32(8),
 
 		DashingEnabled: false,
 		OnWallEnabled:  false,
@@ -547,6 +549,33 @@ var skills = map[int]*Skill{
 			},
 		},
 	},
+	12: &Skill{
+		RecoveryFrames:        int32(15),
+		RecoveryFramesOnBlock: int32(15),
+		RecoveryFramesOnHit:   int32(15),
+		ReleaseTriggerType:    int32(1),
+		BoundChState:          ATK_CHARACTER_STATE_DASHING,
+		Hits: []interface{}{
+			&MeleeBullet{
+				Bullet: &BulletConfig{
+					StartupFrames:   int32(0),
+					ActiveFrames:    int32(0),
+					HitStunFrames:   MAX_INT32,
+					BlockStunFrames: int32(0),
+					Damage:          int32(0),
+					SelfLockVelX:    int32(float64(9) * WORLD_TO_VIRTUAL_GRID_RATIO),
+					SelfLockVelY:    int32(0),
+					PushbackVelX:    NO_LOCK_VEL,
+					PushbackVelY:    NO_LOCK_VEL,
+					HitboxOffsetX:   int32(0),
+					HitboxOffsetY:   int32(0),
+					HitboxSizeX:     int32(0),
+					HitboxSizeY:     int32(0),
+					BlowUp:          false,
+				},
+			},
+		},
+	},
 	255: &Skill{
 		RecoveryFrames:        int32(30),
 		RecoveryFramesOnBlock: int32(30),