Update ServerKnockbackStabilizer.cs

Zheneq · Zheneq · commit 6fa0890e3ce6 · 2024-01-05T17:48:22.000+04:00
diff --git a/Assembly-CSharp/ServerKnockbackStabilizer.cs b/Assembly-CSharp/ServerKnockbackStabilizer.cs
@@ -7,29 +7,21 @@
 #if SERVER
 public class ServerKnockbackStabilizer
 {
-	public void StabilizeKnockbacks(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks, List<BoardSquare> additionalInvalidSquares)
+	public void StabilizeKnockbacks(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks,
+		List<BoardSquare> additionalInvalidSquares)
 	{
-		bool flag = true;
-		while (flag)
+		while (StabilizeKnockbacksForValidDestination(incomingKnockbacks, additionalInvalidSquares)
+		       || StabilizeKnockbacksVsObstacles(incomingKnockbacks) 
+		       || StabilizeKnockbacksVsStationaries(incomingKnockbacks)
+		       || StabilizeKnockbacksVsKnockbackees(incomingKnockbacks))
 		{
-			bool flag2 = StabilizeKnockbacksForValidDestination(incomingKnockbacks, additionalInvalidSquares);
-			if (!flag2)
-			{
-				flag2 = StabilizeKnockbacksVsObstacles(incomingKnockbacks);
-			}
-			if (!flag2)
-			{
-				flag2 = StabilizeKnockbacksVsStationaries(incomingKnockbacks);
-			}
-			if (!flag2)
-			{
-				flag2 = StabilizeKnockbacksVsKnockbackees(incomingKnockbacks);
-			}
-			flag = flag2;
 		}
 	}
 
-	private bool StabilizeKnockbacksForValidDestination(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks, List<BoardSquare> additionalInvalidSquares)
+	private bool StabilizeKnockbacksForValidDestination(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks,
+		List<BoardSquare> additionalInvalidSquares)
 	{
 		bool flag = false;
 		foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry in incomingKnockbacks)
@@ -39,35 +31,42 @@ private bool StabilizeKnockbacksForValidDestination(Dictionary<ActorData, Server
 		return flag;
 	}
 
-	private bool StabilizeKnockbackEntryForValidDestination(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry, List<BoardSquare> additionalInvalidSquares)
+	private bool StabilizeKnockbackEntryForValidDestination(
+		KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry,
+		List<BoardSquare> additionalInvalidSquares)
 	{
-		bool result = false;
-		BoardSquarePathInfo boardSquarePathInfo = knockbackEntry.Value.GetKnockbackPath().GetPathEndpoint();
-		BoardSquarePathInfo boardSquarePathInfo2 = boardSquarePathInfo;
-		bool flag = boardSquarePathInfo.square != null && boardSquarePathInfo.square.IsValidForGameplay() && !additionalInvalidSquares.Contains(boardSquarePathInfo.square);
-		while (!flag)
+		BoardSquarePathInfo endpoint = knockbackEntry.Value.GetKnockbackPath().GetPathEndpoint();
+		BoardSquarePathInfo initialEndpoint = endpoint;
+		bool isValidEndpoint = endpoint.square != null
+		            && endpoint.square.IsValidForGameplay()
+		            && !additionalInvalidSquares.Contains(endpoint.square);
+		while (!isValidEndpoint)
 		{
-			if (boardSquarePathInfo.prev == null)
+			if (endpoint.prev == null)
 			{
-				flag = true;
+				isValidEndpoint = true;
 			}
 			else
 			{
-				boardSquarePathInfo.square = null;
-				boardSquarePathInfo.prev.next = null;
-				boardSquarePathInfo = boardSquarePathInfo.prev;
-				flag = (boardSquarePathInfo.square != null && boardSquarePathInfo.square.IsValidForGameplay());
+				endpoint.square = null;
+				endpoint.prev.next = null;
+				endpoint = endpoint.prev;
+				isValidEndpoint = endpoint.square != null && endpoint.square.IsValidForGameplay();
 			}
 		}
-		if (boardSquarePathInfo2 != boardSquarePathInfo)
+		if (initialEndpoint != endpoint)
 		{
-			knockbackEntry.Value.OnKnockbackPathStabilized(boardSquarePathInfo.square);
-			result = true;
+			knockbackEntry.Value.OnKnockbackPathStabilized(endpoint.square);
+			return true;
+		}
+		else
+		{
+			return false;
 		}
-		return result;
 	}
 
-	private bool StabilizeKnockbacksVsObstacles(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
+	private bool StabilizeKnockbacksVsObstacles(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
 	{
 		bool flag = false;
 		foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry in incomingKnockbacks)
@@ -77,112 +76,122 @@ private bool StabilizeKnockbacksVsObstacles(Dictionary<ActorData, ServerKnockbac
 		return flag;
 	}
 
-	private bool StabilizeKnockbackEntryVsObstacles(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry)
+	private bool StabilizeKnockbackEntryVsObstacles(
+		KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry)
 	{
 		bool result = false;
 		ActorData key = knockbackEntry.Key;
-		BoardSquarePathInfo boardSquarePathInfo = knockbackEntry.Value.GetKnockbackPath();
-		BoardSquarePathInfo boardSquarePathInfo2 = boardSquarePathInfo.next;
-		BoardSquarePathInfo prev = boardSquarePathInfo.prev;
-		while (boardSquarePathInfo2 != null)
+		BoardSquarePathInfo step = knockbackEntry.Value.GetKnockbackPath();
+		BoardSquarePathInfo next = step.next;
+		BoardSquarePathInfo prev = step.prev;
+		while (next != null)
 		{
-			bool flag = (prev != null && BarrierManager.Get() != null && BarrierManager.Get().IsMovementBlockedOnCrossover(key, prev.square, boardSquarePathInfo.square)) || (BarrierManager.Get() != null && BarrierManager.Get().IsMovementBlocked(key, boardSquarePathInfo.square, boardSquarePathInfo2.square));
-			if (flag)
+			if ((prev != null
+			     && BarrierManager.Get() != null
+			     && BarrierManager.Get().IsMovementBlockedOnCrossover(key, prev.square, step.square))
+			    || (BarrierManager.Get() != null
+			        && BarrierManager.Get().IsMovementBlocked(key, step.square, next.square)))
 			{
-				boardSquarePathInfo.next = null;
-				boardSquarePathInfo2.prev = null;
-				boardSquarePathInfo2 = null;
-				knockbackEntry.Value.OnKnockbackPathStabilized(boardSquarePathInfo.square);
+				step.next = null;
+				next.prev = null;
+				next = null;
+				knockbackEntry.Value.OnKnockbackPathStabilized(step.square);
 				result = true;
 			}
 			else
 			{
-				boardSquarePathInfo = boardSquarePathInfo2;
-				prev = boardSquarePathInfo2.prev;
-				boardSquarePathInfo2 = boardSquarePathInfo2.next;
+				step = next;
+				prev = next.prev;
+				next = next.next;
 			}
 		}
 		return result;
 	}
 
-	private bool StabilizeKnockbacksVsStationaries(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
+	private bool StabilizeKnockbacksVsStationaries(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
 	{
 		bool result = false;
 		foreach (ActorData actorData in GetStationaryActorsWrtKnockback(incomingKnockbacks))
 		{
-			if (!actorData.IsDead())
+			if (actorData.IsDead())
 			{
-				BoardSquare currentBoardSquare = actorData.GetCurrentBoardSquare();
-				foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair in incomingKnockbacks)
+				continue;
+			}
+			BoardSquare currentBoardSquare = actorData.GetCurrentBoardSquare();
+			foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair in incomingKnockbacks)
+			{
+				ServerKnockbackManager.KnockbackHits value = keyValuePair.Value;
+				if (value.GetKnockbackEndSquare() == currentBoardSquare)
 				{
-					ServerKnockbackManager.KnockbackHits value = keyValuePair.Value;
-					if (value.GetKnockbackEndSquare() == currentBoardSquare)
+					BoardSquarePathInfo boardSquarePathInfo = value.GetKnockbackPath().BackUpOnceFromEnd();
+					if (value.GetKnockbackEndSquare() != boardSquarePathInfo.square)
+					{
+						value.OnKnockbackPathStabilized(boardSquarePathInfo.square);
+						result = true;
+					}
+					else
 					{
-						BoardSquarePathInfo boardSquarePathInfo = value.GetKnockbackPath().BackUpOnceFromEnd();
-						if (value.GetKnockbackEndSquare() != boardSquarePathInfo.square)
-						{
-							value.OnKnockbackPathStabilized(boardSquarePathInfo.square);
-							result = true;
-						}
-						else
-						{
-							Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsStationaries.");
-						}
+						Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsStationaries.");
 					}
 				}
 			}
 		}
 		return result;
 	}
 
-	private bool StabilizeKnockbacksVsKnockbackees(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
+	private bool StabilizeKnockbacksVsKnockbackees(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
 	{
-		bool flag = false;
-		List<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>> list = incomingKnockbacks.ToList<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>>();
-		list.Sort(delegate(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> x, KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> y)
+		List<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>> incomingKnockbacksSorted = incomingKnockbacks.ToList();
+		incomingKnockbacksSorted.Sort((x, y) =>
 		{
-			float num2 = x.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(x.Key.GetCurrentBoardSquare());
-			float value3 = y.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(y.Key.GetCurrentBoardSquare());
-			return num2.CompareTo(value3);
+			float xDist = x.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(x.Key.GetCurrentBoardSquare());
+			float yDist = y.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(y.Key.GetCurrentBoardSquare());
+			return xDist.CompareTo(yDist);
 		});
-		int num = 0;
-		while (num < list.Count && !flag)
+		
+		bool stabilized = false;
+		for (int i = 0; i < incomingKnockbacksSorted.Count; i++)
 		{
-			ServerKnockbackManager.KnockbackHits value = list[num].Value;
-			for (int i = num + 1; i < list.Count; i++)
+			ServerKnockbackManager.KnockbackHits knockback1 = incomingKnockbacksSorted[i].Value;
+			for (int j = i + 1; j < incomingKnockbacksSorted.Count; j++)
 			{
-				KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair = list[i];
-				ServerKnockbackManager.KnockbackHits value2 = keyValuePair.Value;
-				if (value.GetKnockbackEndSquare() == value2.GetKnockbackEndSquare())
+				ServerKnockbackManager.KnockbackHits knockback2 = incomingKnockbacksSorted[j].Value;
+				if (knockback1.GetKnockbackEndSquare() == knockback2.GetKnockbackEndSquare())
 				{
-					BoardSquarePathInfo boardSquarePathInfo = value2.GetKnockbackPath().BackUpOnceFromEnd();
-					if (boardSquarePathInfo.square != value2.GetKnockbackEndSquare())
+					BoardSquarePathInfo stepBack = knockback2.GetKnockbackPath().BackUpOnceFromEnd();
+					if (stepBack.square != knockback2.GetKnockbackEndSquare())
 					{
-						value2.OnKnockbackPathStabilized(boardSquarePathInfo.square);
-						flag = true;
+						knockback2.OnKnockbackPathStabilized(stepBack.square);
+						stabilized = true;
 					}
 					else
 					{
-						Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsKnockbackees.");
+						Log.Error($"Failed to back up {incomingKnockbacksSorted[j].Key} in StabilizeKnockbacksVsKnockbackees.");
 					}
 				}
 			}
-			num++;
+			if (stabilized)
+			{
+				return true;
+			}
 		}
-		return flag;
+		return false;
 	}
 
-	private List<ActorData> GetStationaryActorsWrtKnockback(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
+	private List<ActorData> GetStationaryActorsWrtKnockback(
+		Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)
 	{
-		List<ActorData> list = new List<ActorData>(GameFlowData.Get().GetActors());
+		List<ActorData> actors = new List<ActorData>(GameFlowData.Get().GetActors());
 		foreach (ActorData item in incomingKnockbacks.Keys)
 		{
-			if (list.Contains(item))
+			if (actors.Contains(item))
 			{
-				list.Remove(item);
+				actors.Remove(item);
 			}
 		}
-		return list;
+		return actors;
 	}
 }
 #endif

Original file line number	Diff line number	Diff line change
`@@ -7,29 +7,21 @@`
`7`	`7`	`#if SERVER`
`8`	`8`	`public class ServerKnockbackStabilizer`
`9`	`9`	`{`
`10`		`- public void StabilizeKnockbacks(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks, List<BoardSquare> additionalInvalidSquares)`
	`10`	`+ public void StabilizeKnockbacks(`
	`11`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks,`
	`12`	`+ List<BoardSquare> additionalInvalidSquares)`
`11`	`13`	`{`
`12`		`- bool flag = true;`
`13`		`- while (flag)`
	`14`	`+ while (StabilizeKnockbacksForValidDestination(incomingKnockbacks, additionalInvalidSquares)`
	`15`	`+ \|\| StabilizeKnockbacksVsObstacles(incomingKnockbacks)`
	`16`	`+ \|\| StabilizeKnockbacksVsStationaries(incomingKnockbacks)`
	`17`	`+ \|\| StabilizeKnockbacksVsKnockbackees(incomingKnockbacks))`
`14`	`18`	`{`
`15`		`- bool flag2 = StabilizeKnockbacksForValidDestination(incomingKnockbacks, additionalInvalidSquares);`
`16`		`- if (!flag2)`
`17`		`- {`
`18`		`- flag2 = StabilizeKnockbacksVsObstacles(incomingKnockbacks);`
`19`		`- }`
`20`		`- if (!flag2)`
`21`		`- {`
`22`		`- flag2 = StabilizeKnockbacksVsStationaries(incomingKnockbacks);`
`23`		`- }`
`24`		`- if (!flag2)`
`25`		`- {`
`26`		`- flag2 = StabilizeKnockbacksVsKnockbackees(incomingKnockbacks);`
`27`		`- }`
`28`		`- flag = flag2;`
`29`	`19`	`}`
`30`	`20`	`}`
`31`	`21`
`32`		`- private bool StabilizeKnockbacksForValidDestination(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks, List<BoardSquare> additionalInvalidSquares)`
	`22`	`+ private bool StabilizeKnockbacksForValidDestination(`
	`23`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks,`
	`24`	`+ List<BoardSquare> additionalInvalidSquares)`
`33`	`25`	`{`
`34`	`26`	`bool flag = false;`
`35`	`27`	`foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry in incomingKnockbacks)`
`@@ -39,35 +31,42 @@ private bool StabilizeKnockbacksForValidDestination(Dictionary<ActorData, Server`
`39`	`31`	`return flag;`
`40`	`32`	`}`
`41`	`33`
`42`		`- private bool StabilizeKnockbackEntryForValidDestination(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry, List<BoardSquare> additionalInvalidSquares)`
	`34`	`+ private bool StabilizeKnockbackEntryForValidDestination(`
	`35`	`+ KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry,`
	`36`	`+ List<BoardSquare> additionalInvalidSquares)`
`43`	`37`	`{`
`44`		`- bool result = false;`
`45`		`- BoardSquarePathInfo boardSquarePathInfo = knockbackEntry.Value.GetKnockbackPath().GetPathEndpoint();`
`46`		`- BoardSquarePathInfo boardSquarePathInfo2 = boardSquarePathInfo;`
`47`		`- bool flag = boardSquarePathInfo.square != null && boardSquarePathInfo.square.IsValidForGameplay() && !additionalInvalidSquares.Contains(boardSquarePathInfo.square);`
`48`		`- while (!flag)`
	`38`	`+ BoardSquarePathInfo endpoint = knockbackEntry.Value.GetKnockbackPath().GetPathEndpoint();`
	`39`	`+ BoardSquarePathInfo initialEndpoint = endpoint;`
	`40`	`+ bool isValidEndpoint = endpoint.square != null`
	`41`	`+ && endpoint.square.IsValidForGameplay()`
	`42`	`+ && !additionalInvalidSquares.Contains(endpoint.square);`
	`43`	`+ while (!isValidEndpoint)`
`49`	`44`	`{`
`50`		`- if (boardSquarePathInfo.prev == null)`
	`45`	`+ if (endpoint.prev == null)`
`51`	`46`	`{`
`52`		`- flag = true;`
	`47`	`+ isValidEndpoint = true;`
`53`	`48`	`}`
`54`	`49`	`else`
`55`	`50`	`{`
`56`		`- boardSquarePathInfo.square = null;`
`57`		`- boardSquarePathInfo.prev.next = null;`
`58`		`- boardSquarePathInfo = boardSquarePathInfo.prev;`
`59`		`- flag = (boardSquarePathInfo.square != null && boardSquarePathInfo.square.IsValidForGameplay());`
	`51`	`+ endpoint.square = null;`
	`52`	`+ endpoint.prev.next = null;`
	`53`	`+ endpoint = endpoint.prev;`
	`54`	`+ isValidEndpoint = endpoint.square != null && endpoint.square.IsValidForGameplay();`
`60`	`55`	`}`
`61`	`56`	`}`
`62`		`- if (boardSquarePathInfo2 != boardSquarePathInfo)`
	`57`	`+ if (initialEndpoint != endpoint)`
`63`	`58`	`{`
`64`		`- knockbackEntry.Value.OnKnockbackPathStabilized(boardSquarePathInfo.square);`
`65`		`- result = true;`
	`59`	`+ knockbackEntry.Value.OnKnockbackPathStabilized(endpoint.square);`
	`60`	`+ return true;`
	`61`	`+ }`
	`62`	`+ else`
	`63`	`+ {`
	`64`	`+ return false;`
`66`	`65`	`}`
`67`		`- return result;`
`68`	`66`	`}`
`69`	`67`
`70`		`- private bool StabilizeKnockbacksVsObstacles(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
	`68`	`+ private bool StabilizeKnockbacksVsObstacles(`
	`69`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
`71`	`70`	`{`
`72`	`71`	`bool flag = false;`
`73`	`72`	`foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry in incomingKnockbacks)`
`@@ -77,112 +76,122 @@ private bool StabilizeKnockbacksVsObstacles(Dictionary<ActorData, ServerKnockbac`
`77`	`76`	`return flag;`
`78`	`77`	`}`
`79`	`78`
`80`		`- private bool StabilizeKnockbackEntryVsObstacles(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry)`
	`79`	`+ private bool StabilizeKnockbackEntryVsObstacles(`
	`80`	`+ KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> knockbackEntry)`
`81`	`81`	`{`
`82`	`82`	`bool result = false;`
`83`	`83`	`ActorData key = knockbackEntry.Key;`
`84`		`- BoardSquarePathInfo boardSquarePathInfo = knockbackEntry.Value.GetKnockbackPath();`
`85`		`- BoardSquarePathInfo boardSquarePathInfo2 = boardSquarePathInfo.next;`
`86`		`- BoardSquarePathInfo prev = boardSquarePathInfo.prev;`
`87`		`- while (boardSquarePathInfo2 != null)`
	`84`	`+ BoardSquarePathInfo step = knockbackEntry.Value.GetKnockbackPath();`
	`85`	`+ BoardSquarePathInfo next = step.next;`
	`86`	`+ BoardSquarePathInfo prev = step.prev;`
	`87`	`+ while (next != null)`
`88`	`88`	`{`
`89`		`- bool flag = (prev != null && BarrierManager.Get() != null && BarrierManager.Get().IsMovementBlockedOnCrossover(key, prev.square, boardSquarePathInfo.square)) \|\| (BarrierManager.Get() != null && BarrierManager.Get().IsMovementBlocked(key, boardSquarePathInfo.square, boardSquarePathInfo2.square));`
`90`		`- if (flag)`
	`89`	`+ if ((prev != null`
	`90`	`+ && BarrierManager.Get() != null`
	`91`	`+ && BarrierManager.Get().IsMovementBlockedOnCrossover(key, prev.square, step.square))`
	`92`	`+ \|\| (BarrierManager.Get() != null`
	`93`	`+ && BarrierManager.Get().IsMovementBlocked(key, step.square, next.square)))`
`91`	`94`	`{`
`92`		`- boardSquarePathInfo.next = null;`
`93`		`- boardSquarePathInfo2.prev = null;`
`94`		`- boardSquarePathInfo2 = null;`
`95`		`- knockbackEntry.Value.OnKnockbackPathStabilized(boardSquarePathInfo.square);`
	`95`	`+ step.next = null;`
	`96`	`+ next.prev = null;`
	`97`	`+ next = null;`
	`98`	`+ knockbackEntry.Value.OnKnockbackPathStabilized(step.square);`
`96`	`99`	`result = true;`
`97`	`100`	`}`
`98`	`101`	`else`
`99`	`102`	`{`
`100`		`- boardSquarePathInfo = boardSquarePathInfo2;`
`101`		`- prev = boardSquarePathInfo2.prev;`
`102`		`- boardSquarePathInfo2 = boardSquarePathInfo2.next;`
	`103`	`+ step = next;`
	`104`	`+ prev = next.prev;`
	`105`	`+ next = next.next;`
`103`	`106`	`}`
`104`	`107`	`}`
`105`	`108`	`return result;`
`106`	`109`	`}`
`107`	`110`
`108`		`- private bool StabilizeKnockbacksVsStationaries(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
	`111`	`+ private bool StabilizeKnockbacksVsStationaries(`
	`112`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
`109`	`113`	`{`
`110`	`114`	`bool result = false;`
`111`	`115`	`foreach (ActorData actorData in GetStationaryActorsWrtKnockback(incomingKnockbacks))`
`112`	`116`	`{`
`113`		`- if (!actorData.IsDead())`
	`117`	`+ if (actorData.IsDead())`
`114`	`118`	`{`
`115`		`- BoardSquare currentBoardSquare = actorData.GetCurrentBoardSquare();`
`116`		`- foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair in incomingKnockbacks)`
	`119`	`+ continue;`
	`120`	`+ }`
	`121`	`+ BoardSquare currentBoardSquare = actorData.GetCurrentBoardSquare();`
	`122`	`+ foreach (KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair in incomingKnockbacks)`
	`123`	`+ {`
	`124`	`+ ServerKnockbackManager.KnockbackHits value = keyValuePair.Value;`
	`125`	`+ if (value.GetKnockbackEndSquare() == currentBoardSquare)`
`117`	`126`	`{`
`118`		`- ServerKnockbackManager.KnockbackHits value = keyValuePair.Value;`
`119`		`- if (value.GetKnockbackEndSquare() == currentBoardSquare)`
	`127`	`+ BoardSquarePathInfo boardSquarePathInfo = value.GetKnockbackPath().BackUpOnceFromEnd();`
	`128`	`+ if (value.GetKnockbackEndSquare() != boardSquarePathInfo.square)`
	`129`	`+ {`
	`130`	`+ value.OnKnockbackPathStabilized(boardSquarePathInfo.square);`
	`131`	`+ result = true;`
	`132`	`+ }`
	`133`	`+ else`
`120`	`134`	`{`
`121`		`- BoardSquarePathInfo boardSquarePathInfo = value.GetKnockbackPath().BackUpOnceFromEnd();`
`122`		`- if (value.GetKnockbackEndSquare() != boardSquarePathInfo.square)`
`123`		`- {`
`124`		`- value.OnKnockbackPathStabilized(boardSquarePathInfo.square);`
`125`		`- result = true;`
`126`		`- }`
`127`		`- else`
`128`		`- {`
`129`		`- Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsStationaries.");`
`130`		`- }`
	`135`	`+ Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsStationaries.");`
`131`	`136`	`}`
`132`	`137`	`}`
`133`	`138`	`}`
`134`	`139`	`}`
`135`	`140`	`return result;`
`136`	`141`	`}`
`137`	`142`
`138`		`- private bool StabilizeKnockbacksVsKnockbackees(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
	`143`	`+ private bool StabilizeKnockbacksVsKnockbackees(`
	`144`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
`139`	`145`	`{`
`140`		`- bool flag = false;`
`141`		`- List<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>> list = incomingKnockbacks.ToList<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>>();`
`142`		`- list.Sort(delegate(KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> x, KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> y)`
	`146`	`+ List<KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits>> incomingKnockbacksSorted = incomingKnockbacks.ToList();`
	`147`	`+ incomingKnockbacksSorted.Sort((x, y) =>`
`143`	`148`	`{`
`144`		`- float num2 = x.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(x.Key.GetCurrentBoardSquare());`
`145`		`- float value3 = y.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(y.Key.GetCurrentBoardSquare());`
`146`		`- return num2.CompareTo(value3);`
	`149`	`+ float xDist = x.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(x.Key.GetCurrentBoardSquare());`
	`150`	`+ float yDist = y.Value.GetKnockbackEndSquare().HorizontalDistanceOnBoardTo(y.Key.GetCurrentBoardSquare());`
	`151`	`+ return xDist.CompareTo(yDist);`
`147`	`152`	`});`
`148`		`- int num = 0;`
`149`		`- while (num < list.Count && !flag)`
	`153`	`+`
	`154`	`+ bool stabilized = false;`
	`155`	`+ for (int i = 0; i < incomingKnockbacksSorted.Count; i++)`
`150`	`156`	`{`
`151`		`- ServerKnockbackManager.KnockbackHits value = list[num].Value;`
`152`		`- for (int i = num + 1; i < list.Count; i++)`
	`157`	`+ ServerKnockbackManager.KnockbackHits knockback1 = incomingKnockbacksSorted[i].Value;`
	`158`	`+ for (int j = i + 1; j < incomingKnockbacksSorted.Count; j++)`
`153`	`159`	`{`
`154`		`- KeyValuePair<ActorData, ServerKnockbackManager.KnockbackHits> keyValuePair = list[i];`
`155`		`- ServerKnockbackManager.KnockbackHits value2 = keyValuePair.Value;`
`156`		`- if (value.GetKnockbackEndSquare() == value2.GetKnockbackEndSquare())`
	`160`	`+ ServerKnockbackManager.KnockbackHits knockback2 = incomingKnockbacksSorted[j].Value;`
	`161`	`+ if (knockback1.GetKnockbackEndSquare() == knockback2.GetKnockbackEndSquare())`
`157`	`162`	`{`
`158`		`- BoardSquarePathInfo boardSquarePathInfo = value2.GetKnockbackPath().BackUpOnceFromEnd();`
`159`		`- if (boardSquarePathInfo.square != value2.GetKnockbackEndSquare())`
	`163`	`+ BoardSquarePathInfo stepBack = knockback2.GetKnockbackPath().BackUpOnceFromEnd();`
	`164`	`+ if (stepBack.square != knockback2.GetKnockbackEndSquare())`
`160`	`165`	`{`
`161`		`- value2.OnKnockbackPathStabilized(boardSquarePathInfo.square);`
`162`		`- flag = true;`
	`166`	`+ knockback2.OnKnockbackPathStabilized(stepBack.square);`
	`167`	`+ stabilized = true;`
`163`	`168`	`}`
`164`	`169`	`else`
`165`	`170`	`{`
`166`		`- Log.Error($"Failed to back up {keyValuePair.Key} in StabilizeKnockbacksVsKnockbackees.");`
	`171`	`+ Log.Error($"Failed to back up {incomingKnockbacksSorted[j].Key} in StabilizeKnockbacksVsKnockbackees.");`
`167`	`172`	`}`
`168`	`173`	`}`
`169`	`174`	`}`
`170`		`- num++;`
	`175`	`+ if (stabilized)`
	`176`	`+ {`
	`177`	`+ return true;`
	`178`	`+ }`
`171`	`179`	`}`
`172`		`- return flag;`
	`180`	`+ return false;`
`173`	`181`	`}`
`174`	`182`
`175`		`- private List<ActorData> GetStationaryActorsWrtKnockback(Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
	`183`	`+ private List<ActorData> GetStationaryActorsWrtKnockback(`
	`184`	`+ Dictionary<ActorData, ServerKnockbackManager.KnockbackHits> incomingKnockbacks)`
`176`	`185`	`{`
`177`		`- List<ActorData> list = new List<ActorData>(GameFlowData.Get().GetActors());`
	`186`	`+ List<ActorData> actors = new List<ActorData>(GameFlowData.Get().GetActors());`
`178`	`187`	`foreach (ActorData item in incomingKnockbacks.Keys)`
`179`	`188`	`{`
`180`		`- if (list.Contains(item))`
	`189`	`+ if (actors.Contains(item))`
`181`	`190`	`{`
`182`		`- list.Remove(item);`
	`191`	`+ actors.Remove(item);`
`183`	`192`	`}`
`184`	`193`	`}`
`185`		`- return list;`
	`194`	`+ return actors;`
`186`	`195`	`}`
`187`	`196`	`}`
`188`	`197`	`#endif`