using System;
using System.Collections;
using System.Collections.Generic;
using Pathfinding;
using UnityEngine;

// Token: 0x0200002A RID: 42
public class EnemyGroup : MonoBehaviour
{
	// Token: 0x060006AF RID: 1711 RVA: 0x0008F5EC File Offset: 0x0008D7EC
	public void Setup(Character c1, Character c2, Character c3, Character c4, Character c5, Character c6, Character c7, Character c8, GraphNode startNode, GraphNode n1, GraphNode n2, GraphNode n3, GraphNode n4, GraphNode n5, GraphNode n6, GraphNode n7, GraphNode n8, GraphNode n9, GraphNode n10, GraphNode n11, GraphNode n12)
	{
		this.center = (Vector3)startNode.position;
		this.centroid = this.center;
		this.centerNode = startNode;
		this.allCharacters.Clear();
		this.circleTiles.Clear();
		this.centerCharacter = c1;
		this.dioramaCharacters = Links.x.diorama.characters;
		this.frontOfCircle = this.center;
		this.middleCircle = this.center;
		this.backOfCircle = this.center;
		this.morale = 50;
		this.needsFade = true;
		this.needsFadeOut = true;
		if (this.staminaFilling)
		{
			this.staminaRecover = Links.x.cellar.GetPooledGameObject(131);
			this.staminaRecover.SetActive(false);
		}
		this.timeSinceGather = Links.x.gameplay.seconds;
		if (!Records.x.editor)
		{
			this.debugConsole = false;
			this.debug = false;
		}
		if (this.debugConsole)
		{
			Debug.Log(string.Concat(new string[]
			{
				"New group ",
				this.groupID.ToString(),
				" aggressive? ",
				this.aggressive.ToString(),
				" stamina filling? ",
				this.staminaFilling.ToString(),
				" moving together? ",
				this.movingTogether.ToString()
			}));
		}
		if (c1)
		{
			this.allCharacters.Add(c1);
			this.allCharactersFormation.Add(0);
		}
		if (c2)
		{
			this.allCharacters.Add(c2);
			this.allCharactersFormation.Add(0);
		}
		if (c3)
		{
			this.allCharacters.Add(c3);
			this.allCharactersFormation.Add(0);
		}
		if (c4)
		{
			this.allCharacters.Add(c4);
			this.allCharactersFormation.Add(0);
		}
		if (c5)
		{
			this.allCharacters.Add(c5);
			this.allCharactersFormation.Add(0);
		}
		if (c6)
		{
			this.allCharacters.Add(c6);
			this.allCharactersFormation.Add(0);
		}
		if (c7)
		{
			this.allCharacters.Add(c7);
			this.allCharactersFormation.Add(0);
		}
		if (c8)
		{
			this.allCharacters.Add(c8);
			this.allCharactersFormation.Add(0);
		}
		this.CheckDirection(false);
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			Character character = this.allCharacters[i];
			if (character)
			{
				character.group = this;
				character.inCircle = true;
				if (character.actions)
				{
					character.actions.ai.UpdateCircleTiles();
					character.actions.CheckIfRunningAI();
				}
				character.ClearPathUpdates();
				character.ClearCurrentPathNodes();
				GraphNode formationPointInCircle = this.GetFormationPointInCircle(character, false);
				if (formationPointInCircle != null && formationPointInCircle != character.node)
				{
					this.JoinCirclePath(formationPointInCircle, character);
				}
			}
		}
		if (n1 != null)
		{
			this.circleTiles.Add(n1);
		}
		if (n2 != null)
		{
			this.circleTiles.Add(n2);
		}
		if (n3 != null)
		{
			this.circleTiles.Add(n3);
		}
		if (n4 != null)
		{
			this.circleTiles.Add(n4);
		}
		if (n5 != null)
		{
			this.circleTiles.Add(n5);
		}
		if (n6 != null)
		{
			this.circleTiles.Add(n6);
		}
		if (n7 != null)
		{
			this.circleTiles.Add(n7);
		}
		if (n8 != null)
		{
			this.circleTiles.Add(n8);
		}
		if (n9 != null)
		{
			this.circleTiles.Add(n9);
		}
		if (n10 != null)
		{
			this.circleTiles.Add(n10);
		}
		if (n11 != null)
		{
			this.circleTiles.Add(n11);
		}
		if (n12 != null)
		{
			this.circleTiles.Add(n12);
		}
		this.savedEndPoint = startNode;
		if (this.centerCharacter && this.centerCharacter.actions)
		{
			this.savedTarget = this.centerCharacter.actions.ai.NearestEnemy();
		}
		this.moveTo = (Vector3)this.savedEndPoint.position;
		this.openTiles.Clear();
		for (int j = 0; j < this.circleTiles.Count; j++)
		{
			this.openTiles.Add(this.circleTiles[j]);
		}
		int num = 9;
		if (this.allCharacters.Count <= 6)
		{
			num = 6;
		}
		if (this.allCharacters.Count <= 4)
		{
			num = 4;
		}
		if (this.allCharacters.Count <= 3)
		{
			num = 3;
		}
		this.circleTiles.Clear();
		this.circleTiles.Add(startNode);
		for (int k = 1; k < 9; k++)
		{
			int num2 = -1;
			if (num == 9 || num == 6)
			{
				if (k == 1)
				{
					num2 = 1;
				}
				if (k == 2)
				{
					num2 = 0;
				}
				if (k == 3)
				{
					num2 = 4;
				}
				if (k == 4)
				{
					num2 = 7;
				}
				if (k == 5)
				{
					num2 = 3;
				}
				if (k == 6)
				{
					num2 = 2;
				}
				if (k == 7)
				{
					num2 = 5;
				}
				if (k == 8)
				{
					num2 = 6;
				}
			}
			else if (num == 4)
			{
				if (k == 1)
				{
					num2 = 1;
				}
				if (k == 2)
				{
					num2 = 0;
				}
				if (k == 3)
				{
					num2 = 4;
				}
			}
			else if (num == 3)
			{
				if (k == 1)
				{
					num2 = 1;
				}
				if (k == 2)
				{
					num2 = 0;
				}
			}
			if (num2 > -1)
			{
				GraphNode connectionAtIndex = startNode.GetConnectionAtIndex(num2);
				if (connectionAtIndex != null)
				{
					float num3 = float.PositiveInfinity;
					int num4 = -1;
					for (int l = 0; l < this.openTiles.Count; l++)
					{
						float sqrMagnitude = ((Vector3)this.openTiles[l].position - (Vector3)connectionAtIndex.position).sqrMagnitude;
						if (sqrMagnitude < num3)
						{
							num3 = sqrMagnitude;
							num4 = l;
						}
					}
					if (num4 > -1)
					{
						this.circleTiles.Add(this.openTiles[num4]);
						this.openTiles.RemoveAt(num4);
					}
				}
			}
		}
		if (this.circleTiles.Count < num && n1 != null && !this.circleTiles.Contains(n1))
		{
			this.circleTiles.Add(n1);
		}
		if (this.circleTiles.Count < num && n2 != null && !this.circleTiles.Contains(n2))
		{
			this.circleTiles.Add(n2);
		}
		if (this.circleTiles.Count < num && n3 != null && !this.circleTiles.Contains(n3))
		{
			this.circleTiles.Add(n3);
		}
		if (this.circleTiles.Count < num && n4 != null && !this.circleTiles.Contains(n4))
		{
			this.circleTiles.Add(n4);
		}
		if (this.circleTiles.Count < num && n5 != null && !this.circleTiles.Contains(n5))
		{
			this.circleTiles.Add(n5);
		}
		if (this.circleTiles.Count < num && n6 != null && !this.circleTiles.Contains(n6))
		{
			this.circleTiles.Add(n6);
		}
		if (this.circleTiles.Count < num && n7 != null && !this.circleTiles.Contains(n7))
		{
			this.circleTiles.Add(n7);
		}
		if (this.circleTiles.Count < num && n8 != null && !this.circleTiles.Contains(n8))
		{
			this.circleTiles.Add(n8);
		}
		if (this.circleTiles.Count < num && n9 != null && !this.circleTiles.Contains(n9))
		{
			this.circleTiles.Add(n9);
		}
		bool flag = true;
		Vector3 vector = (Vector3)this.circleTiles[0].position;
		for (int m = 1; m < this.circleTiles.Count; m++)
		{
			if ((vector - (Vector3)this.circleTiles[m].position).sqrMagnitude > 16f)
			{
				flag = false;
			}
		}
		if (!flag)
		{
			this.circleTiles.Clear();
			if (n1 != null)
			{
				this.circleTiles.Add(n1);
			}
			if (n2 != null)
			{
				this.circleTiles.Add(n2);
			}
			if (n3 != null)
			{
				this.circleTiles.Add(n3);
			}
			if (n4 != null)
			{
				this.circleTiles.Add(n4);
			}
			if (n5 != null)
			{
				this.circleTiles.Add(n5);
			}
			if (n6 != null)
			{
				this.circleTiles.Add(n6);
			}
			if (n7 != null)
			{
				this.circleTiles.Add(n7);
			}
			if (n8 != null)
			{
				this.circleTiles.Add(n8);
			}
			if (n9 != null)
			{
				this.circleTiles.Add(n9);
			}
			if (n10 != null)
			{
				this.circleTiles.Add(n10);
			}
			if (n11 != null)
			{
				this.circleTiles.Add(n11);
			}
			if (n12 != null)
			{
				this.circleTiles.Add(n12);
			}
		}
		for (int num5 = 0; num5 < this.circleTiles.Count; num5++)
		{
			if (this.circleTiles[num5].circle == 0)
			{
				this.circleTiles[num5].circle = this.groupID;
			}
			this.nearNodes.Add(this.circleTiles[num5]);
		}
		this.SetCircleTiles(false);
		if (this.staminaFilling || this.aggressive || this.movingTogether)
		{
			this.inFormationMovement = true;
			this.timeSinceFormation = Links.x.gameplay.seconds;
			for (int num6 = 0; num6 < this.allCharactersFormation.Count; num6++)
			{
				this.allCharactersFormation[num6] = 1;
			}
			this.FormationPoints(true, this.centerCharacter, this.savedEndPoint, "Flank");
			if (this.debugConsole)
			{
				Debug.Log(this.groupID.ToString() + " Start formation listen");
			}
		}
		else
		{
			this.defensive = true;
		}
		for (int num7 = 0; num7 < this.allCharacters.Count; num7++)
		{
			this.originalCharacters.Add(this.allCharacters[num7]);
			this.timeOutsideCircle.Add(-1f);
		}
	}

	// Token: 0x060006B0 RID: 1712 RVA: 0x0009001C File Offset: 0x0008E21C
	public void Update()
	{
		if (this.fading)
		{
			this.currentDither = Mathf.Lerp(this.startDither, this.endDither, this.fadeAmount);
			if ((this.endDither == 1f && this.currentDither >= 1f) || (this.endDither == 0f && this.currentDither <= 0f))
			{
				this.fading = false;
				if (this.endDither == 1f)
				{
					Links.x.cameraEffects.ClearEnemyGroupTiles(this);
				}
			}
			if (this.endDither == 1f)
			{
				this.fadeAmount += Time.deltaTime * 5f;
			}
			else
			{
				this.fadeAmount += Time.deltaTime * 1f;
			}
		}
		if (this.pulsing)
		{
			this.pulse = Mathf.Lerp(this.startPulseDither, this.endPulseDither, this.pulseAmount);
			if ((this.endPulseDither == 1f && this.pulse >= 1f) || (this.endPulseDither == 0f && this.pulse <= 0.01f))
			{
				if (this.endPulseDither == 1f)
				{
					this.StartPulse(false);
					for (int i = 0; i < this.allCharacters.Count; i++)
					{
						Character character = this.allCharacters[i];
						if (character.hasCreatureBuff)
						{
							this.Rest(character);
						}
					}
				}
				else
				{
					this.pulsing = false;
				}
			}
			else
			{
				this.pulseAmount += Time.deltaTime * 4f;
			}
		}
		if (Links.x.gaia.pathfindingReady && Links.x.gaia.sceneLoaded && Records.x.combat && !this.isBreaking)
		{
			bool flag = false;
			bool flag2 = true;
			int count = this.originalCharacters.Count;
			int num = (int)Mathf.Ceil((float)count / 2f) - 1;
			int num2 = (int)Mathf.Round((float)count * 0.8f);
			int num3 = (int)Mathf.Round((float)count * 0.6f);
			if (num < 2)
			{
				num = 2;
			}
			int num4 = 1;
			if (num == 4 || num == 5)
			{
				num4 = 2;
			}
			if (num >= 6)
			{
				num4 = 3;
			}
			this.dangerLevel = 0;
			this.inCircleCount = 0;
			this.canBeInCircle = 0;
			float seconds = Links.x.gameplay.seconds;
			int num5 = 0;
			for (int j = 0; j < count; j++)
			{
				Character character2 = this.originalCharacters[j];
				if (character2 && character2.IsSentient() && character2.inCircle)
				{
					bool flag3;
					if (!character2.hasCreatureBuff)
					{
						if (this.timeOutsideCircle[j] == 0f)
						{
							this.canBeInCircle++;
							this.timeOutsideCircle[j] = seconds;
							flag3 = true;
							if (this.defensive && this.CharacterNeedsToBeDefended(character2))
							{
								num5++;
							}
						}
						else if (this.timeOutsideCircle[j] == -1f)
						{
							this.canBeInCircle++;
							if (character2.hasCreatureBuff)
							{
								this.timeOutsideCircle[j] = 0f;
							}
							flag3 = true;
							if (this.defensive && this.CharacterNeedsToBeDefended(character2))
							{
								num5++;
							}
						}
						else if (seconds > this.timeOutsideCircle[j] + 10f)
						{
							this.canBeInCircle++;
							flag3 = false;
							if (this.defensive && this.CharacterNeedsToBeDefended(character2))
							{
								num5++;
							}
						}
						else if (seconds > this.timeOutsideCircle[j] + 80f || (character2.fleeing && seconds > this.timeOutsideCircle[j] + 10f))
						{
							this.timeOutsideCircle[j] = -1f;
							flag3 = false;
							flag2 = true;
							this.LeaveCircle(character2);
						}
						else
						{
							if (this.defensive && this.CharacterNeedsToBeDefended(character2))
							{
								num5++;
							}
							this.canBeInCircle++;
							flag3 = true;
						}
					}
					else
					{
						if (this.defensive && this.CharacterNeedsToBeDefended(character2))
						{
							num5++;
						}
						this.canBeInCircle++;
						this.timeOutsideCircle[j] = 0f;
						flag3 = character2.IsSentient();
						if (!character2.IsSentient())
						{
							flag2 = true;
						}
					}
					if (flag3)
					{
						this.inCircleCount++;
					}
				}
			}
			if (this.defensive && num5 == 0)
			{
				flag = true;
			}
			if (this.inCircleCount < num && !this.inSwarm && !this.inSwarmWait && !this.inFormationMovement && !this.movingTogether)
			{
				flag = true;
			}
			else
			{
				if (this.inCircleCount <= num2)
				{
					this.dangerLevel++;
				}
				if (this.inCircleCount <= num3)
				{
					this.dangerLevel++;
				}
			}
			if (!flag)
			{
				this.intruderTemp.Clear();
				this.intruderTimeTemp.Clear();
				int num6 = 0;
				int num7 = 0;
				int num8 = 0;
				Character characterInCircle = this.centerCharacter;
				if (!characterInCircle)
				{
					characterInCircle = this.GetCharacterInCircle();
					this.centerCharacter = characterInCircle;
				}
				if (characterInCircle)
				{
					for (int k = 0; k < this.dioramaCharacters.Count; k++)
					{
						Character character3 = this.dioramaCharacters[k];
						if (character3 && (!character3.npc || characterInCircle.stats.IsTargetAnEnemy(character3.stats.allegiance)) && this.InCircle(character3.currentPosition, true, false, null))
						{
							int num9 = this.intruders.IndexOf(character3);
							if (num9 == -1)
							{
								this.intruderTemp.Add(character3);
								this.intruderTimeTemp.Add(seconds);
							}
							else
							{
								float num10 = this.intruderTime[num9];
								this.intruderTemp.Add(character3);
								this.intruderTimeTemp.Add(num10);
								if (seconds > num10 + 100f)
								{
									num6++;
									if (seconds > num10 + 400f)
									{
										num8++;
									}
								}
								else
								{
									num7++;
								}
							}
						}
					}
					this.intruders.Clear();
					this.intruderTime.Clear();
					int num11 = 0;
					for (int l = 0; l < this.intruderTemp.Count; l++)
					{
						this.intruders.Add(this.intruderTemp[l]);
						this.intruderTime.Add(this.intruderTimeTemp[l]);
						if (seconds > this.intruderTimeTemp[l] + 60f)
						{
							num11++;
						}
					}
					if (num6 >= num4 || num8 > 0)
					{
						flag = true;
						flag2 = true;
					}
					if (num6 >= 1)
					{
						this.dangerLevel++;
					}
					if (num7 >= 1)
					{
						this.dangerLevel++;
					}
					if (num11 >= 2)
					{
						this.dangerLevel++;
					}
				}
				else
				{
					flag = true;
				}
			}
			if (!flag)
			{
				if (this.aggressive || this.staminaFilling || this.movingTogether)
				{
					if (this.inSwarmWait && seconds > this.timeSinceSwarmWait)
					{
						if (!this.movingTogether)
						{
							if (this.debugConsole)
							{
								Debug.Log(this.groupID.ToString() + " Swarm wait over, breaking");
							}
							this.BreakCircle(false, true);
							return;
						}
						if (this.formationCoroutine == null && this.centerCharacter)
						{
							if (this.formationFlankTries >= 100 || Random.Range(0, 3) == 0)
							{
								this.BreakCircle(false, false);
								return;
							}
							this.FindFormationPoint("Flank");
						}
					}
					if (this.inSwarm && seconds > this.timeSinceSwarm + 1f)
					{
						int num12;
						bool flag4 = this.CanEndFormation("Swarm", out num12);
						if (!flag4 && this.formationCoroutine == null && seconds > this.timeSinceSwarm + 80f)
						{
							int num13 = 0;
							int count2 = this.allCharacters.Count;
							int num14 = 0;
							for (int m = 0; m < count2; m++)
							{
								Character character4 = this.allCharacters[m];
								float sqrMagnitude = this.SubtractVectors(character4.currentPosition, this.moveTo).sqrMagnitude;
								if (sqrMagnitude < 16f)
								{
									num13++;
									num14++;
								}
								if (character4.IsSentient() && !character4.isHit && character4.moving && sqrMagnitude < 225f && sqrMagnitude > 16f)
								{
									num14++;
								}
							}
							if (num14 <= 1 || seconds > this.timeSinceSwarm + 150f)
							{
								if (this.debugConsole)
								{
									Debug.Log(this.groupID.ToString() + " Moving group because too much time has passed");
								}
								flag4 = true;
							}
						}
						if (flag4)
						{
							if (this.debugConsole)
							{
								Debug.Log(string.Concat(new string[]
								{
									this.groupID.ToString(),
									" End swarm ",
									this.aggressive.ToString(),
									" ",
									seconds.ToString(),
									" ",
									this.timeSinceSwarm.ToString()
								}));
							}
							this.inSwarm = false;
							this.inSwarmWait = true;
							this.center = this.centroid;
							if (this.movingTogether)
							{
								this.timeSinceSwarmWait = seconds + (float)Random.Range(20, 40);
								return;
							}
							this.timeSinceSwarmWait = seconds + 50f;
							return;
						}
					}
					if (this.inFormationWait)
					{
						if (!this.canShowLine && !this.movingTogether)
						{
							bool flag5 = false;
							for (int n = 0; n < this.allCharacters.Count; n++)
							{
								Character character5 = this.allCharacters[n];
								if (character5 && this.SubtractVectors(this.moveTo, character5.tr.position).sqrMagnitude < 25f)
								{
									flag5 = true;
									break;
								}
							}
							if (flag5)
							{
								this.canShowLine = true;
							}
						}
						float num15 = 60f;
						if (this.staminaFilling)
						{
							num15 = 200f;
						}
						if (this.movingTogether)
						{
							num15 = 30f;
						}
						if (seconds > this.timeSinceFormationWait + num15)
						{
							if (((this.inCircleCharacters.Count >= this.canBeInCircle - 1 && this.canBeInCircle > 2) || this.inCircleCharacters.Count == this.canBeInCircle || seconds > this.timeSinceFormationWait + num15 + 50f) && this.formationCoroutine == null && this.centerCharacter)
							{
								this.center = this.centroid;
								if (this.debugConsole)
								{
									Debug.Log(string.Concat(new string[]
									{
										this.groupID.ToString(),
										" end formation wait  ",
										this.inCircleCharacters.Count.ToString(),
										" ",
										this.canBeInCircle.ToString()
									}));
								}
								if (this.staminaFilling)
								{
									this.BreakCircle(false, false);
									return;
								}
								int num16 = 0;
								int num17 = 0;
								if (this.centerCharacter.stats.xmlName.Contains("Bakka") && !this.movingTogether)
								{
									for (int num18 = 0; num18 < this.allCharacters.Count; num18++)
									{
										Character character6 = this.allCharacters[num18];
										if (character6 && character6.actions && character6.hasCreatureBuff)
										{
											if (character6.actions.ai.findingAction)
											{
												character6.actions.CheckIfRunningAI();
											}
											character6.ClearNodePath();
											if (character6.IsSentient())
											{
												num17++;
												if (this.Attack(character6, true))
												{
													num16++;
												}
												else
												{
													this.Attack(character6, false);
												}
												Effects effects = character6.gameObject.AddComponent<Effects>();
												Links.x.cellar.AddEffects(effects);
												effects.gameObject.SetActive(true);
												effects.source = character6;
												effects.target = character6;
												effects.sourceLevel = (float)character6.stats.characterRow._Level;
												effects.effectName = "CircleOffense";
												effects.Inflicted(false);
												this.EndChargeUp(character6);
											}
										}
									}
									for (int num19 = 0; num19 < this.allCharacters.Count; num19++)
									{
										Character character7 = this.allCharacters[num19];
									}
									this.BreakCircle(false, true);
									return;
								}
								if (this.formationSwarmTries >= 100)
								{
									this.BreakCircle(false, false);
									return;
								}
								if (this.movingTogether)
								{
									if (Random.Range(0, 2) == 0)
									{
										this.FindFormationPoint("Flank");
									}
									else
									{
										this.FindFormationPoint("Swarm");
									}
								}
								else
								{
									this.FindFormationPoint("Swarm");
								}
							}
						}
						else if (this.staminaFilling)
						{
							bool flag6 = true;
							bool flag7 = false;
							bool flag8 = false;
							if (Links.x.gameplay.seconds > this.staminaFillTime + 5f)
							{
								flag8 = true;
								this.staminaFillTime = Links.x.gameplay.seconds;
							}
							if (this.inCircleCharacters.Count < this.allCharacters.Count - 1)
							{
								flag7 = true;
							}
							for (int num20 = 0; num20 < this.allCharacters.Count; num20++)
							{
								if ((this.allCharacters[num20].hasCreatureBuff || flag7) && this.allCharacters[num20].stats.StaminaPercent() < 0.93f)
								{
									flag6 = false;
								}
								if (flag8 && this.allCharacters[num20].hasCreatureBuff)
								{
									this.allCharacters[num20].stats.AddStamina(1f);
								}
							}
							if (flag6)
							{
								this.BreakCircle(false, false);
							}
						}
					}
					if (this.inFormationMovement)
					{
						int num21;
						bool flag9 = this.CanEndFormation("Flank", out num21);
						if (!flag9)
						{
							float num22 = 250f;
							if (this.aggressive)
							{
								num22 = 150f;
							}
							if (seconds > this.timeSinceFormation + num22 && this.formationCoroutine == null)
							{
								int num23 = 0;
								int count3 = this.allCharacters.Count;
								int num24 = 0;
								for (int num25 = 0; num25 < count3; num25++)
								{
									Character character8 = this.allCharacters[num25];
									float sqrMagnitude2 = this.SubtractVectors(character8.currentPosition, this.moveTo).sqrMagnitude;
									if (sqrMagnitude2 < 49f)
									{
										num23++;
										num24++;
									}
									else if (character8.IsSentient() && !character8.isHit && !character8.inAction && sqrMagnitude2 < 225f)
									{
										num24++;
									}
								}
								if ((num23 >= num24 - 1 && this.useCenterLinking) || (!this.useCenterLinking && this.inCircleCount > num && num > 2) || (!this.useCenterLinking && this.inCircleCount == this.canBeInCircle) || seconds > this.timeSinceFormation + (num22 + 50f))
								{
									if (this.debugConsole)
									{
										Debug.Log(this.groupID.ToString() + " Moving group because too much time has passed");
									}
									flag9 = true;
								}
							}
						}
						if (flag9)
						{
							this.inFormationMovement = false;
							this.inFormationWait = true;
							this.RemoveAllMovementFlags();
							this.timeSinceFormationWait = seconds;
							if (this.debugConsole)
							{
								Debug.Log(this.groupID.ToString() + " start formation wait, can show line = " + this.canShowLine.ToString());
							}
						}
					}
				}
				if (!this.movingTogether && this.canShowLine)
				{
					if (this.dangerLevel == 0)
					{
						this.morale = 100;
					}
					if (this.dangerLevel == 1)
					{
						this.morale = 50;
					}
					if (this.dangerLevel >= 2)
					{
						this.morale = 10;
					}
				}
				else
				{
					this.morale = 100;
				}
				if (seconds > this.checkDirectionTime + 15f)
				{
					this.CheckDirection(true);
					this.checkDirectionTime = seconds;
				}
				this.linkedTiles.Clear();
				this.inCircleCharacters.Clear();
				this.CheckCircle(false);
				if (this.inCircleCharacters.Count >= 1)
				{
					this.circleIsActive = true;
				}
				else
				{
					this.circleIsActive = false;
				}
				this.centroid = Vector3.zero;
				int num26 = 0;
				for (int num27 = 0; num27 < this.inCircleCharacters.Count; num27++)
				{
					this.centroid += this.inCircleCharacters[num27].currentPosition;
					num26++;
				}
				if (!this.circleIsActive)
				{
					num26 = 0;
					for (int num28 = 0; num28 < this.circleTiles.Count; num28++)
					{
						this.centroid += (Vector3)this.circleTiles[num28].position;
						num26++;
					}
				}
				if (this.centroid != Vector3.zero && num26 > 0 && (this.staminaFilling || this.aggressive || this.movingTogether))
				{
					if (this.inFormationMovement || this.inSwarm)
					{
						this.centroid /= (float)num26;
					}
					else
					{
						this.centroid /= (float)num26;
					}
				}
				else if (this.inFormationMovement || this.inSwarm)
				{
					this.centroid = this.centerCharacter.currentPosition;
				}
				else
				{
					this.centroid = this.center;
				}
				if (this.circleIsActive)
				{
					this.CheckCircle(true);
					for (int num29 = 0; num29 < this.inCircleCharacters.Count; num29++)
					{
						Character character9 = this.inCircleCharacters[num29];
						if (character9 != null)
						{
							this.linkedTiles.Add(character9.currentPosition);
						}
					}
					if (this.canShowLine && this.staminaFilling && this.inCircleCharacters.Count > 0)
					{
						float num30 = 20f;
						if (!this.staminaFilling)
						{
							num30 = 200f;
						}
						if (seconds > this.updateTime + num30 && !this.pulsing)
						{
							this.updateTime = seconds;
							this.StartPulse(true);
						}
					}
					this.SetCircleTiles(false);
				}
				if (this.canShowLine && this.staminaFilling && !this.staminaRecover.activeSelf && Time.timeSinceLevelLoad > this.staminaRecoverTime + 1f)
				{
					this.PlaceStamina();
					this.staminaRecoverTime = Time.timeSinceLevelLoad;
				}
				if (!this.aggressive && !this.staminaFilling && !this.movingTogether)
				{
					this.canShowLine = true;
				}
				if (!this.canShowLine || ((this.staminaFilling || this.aggressive) && !this.inFormationWait && !this.inFormationMovement))
				{
					if (this.canShowLine && this.useCenterLinking)
					{
						Links.x.cameraEffects.ClearEnemyGroupTiles(this);
					}
					this.ReturnLines(this.linenum);
					return;
				}
				bool flag10 = false;
				if (this.aggressive || this.staminaFilling)
				{
					bool flag11 = true;
					if (this.linkedTiles.Count > 1)
					{
						for (int num31 = 1; num31 < this.linkedTiles.Count; num31++)
						{
							if (flag11)
							{
								Vector3 vector = this.linkedTiles[num31];
								bool flag12 = false;
								for (int num32 = 0; num32 < this.linkedTiles.Count; num32++)
								{
									if (num32 != num31 && !flag12 && (this.linkedTiles[num32] - vector).sqrMagnitude < 13.690001f)
									{
										flag12 = true;
									}
								}
								if (!flag12)
								{
									flag11 = false;
								}
							}
						}
					}
					flag10 = false;
				}
				if (this.needsFade)
				{
					this.StartCircleFade(false);
					this.needsFade = false;
					if (!this.useCenterLinking && !flag10 && !this.movingTogether)
					{
						for (int num33 = 0; num33 < this.circleTiles.Count; num33++)
						{
							Links.x.cameraEffects.GroupCharacters((Vector3)this.circleTiles[num33].position, this, true);
						}
					}
					if (this.centerCharacter.stats.isFishMonster)
					{
						this.AddEffect("Acid");
					}
				}
				if (flag10 && !this.movingTogether)
				{
					Links.x.cameraEffects.ClearEnemyGroupTiles(this);
					for (int num34 = 0; num34 < this.linkedTiles.Count; num34++)
					{
						Links.x.cameraEffects.GroupCharacters(this.linkedTiles[num34], this, true);
					}
				}
				if (this.useCenterLinking && !this.movingTogether)
				{
					Links.x.cameraEffects.ClearEnemyGroupTiles(this);
					for (int num35 = 0; num35 < this.linkedTiles.Count; num35++)
					{
						Links.x.cameraEffects.GroupCharacters(this.linkedTiles[num35], this, true);
					}
					return;
				}
			}
			else
			{
				this.BreakCircle(flag2, false);
			}
		}
	}

	// Token: 0x060006B1 RID: 1713 RVA: 0x00091518 File Offset: 0x0008F718
	public void CheckDirection(bool sendMoveEvent)
	{
		if (!this.centerCharacter)
		{
			return;
		}
		Quaternion quaternion = this.targetRotation;
		Vector3 vector = this.centerCharacter.currentPosition;
		if (this.centerCharacter.actions)
		{
			Character character = this.centerCharacter.actions.ai.NearestEnemy();
			if (character)
			{
				vector = character.currentPosition;
			}
		}
		if (vector == this.centerCharacter.currentPosition)
		{
			vector = Links.x.gameplay.NearestEnemyClump(false, this.centerCharacter);
		}
		if (vector == Vector3.zero)
		{
			vector = this.centerCharacter.currentPosition;
		}
		Vector3 vector2 = this.centroid;
		if (!this.useCenterLinking)
		{
			vector2 = (Vector3)this.centerNode.position;
		}
		this.targetRotation = Quaternion.LookRotation(vector - vector2);
		Vector3 vector3 = vector2 + this.targetRotation * Vector3.forward * 10f;
		this.middleCircle = vector2;
		vector2 + this.targetRotation * Vector3.forward * -10f;
		float num = float.PositiveInfinity;
		for (int i = 0; i < this.circleTiles.Count; i++)
		{
			if (this.circleTiles[i] != null)
			{
				float sqrMagnitude = ((Vector3)this.circleTiles[i].position - vector3).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					this.frontOfCircle = (Vector3)this.circleTiles[i].position;
				}
			}
		}
		if (this.GetRotationAngle(quaternion, this.targetRotation) > 60f && sendMoveEvent)
		{
			for (int j = 0; j < this.allCharacters.Count; j++)
			{
				Character character2 = this.allCharacters[j];
				if (character2 && character2.hasCreatureBuff && !character2.moving && !character2.inAction && !character2.inRecovery && character2.IsSentient() && character2.hasCreatureBuff && !character2.turning && this.GetRotationAngle(this.targetRotation, character2.rot) > 40f)
				{
					character2.SetRotation(this.targetRotation, true, false);
				}
			}
		}
	}

	// Token: 0x060006B2 RID: 1714 RVA: 0x00091778 File Offset: 0x0008F978
	private void GetChargeUp(Character c)
	{
		if (!c.actions)
		{
			return;
		}
		if (!c.actions.chargeUpFX)
		{
			c.actions.chargeUpNum = 130;
			c.actions.chargeUpFX = Links.x.cellar.GetPooledGameObject(c.actions.chargeUpNum);
			c.actions.chargeUpFX.transform.SetParent(c.body.GetNeck(), true);
			c.actions.chargeUpFX.transform.localPosition = Vector3.zero;
			c.actions.chargeUpFX.SetActive(true);
		}
		if (c.stats.animal && c.stats.hasCircleAnims)
		{
			c.animator.SetBool("Hyped", true);
			if (c.animID == 0)
			{
				c.PlayAnimation("Hyped", 0f);
			}
		}
	}

	// Token: 0x060006B3 RID: 1715 RVA: 0x0009186C File Offset: 0x0008FA6C
	private void EndChargeUp(Character c)
	{
		if (c.actions)
		{
			c.actions.ReturnChargeUpFX();
		}
		c.animator.SetBool("Hyped", false);
	}

	// Token: 0x060006B4 RID: 1716 RVA: 0x00091898 File Offset: 0x0008FA98
	public void CheckCircle(bool canAddBuff)
	{
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			Character character = this.allCharacters[i];
			if (character && character.inCircle)
			{
				bool hasCreatureBuff = character.hasCreatureBuff;
				if (this.LinkedToCenter(character) && character.IsSentient())
				{
					if (!hasCreatureBuff && canAddBuff && this.canShowLine)
					{
						character.hasCreatureBuff = true;
						if (!this.aggressive && !this.staminaFilling && !this.movingTogether)
						{
							Effects effects = character.gameObject.AddComponent<Effects>();
							Links.x.cellar.AddEffects(effects);
							effects.gameObject.SetActive(true);
							effects.source = character;
							effects.target = character;
							effects.sourceLevel = (float)character.stats.characterRow._Level;
							effects.effectName = "CircleDefense";
							effects.Inflicted(false);
						}
						if (this.aggressive && character.actions)
						{
							character.actions.ai.circleMovement = false;
						}
					}
					if (!canAddBuff)
					{
						this.inCircleCharacters.Add(character);
					}
					if (canAddBuff && this.canShowLine && this.aggressive && (this.inFormationWait || this.inFormationMovement))
					{
						if (true)
						{
							this.GetChargeUp(character);
						}
						else
						{
							this.EndChargeUp(character);
						}
					}
				}
				else if (hasCreatureBuff)
				{
					bool flag = true;
					int num = this.originalCharacters.IndexOf(character);
					if (num > -1 && Links.x.gameplay.seconds < this.timeOutsideCircle[num] + 10f)
					{
						flag = false;
					}
					if (flag)
					{
						character.hasCreatureBuff = false;
						if (!this.aggressive && !this.staminaFilling && !this.movingTogether)
						{
							character.stats.HealEffect("CircleDefense");
						}
						if (character.actions && this.aggressive)
						{
							this.EndChargeUp(character);
						}
						if (character.resting)
						{
							character.resting = false;
							character.GetUp();
						}
					}
				}
			}
		}
	}

	// Token: 0x060006B5 RID: 1717 RVA: 0x00091AC0 File Offset: 0x0008FCC0
	public int FreeSpots()
	{
		int count = this.originalCharacters.Count;
		int count2 = this.allCharacters.Count;
		if (count2 < count)
		{
			return count - count2;
		}
		return 0;
	}

	// Token: 0x060006B6 RID: 1718 RVA: 0x00091AF0 File Offset: 0x0008FCF0
	public void Rest(Character v)
	{
		if (!v.resting && v.stats.hasCircleAnims)
		{
			v.resting = true;
			if (!v.moving && !v.stats.pinned && !v.stats.pinning && v.NodesCount() == 0 && v.waitingForPath == 0 && !v.isHit && v.IsSentient())
			{
				v.PlayAnimation("Idle", 0f);
			}
		}
	}

	// Token: 0x060006B7 RID: 1719 RVA: 0x00091B6B File Offset: 0x0008FD6B
	public bool LinkedToCenter(Character c)
	{
		return this.LinkedToCenter(c.currentPosition, c);
	}

	// Token: 0x060006B8 RID: 1720 RVA: 0x00091B7C File Offset: 0x0008FD7C
	public bool LinkedToCenter(Vector3 pt, Character c)
	{
		if (this.useCenterLinking)
		{
			float num = 14.0625f;
			if (this.inFormationMovement)
			{
				num = 20.25f;
			}
			if (this.SubtractVectors(this.centroid, pt).sqrMagnitude <= num)
			{
				return true;
			}
			if (this.centerCharacter && (this.inFormationMovement || this.inSwarm) && this.SubtractVectors(this.centerCharacter.tr.position, pt).sqrMagnitude <= 100f)
			{
				return true;
			}
			int count = this.allCharacters.Count;
			for (int i = 0; i < count; i++)
			{
				Character character = this.allCharacters[i];
				if (character && character != c && character.IsSentient() && !character.body.IsHit())
				{
					Vector3 currentPosition = character.currentPosition;
					if (this.SubtractVectors(currentPosition, pt).sqrMagnitude <= num && this.SubtractVectors(currentPosition, this.centroid).sqrMagnitude <= num)
					{
						return true;
					}
				}
			}
		}
		else if (this.InCircle(pt, true, false, null))
		{
			return true;
		}
		return false;
	}

	// Token: 0x060006B9 RID: 1721 RVA: 0x00091CA8 File Offset: 0x0008FEA8
	public bool LinkedToNewPoint(Vector3 pt, Character c)
	{
		if (this.useCenterLinking)
		{
			float num = 14.0625f;
			Vector3 currentPosition = c.currentPosition;
			if (this.SubtractVectors(pt, currentPosition).sqrMagnitude <= num)
			{
				return true;
			}
			int count = this.allCharacters.Count;
			for (int i = 0; i < count; i++)
			{
				Character character = this.allCharacters[i];
				if (character && character != c)
				{
					Vector3 currentPosition2 = character.currentPosition;
					if (this.SubtractVectors(currentPosition2, currentPosition).sqrMagnitude <= num && this.SubtractVectors(currentPosition2, pt).sqrMagnitude <= num)
					{
						return true;
					}
				}
			}
		}
		else if (this.InCircle(pt, true, false, null))
		{
			return true;
		}
		return false;
	}

	// Token: 0x060006BA RID: 1722 RVA: 0x00091D64 File Offset: 0x0008FF64
	public bool InCircle(GraphNode n, bool mustBeInside, bool testLinked, Character c)
	{
		return this.InCircle((Vector3)n.position, mustBeInside, testLinked, c);
	}

	// Token: 0x060006BB RID: 1723 RVA: 0x00091D7C File Offset: 0x0008FF7C
	public bool InCircle(Vector3 test, bool mustBeInside, bool testLinked, Character c)
	{
		bool flag = false;
		Vector3 vector = Vector3.zero;
		float num = 5f;
		if (mustBeInside)
		{
			num = 1.5f;
		}
		for (int i = 0; i < this.circleTiles.Count; i++)
		{
			vector = (Vector3)this.circleTiles[i].position;
			float num2 = vector.x - test.x;
			if (num2 < 0f)
			{
				num2 *= -1f;
			}
			if (num2 < num)
			{
				float num3 = vector.z - test.z;
				if (num3 < 0f)
				{
					num3 *= -1f;
				}
				if (num3 < num)
				{
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	// Token: 0x060006BC RID: 1724 RVA: 0x00091E24 File Offset: 0x00090024
	public void AddToCircle(Character c)
	{
		if (!this.isBreaking)
		{
			if (this.debugConsole)
			{
				Debug.Log("Adding to group! " + ((c != null) ? c.ToString() : null));
			}
			this.originalCharacters.Add(c);
			this.allCharacters.Add(c);
			this.allCharactersFormation.Add(0);
			this.timeOutsideCircle.Add(-1f);
			c.inCircle = true;
			c.group = this;
			if (c.actions)
			{
				c.actions.ai.UpdateCircleTiles();
			}
		}
	}

	// Token: 0x060006BD RID: 1725 RVA: 0x00091EC0 File Offset: 0x000900C0
	public void LeaveCircle(Character c)
	{
		int num = this.allCharacters.IndexOf(c);
		if (num > -1)
		{
			this.allCharacters.RemoveAt(num);
			this.allCharactersFormation.RemoveAt(num);
		}
		c.hasCreatureBuff = false;
		c.ignoreNodeIDs = false;
		c.inCircle = false;
		c.timeSinceCircle = Links.x.gameplay.seconds;
		c.stats.HealEffect("CircleDefense");
		if (c.resting)
		{
			c.resting = false;
			c.GetUp();
		}
		if (this.aggressive && c.actions)
		{
			c.actions.ReturnChargeUpFX();
		}
		c.animator.SetBool("Hyped", false);
	}

	// Token: 0x060006BE RID: 1726 RVA: 0x00091F76 File Offset: 0x00090176
	public void BreakCircle(bool fromEnemies, bool swarmBreak)
	{
		if (!this.isBreaking)
		{
			this.isBreaking = true;
			base.StartCoroutine(this.Break(fromEnemies, swarmBreak));
		}
	}

	// Token: 0x060006BF RID: 1727 RVA: 0x00091F96 File Offset: 0x00090196
	private IEnumerator Break(bool fromEnemies, bool swarmBreak)
	{
		if (this.debugConsole)
		{
			Debug.Log(this.groupID.ToString() + " BREAK CIRCLE");
		}
		this.SetCircleTiles(true);
		this.RemoveAllMovementFlags();
		this.RemoveEffect();
		for (int i = 0; i < this.circleTiles.Count; i++)
		{
			if (this.circleTiles[i].circle == this.groupID)
			{
				this.circleTiles[i].circle = 0;
			}
		}
		if (this.staminaRecover)
		{
			Links.x.cellar.ReturnPooledGameObject(131, this.staminaRecover);
		}
		for (int j = 0; j < this.allCharacters.Count; j++)
		{
			Character character = this.allCharacters[j];
			if (character)
			{
				character.inCircle = false;
				if (character.resting)
				{
					character.resting = false;
					character.GetUp();
				}
				character.hasCreatureBuff = false;
				character.ignoreNodeIDs = false;
				character.stats.HealEffect("CircleDefense");
				character.timeSinceCircle = Links.x.gameplay.seconds;
				if (this.aggressive && character.actions)
				{
					character.actions.ReturnChargeUpFX();
				}
				character.animator.SetBool("Hyped", false);
			}
		}
		swarmBreak = true;
		if (swarmBreak)
		{
			if (this.needsFadeOut)
			{
				this.StartCircleFade(true);
				while (this.fading)
				{
					yield return null;
				}
				this.needsFadeOut = false;
			}
		}
		else
		{
			this.doFade = true;
			this.fade = 1f;
			float timeToLerp = 1f;
			float percentage = 0f;
			float startTime = Time.time;
			while (percentage < 1f)
			{
				percentage = (Time.time - startTime) / timeToLerp;
				this.fade = percentage;
				yield return null;
			}
		}
		Links.x.cameraEffects.ClearEnemyGroupTiles(this);
		if (this.debug)
		{
			for (int k = 0; k < this.spheres.Count; k++)
			{
				Object.Destroy(this.spheres[k]);
			}
			this.spheres.Clear();
		}
		if (this.sphere)
		{
			Object.Destroy(this.sphere);
		}
		if (Records.x.combat)
		{
			Links.x.combat.RemoveGroup(this);
		}
		this.ReturnLines(this.linenum);
		Object.Destroy(this);
		yield break;
	}

	// Token: 0x060006C0 RID: 1728 RVA: 0x00091FAC File Offset: 0x000901AC
	private Character GetCharacterInCircle()
	{
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			if (this.allCharacters[i].inCircle)
			{
				return this.allCharacters[i];
			}
		}
		return null;
	}

	// Token: 0x060006C1 RID: 1729 RVA: 0x00091FF0 File Offset: 0x000901F0
	private Character GetCharacterWithBuff()
	{
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			if (this.allCharacters[i].inCircle && this.allCharacters[i].hasCreatureBuff)
			{
				return this.allCharacters[i];
			}
		}
		return null;
	}

	// Token: 0x060006C2 RID: 1730 RVA: 0x00092048 File Offset: 0x00090248
	public bool InFormationMovement(Character c)
	{
		int num = this.allCharacters.IndexOf(c);
		return this.allCharactersFormation[num] == 1;
	}

	// Token: 0x060006C3 RID: 1731 RVA: 0x00092074 File Offset: 0x00090274
	public GraphNode GetFormationPointInCircle(Character c, bool rotationChanged)
	{
		GraphNode graphNode = c.node;
		if (!rotationChanged && this.InCircle(c.tr.position, true, true, c) && c.hasCreatureBuff)
		{
			return graphNode;
		}
		if (graphNode == null)
		{
			return null;
		}
		this.nodeConstraintFormation.constrainToArea = (int)graphNode.Area;
		this.nodeConstraintFormation.walkable = true;
		this.nodeConstraintFormation.constrainWalkability = true;
		this.nodeConstraintFormation.constrainTags = false;
		this.nodeConstraintFormation.checkCircleID = this.groupID;
		this.nodeConstraintFormation.passID = 0;
		this.nodeConstraintFormation.constrainPenalty = 0;
		this.nodeConstraintFormation.checkConnections = c.ConnectionNumber();
		this.nodeConstraintFormation.constrainToEnvironment = 1;
		if (c.movesOnWater)
		{
			this.nodeConstraintFormation.constrainToEnvironment = 2;
		}
		this.openTiles.Clear();
		for (int i = 0; i < this.circleTiles.Count; i++)
		{
			GraphNode graphNode2 = this.circleTiles[i];
			if (this.nodeConstraintFormation.Suitable(graphNode2) && (graphNode2.ID == 0 || graphNode2.ID == c.nodeStationaryID || graphNode2.ID == c.nodeMovingID))
			{
				this.openTiles.Add(graphNode2);
			}
		}
		Vector3 vector = this.frontOfCircle;
		float num = float.PositiveInfinity;
		if (!c.protectMe && c.stats.formationGroup >= 4 && c.stats.formationGroup <= 6)
		{
			vector = this.middleCircle;
		}
		if (c.protectMe || (c.stats.formationGroup >= 7 && c.stats.formationGroup <= 9))
		{
			vector = this.backOfCircle;
		}
		for (int j = 0; j < this.openTiles.Count; j++)
		{
			float sqrMagnitude = ((Vector3)this.openTiles[j].position - vector).sqrMagnitude;
			if (sqrMagnitude < num)
			{
				num = sqrMagnitude;
				graphNode = this.openTiles[j];
			}
		}
		return graphNode;
	}

	// Token: 0x060006C4 RID: 1732 RVA: 0x00092270 File Offset: 0x00090470
	public bool CheckCirclePositionAndMove(Character c)
	{
		if (this.inSwarm || this.inSwarmWait)
		{
			return false;
		}
		GraphNode graphNode = c.node;
		if (c.hasCreatureBuff)
		{
			return false;
		}
		graphNode = this.GetFormationPointInCircle(c, false);
		if (graphNode != null && graphNode != c.node)
		{
			c.ClearPathUpdates();
			this.JoinCirclePath(graphNode, c);
			return true;
		}
		return false;
	}

	// Token: 0x060006C5 RID: 1733 RVA: 0x000922C8 File Offset: 0x000904C8
	private void ReturnLines(int l)
	{
		for (int i = 0; i < this.lines.Count; i++)
		{
			Links.x.cellar.ReturnPooledGameObject(l, this.lines[i]);
		}
		this.lines.Clear();
	}

	// Token: 0x060006C6 RID: 1734 RVA: 0x00092314 File Offset: 0x00090514
	private void DrawCircle()
	{
		float num = 9f;
		int num2 = 60;
		int num3 = this.linenum;
		this.linenum = 127;
		if (this.morale > 33 && this.morale < 66)
		{
			this.linenum = 126;
		}
		if (this.morale <= 33)
		{
			this.linenum = 125;
		}
		if (this.linenum != num3)
		{
			this.ReturnLines(num3);
		}
		Vector3 vector = Vector3.zero;
		Vector3 vector2 = Vector3.up * -1f;
		Vector3 forward = Vector3.forward;
		Vector3 zero = Vector3.zero;
		float num4 = 0.25f;
		197120;
		Quaternion quaternion = Quaternion.identity;
		Vector3 vector3 = this.centroid;
		if (!this.useCenterLinking)
		{
			vector3 = (Vector3)this.centerNode.position;
		}
		Vector3 vector4 = vector3;
		Vector3 one = Vector3.one;
		int num5 = 0;
		this.positions.Clear();
		float num6 = 1.25f;
		for (int i = 0; i < this.circleTiles.Count; i++)
		{
			vector = (Vector3)this.circleTiles[i].position;
			this.positions.Add(vector + new Vector3(num6, 0f, num6));
			this.positions.Add(vector + new Vector3(num6 * -1f, 0f, num6));
			this.positions.Add(vector + new Vector3(num6, 0f, num6 * -1f));
			this.positions.Add(vector + new Vector3(num6 * -1f, 0f, num6 * -1f));
		}
		float num7 = 6.2831855f / (float)num2;
		for (int j = 0; j < num2 + 1; j++)
		{
			int num8 = j;
			if (j == num2)
			{
				num8 = 0;
			}
			float num9 = (float)num8 * num7;
			float num10 = num * Mathf.Cos(num9);
			float num11 = num * Mathf.Sin(num9);
			vector = vector3;
			vector.x += num10;
			vector.z += num11;
			float num12 = 200f;
			int num13 = -1;
			for (int k = 0; k < this.positions.Count; k++)
			{
				this.positions[k].y = vector.y;
				float sqrMagnitude = (this.positions[k] - vector).sqrMagnitude;
				if (sqrMagnitude < num12)
				{
					num12 = sqrMagnitude;
					num13 = k;
				}
			}
			if (num13 > -1)
			{
				vector = this.positions[num13];
			}
			else
			{
				vector = Vector3.zero;
			}
			if (vector.x != 0f && vector.z != 0f)
			{
				float y = vector.y;
				vector.y += 3f;
				RaycastHit raycastHit;
				if (Physics.Raycast(vector, vector2, out raycastHit, 8f, Links.x.floor))
				{
					vector.y = raycastHit.point.y + num4;
				}
				else
				{
					vector.y = y + num4;
				}
				if (vector4 != vector)
				{
					quaternion = Quaternion.LookRotation(vector4 - vector);
					if (j > 0)
					{
						GameObject gameObject;
						if (num5 < this.lines.Count)
						{
							gameObject = this.lines[num5];
						}
						else
						{
							gameObject = Links.x.cellar.GetPooledGameObject(this.linenum);
							this.lines.Add(gameObject);
							gameObject.SetActive(true);
						}
						gameObject.transform.position = vector;
						gameObject.transform.rotation = quaternion;
						num5++;
						one.z = Vector3.Distance(vector4, vector);
						gameObject.transform.localScale = one;
					}
					vector4 = vector;
				}
			}
		}
		if (num5 < this.lines.Count)
		{
			for (int l = num5; l < this.lines.Count; l++)
			{
				Links.x.cellar.ReturnPooledGameObject(this.linenum, this.lines[l]);
				this.lines[l] = null;
			}
			this.lines.RemoveAll((GameObject item) => item == null);
		}
	}

	// Token: 0x060006C7 RID: 1735 RVA: 0x00092798 File Offset: 0x00090998
	private void PlaceStamina()
	{
		float num = 8f;
		int num2 = 20;
		Vector3 vector = Vector3.zero;
		Vector3 vector2 = Vector3.up * -1f;
		Vector3 forward = Vector3.forward;
		Vector3 zero = Vector3.zero;
		float num3 = 0.25f;
		197120;
		Quaternion identity = Quaternion.identity;
		Vector3 vector3 = this.centroid;
		if (!this.useCenterLinking)
		{
			vector3 = (Vector3)this.centerNode.position;
		}
		Vector3 vector4 = vector3;
		Vector3 one = Vector3.one;
		this.positions.Clear();
		this.fxPositions.Clear();
		for (int i = 0; i < this.linkedTiles.Count; i++)
		{
			int num4 = 15;
			float num5 = 6.2831855f / (float)num4;
			float num6 = 1.8f;
			for (int j = 0; j < num4; j++)
			{
				float num7 = (float)j * num5;
				float num8 = num6 * Mathf.Cos(num7);
				float num9 = num6 * Mathf.Sin(num7);
				vector = this.linkedTiles[i];
				vector.x += num8;
				vector.z += num9;
				this.positions.Add(vector);
			}
		}
		float num10 = 6.2831855f / (float)num2;
		for (int k = 0; k < num2 + 1; k++)
		{
			int num11 = k;
			if (k == num2)
			{
				num11 = 0;
			}
			float num7 = (float)num11 * num10;
			float num8 = num * Mathf.Cos(num7);
			float num9 = num * Mathf.Sin(num7);
			vector = vector3;
			vector.x += num8;
			vector.z += num9;
			float num12 = 200f;
			int num13 = -1;
			for (int l = 0; l < this.positions.Count; l++)
			{
				this.positions[l].y = vector.y;
				float sqrMagnitude = (this.positions[l] - vector).sqrMagnitude;
				if (sqrMagnitude < num12)
				{
					num12 = sqrMagnitude;
					num13 = l;
				}
			}
			if (num13 > -1)
			{
				vector = this.positions[num13];
			}
			else
			{
				vector = Vector3.zero;
			}
			if (vector.x != 0f && vector.z != 0f)
			{
				float y = vector.y;
				vector.y += 3f;
				RaycastHit raycastHit;
				if (Physics.Raycast(vector, vector2, out raycastHit, 8f, Links.x.floor))
				{
					vector.y = raycastHit.point.y + num3;
				}
				else
				{
					vector.y = y + num3;
				}
				if (vector4 != vector)
				{
					Quaternion.LookRotation(vector4 - vector);
					if (k > 0)
					{
						this.fxPositions.Add(vector);
					}
					vector4 = vector;
				}
			}
		}
		if (this.fxPositions.Count > 0)
		{
			int num14 = Random.Range(0, this.fxPositions.Count);
			this.staminaRecover.transform.position = this.fxPositions[num14] + new Vector3(0f, 0.25f, 0f);
			this.staminaRecover.SetActive(true);
		}
	}

	// Token: 0x060006C8 RID: 1736 RVA: 0x00092AE8 File Offset: 0x00090CE8
	public void CheckIfMovingInFormation(Character character, string type)
	{
		if (character.moving)
		{
			return;
		}
		if (Records.x.pocketPause)
		{
			return;
		}
		if (character.NodesCount() > 0)
		{
			return;
		}
		if (character.waitingForPath == 1 || character.waitingForPath == -1)
		{
			return;
		}
		if (character.blockedTime > 0f)
		{
			return;
		}
		if (character.isHit)
		{
			return;
		}
		if (character.inAction)
		{
			return;
		}
		if (!this.checkingFormation)
		{
			this.FormationPoints(false, character, this.savedEndPoint, type);
		}
	}

	// Token: 0x060006C9 RID: 1737 RVA: 0x00092B60 File Offset: 0x00090D60
	public bool CanEndFormation(string type, out int nearCount)
	{
		nearCount = 0;
		bool flag = true;
		bool flag2 = false;
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			Character character = this.allCharacters[i];
			if (character && this.SubtractVectors(this.moveTo, character.tr.position).sqrMagnitude < 25f)
			{
				if (!this.movingTogether)
				{
					this.canShowLine = true;
				}
				flag2 = true;
				break;
			}
		}
		for (int j = 0; j < this.allCharacters.Count; j++)
		{
			Character character2 = this.allCharacters[j];
			if (character2 && this.allCharactersFormation[j] == 1)
			{
				if (character2.IsSentient())
				{
					bool flag3 = false;
					if (flag2)
					{
						if (type == "Swarm" && character2.hasActions && this.savedTarget)
						{
							float num = 0f;
							float num2 = 0f;
							float num3;
							character2.actions.ai.GetDistances(character2, this.savedTarget, out num3, out num, out num2, false, false);
							float sqrMagnitude = this.SubtractVectors(this.savedTarget.currentPosition, character2.currentPosition).sqrMagnitude;
							if (sqrMagnitude <= num && sqrMagnitude >= num2 && !character2.actions.ai.CheckSight(character2.raycastPosition, this.savedTarget.currentPosition, false))
							{
								flag3 = true;
							}
						}
						if (!flag3)
						{
							if (this.useCenterLinking)
							{
								if (this.LinkedToNewPoint(this.moveTo, character2))
								{
									flag3 = true;
								}
							}
							else if (this.InCircle(character2.currentPosition, true, true, character2))
							{
								flag3 = true;
							}
						}
					}
					if (!flag3)
					{
						flag = false;
						if (character2.moving)
						{
							character2.ignoreNodeIDs = true;
						}
						this.CheckIfMovingInFormation(character2, type);
					}
					else
					{
						nearCount++;
						character2.ignoreNodeIDs = false;
						this.allCharactersFormation[j] = 0;
						if (character2.actions)
						{
							character2.actions.ai.circleMovement = false;
							if (this.inSwarm)
							{
								if (character2.IsSentient())
								{
									character2.actions.ai.UpdateCircleTiles();
									character2.actions.CheckIfRunningAI();
									character2.ClearNodePath();
									this.Attack(character2, false);
								}
							}
							else if (this.staminaFilling)
							{
								this.Rest(character2);
							}
						}
					}
				}
			}
			else
			{
				nearCount++;
			}
		}
		if (type == "Swarm")
		{
			if (!flag2)
			{
				flag = false;
			}
			return flag;
		}
		return flag;
	}

	// Token: 0x060006CA RID: 1738 RVA: 0x00092DF8 File Offset: 0x00090FF8
	private bool Attack(Character c, bool special)
	{
		c.attackTime = 1f;
		c.ignoreNodeIDs = true;
		c.actions.ai.circleMovement = false;
		if (this.savedTarget)
		{
			c.SetRotation(Quaternion.LookRotation(this.savedTarget.currentPosition - c.currentPosition), true, false);
			c.actions.SetSelectedTarget(true, this.savedTarget, null, null);
		}
		if (!special)
		{
			if (!c.actions.ai.busy)
			{
				c.actions.ChooseAction();
			}
			return true;
		}
		if (!c.body.IsHit() && c.IsSentient() && !c.stats.pinned && !c.stats.pinning)
		{
			c.actions.SetSelectedTarget(false, null, null, null);
			return c.actions.ai.SpecialAttack(true);
		}
		return false;
	}

	// Token: 0x060006CB RID: 1739 RVA: 0x00092EE0 File Offset: 0x000910E0
	private void RemoveAllMovementFlags()
	{
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			Character character = this.allCharacters[i];
			if (character)
			{
				character.ignoreNodeIDs = false;
				if (character.actions)
				{
					character.actions.ai.circleMovement = false;
				}
			}
		}
	}

	// Token: 0x060006CC RID: 1740 RVA: 0x00092F40 File Offset: 0x00091140
	public Character GetMiddleFormationCharacter()
	{
		this.nearCharacters.Clear();
		for (int i = 0; i < this.allCharacters.Count; i++)
		{
			Character character = this.allCharacters[i];
			if (character && character.IsSentient())
			{
				if (this.LinkedToNewPoint(this.moveTo, character))
				{
					return character;
				}
				this.nearCharacters.Add(character);
			}
		}
		float num = 1000000f;
		Character character2 = null;
		for (int j = 0; j < this.nearCharacters.Count; j++)
		{
			Character character3 = this.nearCharacters[j];
			float sqrMagnitude = this.SubtractVectors(character3.currentPosition, this.moveTo).sqrMagnitude;
			if (sqrMagnitude < num)
			{
				num = sqrMagnitude;
				character2 = character3;
			}
		}
		return character2;
	}

	// Token: 0x060006CD RID: 1741 RVA: 0x00093003 File Offset: 0x00091203
	public void FindFormationPoint(string type)
	{
		if (this.formationCoroutine == null && this.centerCharacter)
		{
			this.formationCoroutine = this.Formation(type);
			base.StartCoroutine(this.formationCoroutine);
		}
	}

	// Token: 0x060006CE RID: 1742 RVA: 0x00093034 File Offset: 0x00091234
	public IEnumerator Formation(string type)
	{
		GraphNode endPoint = null;
		GraphNode graphNode = Links.x.main.node;
		if (graphNode == null)
		{
			graphNode = this.centerCharacter.node;
		}
		ConstantPath constPath = ConstantPath.ConstructFast(graphNode, Records.x.GetConstantPathRadius(9), null);
		this.nodeConstraint.constrainWalkability = false;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainTags = false;
		this.nodeConstraint.checkCircleID = 0;
		this.nodeConstraint.passID = 0;
		this.nodeConstraint.passID2 = 0;
		this.nodeConstraint.checkConnections = 0;
		this.nodeConstraint.constrainToEnvironment = 1;
		if (this.centerCharacter.ghost)
		{
			this.nodeConstraint.constrainToEnvironment = 0;
		}
		if (this.centerCharacter.movesOnWater)
		{
			this.nodeConstraint.constrainToEnvironment = 2;
		}
		this.nodeConstraint.constrainDistance = false;
		this.nodeConstraint.constrainToArea = -1;
		constPath.nnConstraint = this.nodeConstraint;
		AstarPath.StartPath(constPath, false);
		yield return base.StartCoroutine(constPath.WaitForPath());
		constPath.Claim(this);
		this.allNodes = constPath.allNodes;
		this.nearNodes.Clear();
		int x = this.allNodes.Count;
		this.nodeConstraint.constrainTags = true;
		if (this.centerCharacter)
		{
			this.nodeConstraint.passID = this.centerCharacter.nodeStationaryID;
			this.nodeConstraint.passID2 = this.centerCharacter.nodeMovingID;
		}
		this.nodeConstraint.checkCircleID = this.groupID;
		this.nodeConstraint.checkConnections = 8;
		this.nodeConstraint.constrainWalkability = true;
		Vector3 vector = this.centroid;
		if (!this.useCenterLinking)
		{
			vector = Links.x.main.currentPosition;
		}
		Vector3 currentPosition = Links.x.main.currentPosition;
		float num = 2500f;
		float num2 = 225f;
		bool flag = false;
		bool flag2 = false;
		if (type == "Swarm")
		{
			this.formationSwarmTries++;
			num2 = 4f;
			flag = true;
		}
		else
		{
			this.formationFlankTries++;
			flag2 = true;
		}
		int count = this.dioramaCharacters.Count;
		this.nearCharacters.Clear();
		this.nearTargets.Clear();
		for (int j = 0; j < count; j++)
		{
			Character character = this.dioramaCharacters[j];
			if (character && !character.inactive && character.IsSentient())
			{
				if (character.party)
				{
					this.nearCharacters.Add(character);
					this.nearTargets.Add(character);
				}
				else if (character.npc)
				{
					bool flag3 = false;
					if (this.centerCharacter)
					{
						this.centerCharacter.stats.IsTargetAnEnemy(character.stats.allegiance);
					}
					if (character.hostility == 2 || flag3)
					{
						if (!character.inCircle)
						{
							this.nearCharacters.Add(character);
						}
						else if (character.group != this)
						{
							this.nearCharacters.Add(character);
						}
					}
					if (flag3)
					{
						this.nearTargets.Add(character);
					}
				}
			}
		}
		int count2 = this.nearTargets.Count;
		float num3 = float.PositiveInfinity;
		Character character2 = null;
		for (int k = 0; k < count2; k++)
		{
			Character character3 = this.nearTargets[k];
			float sqrMagnitude = this.SubtractVectors(character3.currentPosition, this.centroid).sqrMagnitude;
			if (sqrMagnitude < num3)
			{
				character2 = character3;
				num3 = sqrMagnitude;
			}
		}
		if (character2 && count2 > 0)
		{
			int num4 = this.nearTargets.IndexOf(character2);
			if (num4 > -1)
			{
				this.nearTargets.RemoveAt(num4);
				this.nearTargets.Insert(0, character2);
			}
		}
		float num5 = 400f;
		for (int l = x - 1; l >= 0; l--)
		{
			graphNode = this.allNodes[l];
			float num6 = this.SubtractVectors((Vector3)graphNode.position, this.centroid).sqrMagnitude;
			if (num6 <= num && num6 > num2)
			{
				num6 = this.SubtractVectors((Vector3)graphNode.position, currentPosition).sqrMagnitude;
				if (num6 < num5)
				{
					bool flag4 = false;
					if (flag2)
					{
						if (graphNode.ConnectionCountCircleFree(this.groupID) >= 8)
						{
							flag4 = true;
						}
					}
					else if (graphNode.ConnectionCountCircleFree(this.groupID) >= 8)
					{
						flag4 = true;
					}
					if (flag4 && this.nodeConstraint.Suitable(graphNode))
					{
						bool flag5 = false;
						for (int m = 0; m < this.nearTargets.Count; m++)
						{
							if (!flag5 && !Physics.Linecast(this.nearTargets[m].torsoPosition, (Vector3)graphNode.position + new Vector3(0f, 3f, 0f), 66304))
							{
								flag5 = true;
							}
						}
						if (flag5)
						{
							this.nearNodes.Add(graphNode);
						}
					}
				}
			}
		}
		constPath.Release(this, false);
		x = this.nearNodes.Count;
		int num7 = this.nearCharacters.Count;
		int count3 = this.nearTargets.Count;
		this.nearNodes2.Clear();
		this.nearNodes3.Clear();
		Vector3 vector2 = Vector3.zero;
		float num8 = 36f;
		float num9 = 144f;
		if (this.movingTogether && type == "Flank")
		{
			num8 = 16f;
			num9 = 49f;
		}
		if (flag2)
		{
			for (int n = 0; n < x; n++)
			{
				graphNode = this.nearNodes[n];
				vector2 = (Vector3)graphNode.position;
				bool flag6 = true;
				for (int num10 = 0; num10 < num7; num10++)
				{
					if (flag6)
					{
						float num6 = this.SubtractVectors(vector2, this.nearCharacters[num10].currentPosition).sqrMagnitude;
						if (num6 < num8)
						{
							flag6 = false;
						}
					}
				}
				if (flag6)
				{
					for (int num11 = 0; num11 < count3; num11++)
					{
						if (flag6)
						{
							float num6 = this.SubtractVectors(vector2, this.nearTargets[num11].currentPosition).sqrMagnitude;
							if (num6 < num9)
							{
								flag6 = false;
							}
						}
					}
					if (flag6)
					{
						for (int num12 = 0; num12 < count3; num12++)
						{
							if (flag6)
							{
								Vector3 vector3 = Quaternion.LookRotation(vector2 - new Vector3(this.centroid.x, vector2.y, this.centroid.z)) * Vector3.forward;
								Vector3 vector4 = Vector3.Normalize(this.nearTargets[num12].currentPosition - new Vector3(this.centroid.x, this.nearTargets[num12].currentPosition.y, this.centroid.z));
								if (Vector3.Dot(vector3, vector4) < 0.25f)
								{
									flag6 = false;
								}
							}
						}
						if (flag6)
						{
							this.nearNodes2.Add(graphNode);
						}
					}
				}
			}
		}
		this.bestNodes.Clear();
		if (flag2)
		{
			num8 = 625f;
			if (this.movingTogether)
			{
				num8 = 324f;
			}
			num7 = this.nearTargets.Count;
			x = this.nearNodes2.Count;
			this.nearNodesTargets.Clear();
			for (int num13 = 0; num13 < x; num13++)
			{
				graphNode = this.nearNodes2[num13];
				vector2 = (Vector3)graphNode.position;
				float num14 = num8;
				Character character4 = null;
				for (int num15 = 0; num15 < num7; num15++)
				{
					float num6 = this.SubtractVectors(vector2, this.nearTargets[num15].currentPosition).sqrMagnitude;
					if (num6 < num14)
					{
						num14 = num6;
						character4 = this.nearTargets[num15];
					}
				}
				if (character4)
				{
					this.nearNodes3.Add(graphNode);
					this.nearNodesTargets.Add(character4);
				}
			}
			x = this.nearNodes3.Count;
			this.tested.Clear();
			for (int num16 = 0; num16 < x; num16++)
			{
				this.tested.Add(0);
			}
			for (int num17 = 0; num17 < 10; num17++)
			{
				float num14 = float.PositiveInfinity;
				int num18 = -1;
				for (int num19 = 0; num19 < x; num19++)
				{
					if (this.tested[num19] == 0)
					{
						graphNode = this.nearNodes3[num19];
						vector2 = (Vector3)graphNode.position;
						float num6 = this.SubtractVectors(vector2, this.centroid).sqrMagnitude;
						if (num6 < num14)
						{
							num14 = num6;
							num18 = num19;
						}
					}
				}
				if (num18 > -1)
				{
					this.tested[num18] = 1;
					this.bestNodes.Add(this.nearNodes3[num18]);
					this.nearNodesTargets.Add(this.nearNodesTargets[num18]);
				}
			}
		}
		if (flag)
		{
			num7 = this.nearTargets.Count;
			x = this.nearNodes.Count;
			this.nearNodesTargets.Clear();
			this.tested.Clear();
			for (int num20 = 0; num20 < x; num20++)
			{
				this.tested.Add(0);
			}
			Vector3 currentPosition2 = this.centroid;
			for (int num21 = 0; num21 < this.allCharacters.Count; num21++)
			{
				if (this.allCharacters[num21].hasCreatureBuff)
				{
					currentPosition2 = this.allCharacters[num21].currentPosition;
				}
			}
			for (int num22 = 0; num22 < 3; num22++)
			{
				for (int num23 = 0; num23 < num7; num23++)
				{
					Character character5 = this.nearTargets[num23];
					Vector3 vector5 = character5.currentPosition + Quaternion.LookRotation(currentPosition2 - character5.currentPosition) * Vector3.forward * 2f;
					if (character5.inCircle)
					{
						num8 = 121f;
					}
					else
					{
						num8 = 64f;
					}
					float num24 = num8;
					int num25 = -1;
					for (int num26 = 0; num26 < x; num26++)
					{
						if (this.tested[num26] == 0)
						{
							graphNode = this.nearNodes[num26];
							vector2 = (Vector3)graphNode.position;
							float num6 = this.SubtractVectors(vector2, vector5).sqrMagnitude;
							if (num6 < num24)
							{
								num24 = num6;
								num25 = num26;
							}
						}
					}
					if (num25 > -1)
					{
						this.tested[num25] = 1;
						this.bestNodes.Add(this.nearNodes[num25]);
						this.nearNodesTargets.Add(character5);
					}
				}
			}
		}
		x = this.bestNodes.Count;
		bool foundPath = false;
		GraphNode g = null;
		GraphNode middleNode = null;
		float num27 = float.PositiveInfinity;
		for (int num28 = 0; num28 < this.circleTiles.Count; num28++)
		{
			float num6 = ((Vector3)this.circleTiles[num28].position - this.centroid).sqrMagnitude;
			if (num6 < num27)
			{
				num27 = num6;
				middleNode = this.circleTiles[num28];
			}
		}
		if (middleNode == null && this.centerCharacter)
		{
			middleNode = this.centerCharacter.node;
		}
		if (middleNode != null)
		{
			this.nodeConstraint.constrainTags = false;
			this.nodeConstraint.checkCircleID = this.groupID;
			this.nodeConstraint.checkConnections = 0;
			int num29;
			for (int i = 0; i < x; i = num29 + 1)
			{
				if (!foundPath)
				{
					g = this.bestNodes[i];
					ABPath p = ABPath.ConstructFast(middleNode, g, null);
					p.nnConstraint = this.nodeConstraint;
					AstarPath.StartPath(p, false);
					yield return base.StartCoroutine(p.WaitForPath());
					p.Claim(this);
					if (!p.error)
					{
						bool flag7 = true;
						this.tempPath = p.path;
						foreach (GraphNode graphNode2 in this.tempPath)
						{
							if (graphNode2.circle != this.groupID && graphNode2.circle > 0)
							{
								flag7 = false;
							}
						}
						if (flag7)
						{
							endPoint = g;
							this.savedTarget = this.nearNodesTargets[i];
							p.Release(this, false);
							foundPath = true;
							break;
						}
						p.Release(this, false);
					}
					else
					{
						p.Release(this, false);
					}
					p = null;
				}
				num29 = i;
			}
		}
		if (this.debugConsole)
		{
			string[] array = new string[17];
			array[0] = this.groupID.ToString();
			array[1] = " ";
			array[2] = foundPath.ToString();
			array[3] = " for ";
			array[4] = type;
			array[5] = " suitable nodes ";
			array[6] = this.nearNodes.Count.ToString();
			array[7] = " away from people ";
			array[8] = this.nearNodes2.Count.ToString();
			array[9] = " within target range ";
			array[10] = this.nearNodes3.Count.ToString();
			array[11] = " best nodes ";
			array[12] = this.bestNodes.Count.ToString();
			array[13] = " nearby targets ";
			array[14] = this.nearTargets.Count.ToString();
			array[15] = " saved target ";
			int num30 = 16;
			Character character6 = this.savedTarget;
			array[num30] = ((character6 != null) ? character6.ToString() : null);
			Debug.Log(string.Concat(array));
		}
		if (endPoint != null)
		{
			constPath = ConstantPath.ConstructFast(endPoint, Records.x.GetConstantPathRadius(7), null);
			this.nodeConstraint.constrainTags = false;
			this.nodeConstraint.checkCircleID = this.groupID;
			this.nodeConstraint.passID = 0;
			this.nodeConstraint.passID2 = 0;
			this.nodeConstraint.checkConnections = 0;
			this.nodeConstraint.constrainWalkability = false;
			constPath.nnConstraint = this.nodeConstraint;
			AstarPath.StartPath(constPath, false);
			yield return base.StartCoroutine(constPath.WaitForPath());
			constPath.Claim(this);
			this.allNodes = constPath.allNodes;
			this.nearNodes.Clear();
			x = this.allNodes.Count;
			this.nodeConstraint.constrainWalkability = true;
			if (type == "Flank")
			{
				this.nodeConstraint.constrainTags = true;
				if (this.centerCharacter)
				{
					this.nodeConstraint.passID = this.centerCharacter.nodeStationaryID;
					this.nodeConstraint.passID2 = this.centerCharacter.nodeMovingID;
				}
			}
			vector = (Vector3)endPoint.position;
			for (int num31 = x - 1; num31 >= 0; num31--)
			{
				graphNode = this.allNodes[num31];
				float num6 = this.SubtractVectors((Vector3)graphNode.position, vector).sqrMagnitude;
				if (num6 <= 150f && this.nodeConstraint.Suitable(graphNode))
				{
					this.nearNodes.Add(graphNode);
				}
			}
			constPath.Release(this, false);
			this.savedEndPoint = endPoint;
			this.centerNode = endPoint;
			this.moveTo = (Vector3)endPoint.position;
			for (int num32 = 0; num32 < this.allCharactersFormation.Count; num32++)
			{
				if (type == "Flank" || this.allCharacters[num32].hasCreatureBuff)
				{
					this.allCharactersFormation[num32] = 1;
				}
				else if (type == "Swarm" && !this.allCharacters[num32].hasCreatureBuff)
				{
					this.allCharactersFormation[num32] = -1;
				}
			}
			if (type == "Flank")
			{
				this.inFormationMovement = true;
				this.inSwarmWait = false;
				this.timeSinceFormation = Links.x.gameplay.seconds;
			}
			else
			{
				if (!this.useCenterLinking && this.needsFadeOut)
				{
					this.StartCircleFade(true);
					this.needsFadeOut = false;
				}
				this.timeSinceSwarm = Links.x.gameplay.seconds;
				this.inSwarm = true;
				this.inFormationWait = false;
				for (int num33 = 0; num33 < this.allCharacters.Count; num33++)
				{
					Character character = this.allCharacters[num33];
					if (character.inCircle && character.hasCreatureBuff && !this.movingTogether)
					{
						if (character.resting)
						{
							character.resting = false;
							character.PlayIdle();
						}
						Effects effects = character.gameObject.AddComponent<Effects>();
						Links.x.cellar.AddEffects(effects);
						effects.gameObject.SetActive(true);
						effects.source = character;
						effects.target = character;
						effects.sourceLevel = (float)character.stats.characterRow._Level;
						effects.effectName = "CircleOffense";
						effects.Inflicted(false);
					}
					if (character.actions)
					{
						character.actions.ReturnChargeUpFX();
					}
				}
			}
			float positiveInfinity = float.PositiveInfinity;
			Vector3 vector6 = (Vector3)endPoint.position;
			Vector3 vector7 = vector6;
			float num34 = float.PositiveInfinity;
			if (this.useCenterLinking)
			{
				for (int num35 = 0; num35 < this.linkedTiles.Count; num35++)
				{
					Vector3 vector8 = this.linkedTiles[num35];
					float num6 = (this.linkedTiles[num35] - vector6).sqrMagnitude;
					if (num6 < num34)
					{
						num34 = num6;
						vector7 = this.linkedTiles[num35];
					}
				}
			}
			else
			{
				for (int num36 = 0; num36 < this.circleTiles.Count; num36++)
				{
					if (this.circleTiles[num36] != null)
					{
						float num6 = ((Vector3)this.circleTiles[num36].position - vector6).sqrMagnitude;
						if (num6 < num34)
						{
							num34 = num6;
							vector7 = (Vector3)this.circleTiles[num36].position;
						}
					}
				}
			}
			for (int num37 = 0; num37 < this.allCharacters.Count; num37++)
			{
				Character character = this.allCharacters[num37];
				if (character.inCircle)
				{
					float num6 = (character.currentPosition - vector7).sqrMagnitude;
					if (num6 < positiveInfinity)
					{
						this.centerCharacter = character;
					}
				}
			}
			this.FormationPoints(true, this.centerCharacter, endPoint, type);
		}
		this.formationCoroutine = null;
		yield break;
	}

	// Token: 0x060006CF RID: 1743 RVA: 0x0009304C File Offset: 0x0009124C
	private void FormationPoints(bool all, Character onlyCharacter, GraphNode endPoint, string type)
	{
		this.checkingFormation = true;
		Vector3 vector = (Vector3)this.savedEndPoint.position;
		if (!this.savedTarget)
		{
			this.savedTarget = Links.x.main;
		}
		Quaternion quaternion = Quaternion.LookRotation((Vector3)this.savedEndPoint.position - this.savedTarget.currentPosition);
		Vector3 vector2 = quaternion * Vector3.forward;
		Vector3 vector3 = quaternion * Vector3.right;
		this.move.Clear();
		if (all && this.debug)
		{
			for (int i = 0; i < this.spheres.Count; i++)
			{
				this.spheres[i].SetActive(false);
				this.openSpheres.Add(this.spheres[i]);
			}
			this.spheres.Clear();
		}
		for (int j = 0; j < this.allCharacters.Count; j++)
		{
			Character character = this.allCharacters[j];
			if (character && character.IsSentient() && this.allCharactersFormation[j] != -1)
			{
				this.move.Add(character);
			}
		}
		int count = this.nearNodes.Count;
		int num = 9;
		if (this.allCharacters.Count <= 6)
		{
			num = 6;
		}
		if (this.allCharacters.Count <= 4)
		{
			num = 4;
		}
		if (this.allCharacters.Count <= 3)
		{
			num = 3;
		}
		if (all)
		{
			for (int k = 0; k < this.circleTiles.Count; k++)
			{
				if (this.circleTiles[k].circle == this.groupID)
				{
					this.circleTiles[k].circle = 0;
				}
			}
			this.circleTiles.Clear();
		}
		for (int l = 0; l < this.move.Count; l++)
		{
			if (all || onlyCharacter == this.move[l])
			{
				int num2 = l;
				int num3 = 0;
				bool flag = false;
				bool flag2 = false;
				if (num == 9 || num == 6)
				{
					if (l == 0)
					{
						num2 = 0;
						flag = false;
						flag2 = false;
					}
					if (l == 1)
					{
						num2 = 0;
						flag = true;
						flag2 = false;
						num3 = 1;
					}
					if (l == 2)
					{
						num2 = 0;
						flag = false;
						flag2 = true;
						num3 = 0;
					}
					if (l == 3)
					{
						num2 = 1;
						flag = false;
						flag2 = false;
						num3 = 4;
					}
					if (l == 4)
					{
						num2 = 1;
						flag = true;
						flag2 = false;
						num3 = 7;
					}
					if (l == 5)
					{
						num2 = 1;
						flag = false;
						flag2 = true;
						num3 = 3;
					}
					if (l == 6)
					{
						num2 = 2;
						flag = false;
						flag2 = false;
						num3 = 2;
					}
					if (l == 7)
					{
						num2 = 2;
						flag = true;
						flag2 = false;
						num3 = 5;
					}
					if (l == 8)
					{
						num2 = 2;
						flag = false;
						flag2 = true;
						num3 = 6;
					}
				}
				else if (num == 4)
				{
					if (l == 0)
					{
						num2 = 0;
						flag = false;
						flag2 = false;
					}
					if (l == 1)
					{
						num2 = 0;
						flag = true;
						flag2 = false;
						num3 = 1;
					}
					if (l == 2)
					{
						num2 = 1;
						flag = false;
						flag2 = false;
						num3 = 0;
					}
					if (l == 3)
					{
						num2 = 1;
						flag = true;
						flag2 = false;
						num3 = 4;
					}
				}
				else if (num == 3)
				{
					if (l == 0)
					{
						num2 = 0;
						flag = false;
						flag2 = false;
					}
					if (l == 1)
					{
						num2 = 0;
						flag = true;
						flag2 = false;
						num3 = 1;
					}
					if (l == 2)
					{
						num2 = 1;
						flag = false;
						flag2 = false;
						num3 = 0;
					}
				}
				GraphNode graphNode = null;
				float num4 = 1f;
				if (flag)
				{
					vector3 *= -1f;
				}
				if (!flag2 && !flag)
				{
					num4 = 0f;
				}
				Vector3 vector4 = vector2 * (float)num2 * -2.5f + vector3 * 2.5f * num4 + vector;
				float num5 = float.PositiveInfinity;
				bool flag3 = false;
				if (l > 0)
				{
					graphNode = endPoint.GetConnectionAtIndex(num3);
					if (graphNode != null)
					{
						flag3 = true;
					}
				}
				if (l == 0)
				{
					graphNode = endPoint;
				}
				else if (!flag3)
				{
					for (int m = 0; m < count; m++)
					{
						GraphNode graphNode2 = this.nearNodes[m];
						if (graphNode2.planningA == 0)
						{
							float sqrMagnitude = this.SubtractVectors((Vector3)graphNode2.position, vector4).sqrMagnitude;
							if (sqrMagnitude < num5)
							{
								bool flag4 = false;
								for (int n = 0; n < this.circleTiles.Count; n++)
								{
									if (this.SubtractVectors((Vector3)graphNode2.position, (Vector3)this.circleTiles[n].position).sqrMagnitude < 13.690001f)
									{
										flag4 = true;
									}
								}
								if (flag4)
								{
									num5 = sqrMagnitude;
									graphNode = graphNode2;
								}
							}
						}
					}
				}
				if (graphNode != null)
				{
					Character character2 = this.move[l];
					graphNode.planningA = 1;
					character2.ClearPathUpdates();
					character2.ClearCurrentPathNodes();
					bool flag5 = false;
					if (character2.resting)
					{
						character2.resting = false;
						character2.PlayIdle();
					}
					if (character2.actions)
					{
						character2.actions.ai.StopAI();
						character2.actions.ai.circleMovement = true;
						character2.actions.savedEnemy = this.savedTarget;
						character2.inRecovery = false;
						flag5 = character2.actions.ai.busy;
					}
					if (all)
					{
						character2.checkForLeaderPath = true;
					}
					if (character2.stats.animal && !this.movingTogether)
					{
						character2.running = true;
					}
					if (!flag5)
					{
						character2.ignoreNodeIDs = true;
						character2.pathTargPosition = (Vector3)graphNode.position;
						character2.MakePath(graphNode, 500, false, false, true);
						character2.savedPathTarget = graphNode;
					}
					if (all && this.debug)
					{
						GameObject gameObject;
						if (this.openSpheres.Count > 0)
						{
							gameObject = this.openSpheres[0];
							this.openSpheres.RemoveAt(0);
						}
						else
						{
							gameObject = this.centerCharacter.CreateSphere((Vector3)graphNode.position, 0.25f);
						}
						this.spheres.Add(gameObject);
						gameObject.transform.position = (Vector3)graphNode.position;
						gameObject.SetActive(true);
					}
				}
			}
		}
		if (all)
		{
			this.circleTiles.Add(endPoint);
			for (int num6 = 1; num6 < 9; num6++)
			{
				int num7 = -1;
				if (num == 9 || num == 6)
				{
					if (num6 == 1)
					{
						num7 = 1;
					}
					if (num6 == 2)
					{
						num7 = 0;
					}
					if (num6 == 3)
					{
						num7 = 4;
					}
					if (num6 == 4)
					{
						num7 = 7;
					}
					if (num6 == 5)
					{
						num7 = 3;
					}
					if (num6 == 6)
					{
						num7 = 2;
					}
					if (num6 == 7)
					{
						num7 = 5;
					}
					if (num6 == 8)
					{
						num7 = 6;
					}
				}
				else if (num == 4)
				{
					if (num6 == 1)
					{
						num7 = 1;
					}
					if (num6 == 2)
					{
						num7 = 0;
					}
					if (num6 == 3)
					{
						num7 = 4;
					}
				}
				else if (num == 3)
				{
					if (num6 == 1)
					{
						num7 = 1;
					}
					if (num6 == 2)
					{
						num7 = 0;
					}
				}
				if (num7 > -1)
				{
					GraphNode connectionAtIndex = endPoint.GetConnectionAtIndex(num7);
					if (connectionAtIndex != null && !this.circleTiles.Contains(connectionAtIndex))
					{
						this.circleTiles.Add(connectionAtIndex);
					}
				}
			}
			if (this.centerCharacter && this.centerCharacter.stats.isFishMonster)
			{
				if (!this.inSwarm && !this.inSwarmWait)
				{
					this.AddEffect("Acid");
				}
				else
				{
					this.RemoveEffect();
				}
			}
		}
		if (!this.movingTogether)
		{
			for (int num8 = 0; num8 < this.circleTiles.Count; num8++)
			{
				if (this.circleTiles[num8].circle == 0)
				{
					this.circleTiles[num8].circle = this.groupID;
				}
			}
		}
		for (int num9 = 0; num9 < count; num9++)
		{
			this.nearNodes[num9].planningA = 0;
		}
		this.checkingFormation = false;
	}

	// Token: 0x060006D0 RID: 1744 RVA: 0x00093804 File Offset: 0x00091A04
	public bool AnyoneHasLKP()
	{
		bool flag = false;
		foreach (Character character in this.allCharacters)
		{
			if (character && character.inCircle && character.hasActions && character.actions.ai.seenCount > 0)
			{
				flag = true;
				break;
			}
		}
		return flag;
	}

	// Token: 0x060006D1 RID: 1745 RVA: 0x00093884 File Offset: 0x00091A84
	public float FormationSpeed(Character c)
	{
		return 1f;
	}

	// Token: 0x060006D2 RID: 1746 RVA: 0x0009388C File Offset: 0x00091A8C
	public bool OutsideCircleStatus(Character c)
	{
		int num = this.originalCharacters.IndexOf(c);
		if (num > -1)
		{
			float num2 = this.timeOutsideCircle[num];
			return num2 == -1f || num2 > 20f;
		}
		return true;
	}

	// Token: 0x060006D3 RID: 1747 RVA: 0x000938D0 File Offset: 0x00091AD0
	private void SetCircleTiles(bool removeAll)
	{
		if (this.useCenterLinking)
		{
			for (int i = 0; i < this.setTiles.Count; i++)
			{
				if (this.setTiles[i].circle == this.groupID)
				{
					this.setTiles[i].circle = 0;
				}
			}
			this.setTiles.Clear();
			if (!removeAll)
			{
				for (int j = 0; j < this.allCharacters.Count; j++)
				{
					Character character = this.allCharacters[j];
					bool flag = character.hasCreatureBuff;
					GraphNode node = character.node;
					if (!flag)
					{
						int num = this.originalCharacters.IndexOf(character);
						if (num > -1)
						{
							float num2 = this.timeOutsideCircle[num];
							if (num2 > -1f && num2 < 10f)
							{
								flag = true;
							}
						}
					}
					if (flag && node != null)
					{
						if (node.circle == 0)
						{
							node.circle = this.groupID;
							this.setTiles.Add(node);
						}
						if (!this.inSwarm && !this.inFormationMovement)
						{
							for (int k = 0; k < 8; k++)
							{
								if (node.ConnectionFromIndex(k) != null && node.circle == 0)
								{
									node.circle = this.groupID;
									this.setTiles.Add(node);
								}
							}
						}
					}
				}
				return;
			}
			for (int l = 0; l < this.circleTiles.Count; l++)
			{
				if (this.circleTiles[l].circle == this.groupID)
				{
					this.circleTiles[l].circle = 0;
				}
			}
		}
	}

	// Token: 0x060006D4 RID: 1748 RVA: 0x00093A6C File Offset: 0x00091C6C
	public void JoinCirclePath(GraphNode n, Character c)
	{
		bool flag = true;
		if (this.inFormationMovement || this.inSwarm)
		{
			int num = this.allCharacters.IndexOf(c);
			if (this.allCharactersFormation[num] == 0)
			{
				flag = true;
			}
			if (c.actions && (c.actions.ai.jumping || c.actions.ai.busy))
			{
				flag = false;
			}
		}
		if (!c.IsSentient() || c.waitingForPath == 1 || c.waitingForPath == -1)
		{
			flag = false;
		}
		if (flag)
		{
			c.ignoreNodeIDs = true;
			c.running = true;
			c.MakePath(n, 50, false, false, true);
		}
	}

	// Token: 0x060006D5 RID: 1749 RVA: 0x00093B14 File Offset: 0x00091D14
	public float GetRotationAngle(Quaternion r1, Quaternion r2)
	{
		Vector3 eulerAngles = r1.eulerAngles;
		eulerAngles.x = 0f;
		eulerAngles.z = 0f;
		r1 = Quaternion.Euler(eulerAngles);
		Vector3 eulerAngles2 = r2.eulerAngles;
		eulerAngles.x = 0f;
		eulerAngles.z = 0f;
		r2 = Quaternion.Euler(eulerAngles2);
		return Quaternion.Angle(r1, r2);
	}

	// Token: 0x060006D6 RID: 1750 RVA: 0x00093B78 File Offset: 0x00091D78
	public Vector3 SubtractVectors(Vector3 a, Vector3 b)
	{
		Vector3 vector;
		vector.x = a.x - b.x;
		vector.y = a.y - b.y;
		vector.z = a.z - b.z;
		return vector;
	}

	// Token: 0x060006D7 RID: 1751 RVA: 0x00093BC4 File Offset: 0x00091DC4
	private bool CharacterNeedsToBeDefended(Character c)
	{
		return c.protectMe || c.stats.needsDefending || (c.stats.canCastSpells && c.hasActions && (c.actions.ai.rangeWeaponIndex == 0 || !c.actions.ai.canMeleeRangeAttack));
	}

	// Token: 0x060006D8 RID: 1752 RVA: 0x00093C24 File Offset: 0x00091E24
	public void StartPulse(bool first)
	{
		if (!first)
		{
			this.startPulseDither = 1f;
			this.endPulseDither = 0f;
		}
		else
		{
			this.startPulseDither = 0f;
			this.endPulseDither = 1f;
		}
		if (this.pulsing)
		{
			this.pulse = this.startPulseDither;
		}
		this.pulseAmount = 0f;
		this.pulsing = true;
	}

	// Token: 0x060006D9 RID: 1753 RVA: 0x00093C88 File Offset: 0x00091E88
	public void StartCircleFade(bool fadeOut)
	{
		this.pulsing = false;
		if (fadeOut)
		{
			this.startDither = 0f;
			this.endDither = 1f;
		}
		else
		{
			this.startDither = 1f;
			this.endDither = 0f;
		}
		this.currentDither = this.startDither;
		this.fadeAmount = 0f;
		this.fading = true;
	}

	// Token: 0x060006DA RID: 1754 RVA: 0x00093CEC File Offset: 0x00091EEC
	private void AddEffect(string n)
	{
		if (this.effect)
		{
			this.effect.Remove();
		}
		this.effect = Links.x.tileEffects.AddComponent<TileEffects>();
		this.effect.gameObject.SetActive(true);
		Library.Effects effectRow = Links.x.library.GetEffectRow(n);
		this.effect.fromGroup = true;
		this.effect.group = this;
		this.effect.Setup(null, effectRow, null, null, null, this.centerCharacter);
	}

	// Token: 0x060006DB RID: 1755 RVA: 0x00093D76 File Offset: 0x00091F76
	private void RemoveEffect()
	{
		if (this.effect)
		{
			this.effect.Remove();
		}
	}

	// Token: 0x0400098A RID: 2442
	[Header("Info")]
	public int groupID;

	// Token: 0x0400098B RID: 2443
	public int dangerLevel;

	// Token: 0x0400098C RID: 2444
	public int maxCharacters;

	// Token: 0x0400098D RID: 2445
	public bool circleIsActive;

	// Token: 0x0400098E RID: 2446
	public Vector3 center;

	// Token: 0x0400098F RID: 2447
	public Character centerCharacter;

	// Token: 0x04000990 RID: 2448
	public GraphNode centerNode;

	// Token: 0x04000991 RID: 2449
	public Vector3 frontOfCircle;

	// Token: 0x04000992 RID: 2450
	public Vector3 middleCircle;

	// Token: 0x04000993 RID: 2451
	public Vector3 backOfCircle;

	// Token: 0x04000994 RID: 2452
	public Quaternion targetRotation;

	// Token: 0x04000995 RID: 2453
	public bool aggressive;

	// Token: 0x04000996 RID: 2454
	public bool staminaFilling;

	// Token: 0x04000997 RID: 2455
	public bool movingTogether;

	// Token: 0x04000998 RID: 2456
	public bool defensive;

	// Token: 0x04000999 RID: 2457
	public int morale;

	// Token: 0x0400099A RID: 2458
	public int inCircleCount;

	// Token: 0x0400099B RID: 2459
	public Vector3 centroid;

	// Token: 0x0400099C RID: 2460
	public bool useCenterLinking;

	// Token: 0x0400099D RID: 2461
	public bool doFade;

	// Token: 0x0400099E RID: 2462
	public float pulse;

	// Token: 0x0400099F RID: 2463
	public float fade;

	// Token: 0x040009A0 RID: 2464
	public bool isBreaking;

	// Token: 0x040009A1 RID: 2465
	public int canBeInCircle;

	// Token: 0x040009A2 RID: 2466
	private List<Vector3> positions = new List<Vector3>();

	// Token: 0x040009A3 RID: 2467
	public List<GameObject> lines = new List<GameObject>();

	// Token: 0x040009A4 RID: 2468
	public int linenum;

	// Token: 0x040009A5 RID: 2469
	private List<Vector3> linkedTiles = new List<Vector3>();

	// Token: 0x040009A6 RID: 2470
	public List<Character> allCharacters = new List<Character>();

	// Token: 0x040009A7 RID: 2471
	public List<int> allCharactersFormation = new List<int>();

	// Token: 0x040009A8 RID: 2472
	public List<Character> inCircleCharacters = new List<Character>();

	// Token: 0x040009A9 RID: 2473
	public List<GraphNode> circleTiles = new List<GraphNode>();

	// Token: 0x040009AA RID: 2474
	public List<Character> originalCharacters = new List<Character>();

	// Token: 0x040009AB RID: 2475
	public List<float> timeOutsideCircle = new List<float>();

	// Token: 0x040009AC RID: 2476
	private List<Character> dioramaCharacters;

	// Token: 0x040009AD RID: 2477
	private List<Character> nearCharacters = new List<Character>();

	// Token: 0x040009AE RID: 2478
	private List<Character> nearTargets = new List<Character>();

	// Token: 0x040009AF RID: 2479
	private List<Character> nearNodesTargets = new List<Character>();

	// Token: 0x040009B0 RID: 2480
	private List<Character> intruders = new List<Character>();

	// Token: 0x040009B1 RID: 2481
	private List<float> intruderTime = new List<float>();

	// Token: 0x040009B2 RID: 2482
	private List<Character> intruderTemp = new List<Character>();

	// Token: 0x040009B3 RID: 2483
	private List<float> intruderTimeTemp = new List<float>();

	// Token: 0x040009B4 RID: 2484
	private List<Vector3> fxPositions = new List<Vector3>();

	// Token: 0x040009B5 RID: 2485
	private NNConstraint nodeConstraintFormation = new NNConstraint();

	// Token: 0x040009B6 RID: 2486
	private List<GraphNode> openTiles = new List<GraphNode>();

	// Token: 0x040009B7 RID: 2487
	private GraphNode savedEndPoint;

	// Token: 0x040009B8 RID: 2488
	private List<Character> move = new List<Character>();

	// Token: 0x040009B9 RID: 2489
	private NNConstraint nodeConstraint = new NNConstraint();

	// Token: 0x040009BA RID: 2490
	private List<GameObject> spheres = new List<GameObject>();

	// Token: 0x040009BB RID: 2491
	private List<GameObject> openSpheres = new List<GameObject>();

	// Token: 0x040009BC RID: 2492
	public IEnumerator formationCoroutine;

	// Token: 0x040009BD RID: 2493
	private List<GraphNode> allNodes;

	// Token: 0x040009BE RID: 2494
	private List<GraphNode> nearNodes = new List<GraphNode>();

	// Token: 0x040009BF RID: 2495
	private List<GraphNode> nearNodes2 = new List<GraphNode>();

	// Token: 0x040009C0 RID: 2496
	private List<GraphNode> nearNodes3 = new List<GraphNode>();

	// Token: 0x040009C1 RID: 2497
	private List<GraphNode> bestNodes = new List<GraphNode>();

	// Token: 0x040009C2 RID: 2498
	private List<GraphNode> setTiles = new List<GraphNode>();

	// Token: 0x040009C3 RID: 2499
	private List<GraphNode> tempPath;

	// Token: 0x040009C4 RID: 2500
	private List<int> tested = new List<int>();

	// Token: 0x040009C5 RID: 2501
	private bool debug;

	// Token: 0x040009C6 RID: 2502
	private bool debugConsole;

	// Token: 0x040009C7 RID: 2503
	private GameObject sphere;

	// Token: 0x040009C8 RID: 2504
	public bool inFormationMovement;

	// Token: 0x040009C9 RID: 2505
	public bool inSwarm;

	// Token: 0x040009CA RID: 2506
	public bool inFormationWait;

	// Token: 0x040009CB RID: 2507
	public bool inSwarmWait;

	// Token: 0x040009CC RID: 2508
	public float timeSinceFormation;

	// Token: 0x040009CD RID: 2509
	public float timeSinceSwarm;

	// Token: 0x040009CE RID: 2510
	public float timeSinceGather;

	// Token: 0x040009CF RID: 2511
	public float timeSinceFormationWait;

	// Token: 0x040009D0 RID: 2512
	public float timeSinceSwarmWait;

	// Token: 0x040009D1 RID: 2513
	private Vector3 moveTo;

	// Token: 0x040009D2 RID: 2514
	public bool canShowLine;

	// Token: 0x040009D3 RID: 2515
	public bool checkingFormation;

	// Token: 0x040009D4 RID: 2516
	public bool needsFade;

	// Token: 0x040009D5 RID: 2517
	public bool needsFadeOut;

	// Token: 0x040009D6 RID: 2518
	private Character savedTarget;

	// Token: 0x040009D7 RID: 2519
	public float currentDither;

	// Token: 0x040009D8 RID: 2520
	private float startDither;

	// Token: 0x040009D9 RID: 2521
	private float endDither;

	// Token: 0x040009DA RID: 2522
	private float fadeAmount;

	// Token: 0x040009DB RID: 2523
	private float staminaRecoverTime;

	// Token: 0x040009DC RID: 2524
	private float staminaFillTime;

	// Token: 0x040009DD RID: 2525
	public bool fading;

	// Token: 0x040009DE RID: 2526
	private GameObject staminaRecover;

	// Token: 0x040009DF RID: 2527
	private float startPulseDither;

	// Token: 0x040009E0 RID: 2528
	private float endPulseDither;

	// Token: 0x040009E1 RID: 2529
	private float pulseAmount;

	// Token: 0x040009E2 RID: 2530
	public bool pulsing;

	// Token: 0x040009E3 RID: 2531
	private float updateTime;

	// Token: 0x040009E4 RID: 2532
	private float checkDirectionTime;

	// Token: 0x040009E5 RID: 2533
	private int formationFlankTries;

	// Token: 0x040009E6 RID: 2534
	private int formationSwarmTries;

	// Token: 0x040009E7 RID: 2535
	private TileEffects effect;
}