using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using R2API;
using RoR2;
using RoR2.CharacterAI;
using RoR2.Navigation;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RogueTeamPlugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RogueTeamPlugin")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a4c09232-17b4-460d-9533-44d54f380794")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RogueTeamPlugin
{
	public class NewFriendsAchievement : ModdedUnlockable
	{
		public const string AchievementId = "ROGUE_NEWFRIENDS_ACHIEVEMENT_ID";

		public const string UnlockableId = "ROGUE_NEWFRIENDS_UNLOCKABLE_ID";

		public override string AchievementIdentifier => "ROGUE_NEWFRIENDS_ACHIEVEMENT_ID";

		public override string UnlockableIdentifier => "ROGUE_NEWFRIENDS_UNLOCKABLE_ID";

		public override string AchievementNameToken => "NEW_FRIENDS_ACHIEVEMENT_NAME";

		public override string AchievementDescToken => "NEW_FRIENDS_ACHIEVEMENT_DESC";

		public override string UnlockableNameToken => "NEW_FRIENDS_UNLOCKABLE_NAME";

		public override Sprite Sprite => null;

		public override string PrerequisiteUnlockableIdentifier => "";

		public override Func<string> GetHowToUnlock => () => "Escape the planet with the Rogue faction enabled.";

		public override Func<string> GetUnlocked => () => "You escaped the planet with Rogue allies.";
	}
	public static class RogueArtifact
	{
		public static ArtifactDef Artifact;

		public static bool Enabled
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)RunArtifactManager.instance))
				{
					return false;
				}
				return RunArtifactManager.instance.IsArtifactEnabled(Artifact);
			}
		}

		public static void Init()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			Artifact = ScriptableObject.CreateInstance<ArtifactDef>();
			Artifact.cachedName = "ArtifactOfTheRogue";
			Artifact.nameToken = "ARTIFACT_ROGUE_NAME";
			Artifact.descriptionToken = "ARTIFACT_ROGUE_DESC";
			Artifact.smallIconSelectedSprite = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/Common/texArtifactEnabled.png").WaitForCompletion();
			Artifact.smallIconDeselectedSprite = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/Common/texArtifactDisabled.png").WaitForCompletion();
			Artifact.pickupModelPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/ArtifactShell.prefab").WaitForCompletion();
			Artifact.unlockableDef = null;
			LanguageAPI.Add("ARTIFACT_ROGUE_NAME", "Artifact of the Rogue");
			LanguageAPI.Add("ARTIFACT_ROGUE_DESC", "Enables the Rogue Team.");
			ArtifactCatalog.getAdditionalEntries += delegate(List<ArtifactDef> list)
			{
				if (!list.Contains(Artifact))
				{
					list.Add(Artifact);
				}
			};
			Debug.Log((object)"[Rogue] ArtifactOfTheRogue registered.");
		}
	}
	public static class RogueDebug
	{
		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CC_RogueDebug(ConCommandArgs args)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RogueDirector.instance == (Object)null)
			{
				Debug.Log((object)"[RogueDebug] RogueDirector is NULL.");
				return;
			}
			RogueDirector instance = RogueDirector.instance;
			Debug.Log((object)"=== ROGUE DIRECTOR DEBUG ===");
			Debug.Log((object)$"Initial Spawn Done: {instance.InitialSpawnDone}");
			Debug.Log((object)$"Is First Stage: {instance.IsFirstStage}");
			Debug.Log((object)$"Max Rogues: {instance.MaxRogues}");
			Debug.Log((object)$"Alive Rogues: {instance.AliveCount}");
			Debug.Log((object)$"Reinforcement Timer: {instance.ReinforcementTimer:F1} / 300");
			Debug.Log((object)("Leader: " + instance.LeaderName));
			Debug.Log((object)$"Has Leader: {instance.HasLeader}");
			Debug.Log((object)"--- Squad ---");
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			Debug.Log((object)$"Squad Members: {orCreateSquad.Members.Count}");
			Debug.Log((object)("Squad Leader: " + (Object.op_Implicit((Object)(object)orCreateSquad.Leader) ? ((Object)orCreateSquad.Leader).name : "None")));
			Debug.Log((object)"--- Last Spawn Info ---");
			Debug.Log((object)$"Last Spawn Success: {instance.LastSpawnSuccess}");
			Debug.Log((object)$"Last Spawn Position: {instance.LastSpawnPosition}");
			Debug.Log((object)"--- Node Selection ---");
			Debug.Log((object)$"Last Node Distance Threshold Used: {instance.LastNodeThreshold}");
			Debug.Log((object)$"Last Node Found: {instance.LastNodeFound}");
			Debug.Log((object)$"Last Node Position: {instance.LastNodePosition}");
			Debug.Log((object)"=== END DEBUG ===");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CC_RogueDebugVerbose(ConCommandArgs args)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CC_RogueDebug(args);
			if ((Object)(object)RogueDirector.instance == (Object)null)
			{
				return;
			}
			RogueDirector instance = RogueDirector.instance;
			Debug.Log((object)"=== VERBOSE ===");
			Debug.Log((object)"--- Rogue Masters ---");
			foreach (CharacterMaster rogueMaster in instance.RogueMasters)
			{
				if (Object.op_Implicit((Object)(object)rogueMaster))
				{
					CharacterBody body = rogueMaster.GetBody();
					Debug.Log((object)$"Master: {((Object)rogueMaster).name}, Alive: {Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive}");
				}
			}
			Debug.Log((object)"--- Survivors (Persistence) ---");
			if ((Object)(object)RoguePersistence.instance != (Object)null)
			{
				foreach (CharacterMaster survivor in RoguePersistence.instance.SurvivorList)
				{
					Debug.Log((object)("Survivor: " + ((Object)survivor).name));
				}
			}
			Debug.Log((object)"=== END VERBOSE ===");
		}
	}
	public class RogueDirector : MonoBehaviour
	{
		public static RogueDirector instance;

		private const float ReinforcementInterval = 300f;

		private static readonly float[] DistanceThresholds = new float[3] { 60f, 40f, 20f };

		private int maxRogues;

		private bool initialSpawnDone;

		private bool isFirstStage;

		private float reinforcementTimer;

		private readonly List<CharacterMaster> rogueMasters = new List<CharacterMaster>();

		private CharacterMaster leaderMaster;

		public bool LastSpawnSuccess { get; private set; }

		public Vector3 LastSpawnPosition { get; private set; }

		public float LastNodeThreshold { get; private set; }

		public bool LastNodeFound { get; private set; }

		public Vector3 LastNodePosition { get; private set; }

		public bool InitialSpawnDone => initialSpawnDone;

		public bool IsFirstStage => isFirstStage;

		public int MaxRogues => maxRogues;

		public float ReinforcementTimer => reinforcementTimer;

		public int AliveCount => CountAliveRogues();

		public bool HasLeader => (Object)(object)leaderMaster != (Object)null;

		public string LeaderName => Object.op_Implicit((Object)(object)leaderMaster) ? ((Object)leaderMaster).name : "None";

		public IReadOnlyList<CharacterMaster> RogueMasters => rogueMasters;

		public static void Init()
		{
			SceneDirector.onPrePopulateSceneServer += OnSceneStart;
		}

		public static void ClearRogues()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)instance))
			{
				Debug.Log((object)"[Rogue][DEBUG] ClearRogues called. Clearing rogueMasters and squad.");
				instance.rogueMasters.Clear();
				instance.leaderMaster = null;
				RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
				orCreateSquad.Members.Clear();
				orCreateSquad.SetLeader(null);
			}
		}

		public static void RegisterExistingRogue(CharacterMaster master)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)master))
			{
				if (!Object.op_Implicit((Object)(object)instance))
				{
					Debug.LogWarning((object)"[Rogue][DEBUG] RegisterExistingRogue called but RogueDirector is null.");
				}
				else if (!instance.rogueMasters.Contains(master))
				{
					Debug.Log((object)("[Rogue][DEBUG] RegisterExistingRogue: " + ((Object)master).name));
					instance.rogueMasters.Add(master);
					instance.RefreshLeaderFromSquad();
					RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
					orCreateSquad.AddMember(master);
				}
			}
		}

		private static void OnSceneStart(SceneDirector sceneDirector)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			if (!RogueArtifact.Enabled)
			{
				Debug.Log((object)"[Rogue][DEBUG] RogueArtifact disabled. RogueDirector will not initialize this stage.");
				return;
			}
			SceneDef sceneDefForCurrentScene = SceneCatalog.GetSceneDefForCurrentScene();
			if (!Object.op_Implicit((Object)(object)sceneDefForCurrentScene) || (int)sceneDefForCurrentScene.sceneType != 1)
			{
				Debug.Log((object)("[Rogue][DEBUG] Scene is not a Stage. RogueDirector not created. sceneDef=" + (Object.op_Implicit((Object)(object)sceneDefForCurrentScene) ? sceneDefForCurrentScene.cachedName : "null")));
				return;
			}
			if (!Object.op_Implicit((Object)(object)instance))
			{
				GameObject val = new GameObject("RogueDirector");
				instance = val.AddComponent<RogueDirector>();
				Object.DontDestroyOnLoad((Object)(object)val);
				Debug.Log((object)("[Rogue] RogueDirector created for stage: " + sceneDefForCurrentScene.cachedName));
			}
			int num = (Object.op_Implicit((Object)(object)Run.instance) ? Run.instance.stageClearCount : 0);
			instance.ConfigureForStage(num);
			Debug.Log((object)("[Rogue] RogueDirector activated for stage: " + sceneDefForCurrentScene.cachedName + ", " + $"stageIndex={num}, maxRogues={instance.maxRogues}, isFirstStage={instance.isFirstStage}"));
		}

		private void ConfigureForStage(int stageIndex)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			maxRogues = 6 + stageIndex * 2;
			isFirstStage = stageIndex == 0;
			initialSpawnDone = false;
			reinforcementTimer = 0f;
			rogueMasters.Clear();
			leaderMaster = null;
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			orCreateSquad.Members.Clear();
			orCreateSquad.SetLeader(null);
		}

		private void FixedUpdate()
		{
			if (!Object.op_Implicit((Object)(object)Run.instance))
			{
				return;
			}
			PruneRogueList();
			RefreshLeaderFromSquad();
			float fixedDeltaTime = Time.fixedDeltaTime;
			if (!initialSpawnDone)
			{
				if (isFirstStage)
				{
					Debug.Log((object)"[Rogue][DEBUG] InitialSpawn: First stage, spawning immediately.");
					TryInitialSpawnFromPlayer();
					initialSpawnDone = true;
					reinforcementTimer = 0f;
					return;
				}
				reinforcementTimer += fixedDeltaTime;
				if (reinforcementTimer >= 300f)
				{
					Debug.Log((object)"[Rogue][DEBUG] InitialSpawn: Delayed stage, spawning after interval.");
					TryInitialSpawnFromPlayer();
					initialSpawnDone = true;
					reinforcementTimer = 0f;
				}
			}
			else
			{
				reinforcementTimer += fixedDeltaTime;
				if (reinforcementTimer >= 300f)
				{
					reinforcementTimer = 0f;
					Debug.Log((object)"[Rogue][DEBUG] Reinforcement timer elapsed. Trying reinforcement spawn.");
					TrySpawnReinforcement();
				}
			}
		}

		private void TryInitialSpawnFromPlayer()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			Vector3? anyPlayerPosition = GetAnyPlayerPosition();
			if (!anyPlayerPosition.HasValue)
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] TryInitialSpawnFromPlayer: No player found for initial Rogue spawn.");
				return;
			}
			Vector3 value = anyPlayerPosition.Value;
			Debug.Log((object)("[Rogue][DEBUG] TryInitialSpawnFromPlayer: Using player position " + ((object)(Vector3)(ref value)).ToString()));
			EnsureRogueCount(anyPlayerPosition.Value);
		}

		private void TrySpawnReinforcement()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			int num = CountAliveRogues();
			if (num >= maxRogues)
			{
				Debug.Log((object)("[Rogue][DEBUG] TrySpawnReinforcement: AliveRogues=" + num + " >= maxRogues=" + maxRogues + ". Skipping."));
			}
			else
			{
				Vector3? val = GetLeaderPosition() ?? GetAnyRoguePosition() ?? GetAnyPlayerPosition();
				if (val.HasValue)
				{
					Vector3 value = val.Value;
					Debug.Log((object)("[Rogue][DEBUG] TrySpawnReinforcement: Anchor position " + ((object)(Vector3)(ref value)).ToString()));
					SpawnSingleRogueAtAnchor(val.Value);
				}
				else
				{
					Debug.LogWarning((object)"[Rogue][DEBUG] TrySpawnReinforcement: No valid anchor found (no leader/rogue/player).");
				}
			}
		}

		private void EnsureRogueCount(Vector3 anchor)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = maxRogues * 2;
			Debug.Log((object)("[Rogue][DEBUG] EnsureRogueCount: Starting. CurrentAlive=" + CountAliveRogues() + " target=" + maxRogues));
			while (CountAliveRogues() < maxRogues && num < num2)
			{
				bool flag = SpawnSingleRogueAtAnchor(anchor);
				Debug.Log((object)("[Rogue][DEBUG] EnsureRogueCount: SpawnRequested=" + flag + " attempts=" + num + " alive=" + CountAliveRogues()));
				if (!flag)
				{
					break;
				}
				num++;
			}
			if (num >= num2)
			{
				Debug.LogWarning((object)("[Rogue] Spawn loop aborted to prevent freeze. attempts=" + num));
			}
		}

		private bool SpawnSingleRogueAtAnchor(Vector3 anchor)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)DirectorCore.instance))
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] SpawnSingleRogueAtAnchor: DirectorCore.instance is NULL.");
				return false;
			}
			if ((Object)(object)RogueSpawnCard.RogueCard == (Object)null)
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] SpawnSingleRogueAtAnchor: RogueSpawnCard.RogueCard is NULL.");
				return false;
			}
			if (!TryGetSpawnPositionFarFrom(anchor, out var position))
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] SpawnSingleRogueAtAnchor: Failed to find spawn position.");
				return false;
			}
			LastSpawnSuccess = false;
			LastSpawnPosition = position;
			Vector3 val = position;
			Debug.Log((object)("[Rogue][DEBUG] SpawnSingleRogueAtAnchor: Attempting spawn at " + ((object)(Vector3)(ref val)).ToString()));
			DirectorSpawnRequest val2 = new DirectorSpawnRequest((SpawnCard)(object)RogueSpawnCard.RogueCard, new DirectorPlacementRule
			{
				placementMode = (PlacementMode)0,
				position = position
			}, RoR2Application.rng);
			val2.teamIndexOverride = RogueTeamPlugin.RogueTeam;
			val2.onSpawnedServer = (Action<SpawnResult>)Delegate.Combine(val2.onSpawnedServer, new Action<SpawnResult>(OnRogueSpawnedServer));
			DirectorCore.instance.TrySpawnObject(val2);
			return true;
		}

		private void OnRogueSpawnedServer(SpawnResult result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			if (!result.success || !Object.op_Implicit((Object)(object)result.spawnedInstance))
			{
				Debug.LogWarning((object)("[Rogue][DEBUG] OnRogueSpawnedServer: SpawnResult FAILED. success=" + result.success + " spawnedInstance=" + (object)result.spawnedInstance));
				return;
			}
			LastSpawnSuccess = true;
			CharacterMaster component = result.spawnedInstance.GetComponent<CharacterMaster>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] OnRogueSpawnedServer: Spawned instance has NO CharacterMaster.");
				return;
			}
			string name = ((Object)component).name;
			TeamIndex teamIndex = component.teamIndex;
			Debug.Log((object)("[Rogue][DEBUG] OnRogueSpawnedServer: Spawned Rogue Master=" + name + " | team(before)=" + ((object)(TeamIndex)(ref teamIndex)).ToString()));
			component.teamIndex = RogueTeamPlugin.RogueTeam;
			CharacterBody body = component.GetBody();
			if (Object.op_Implicit((Object)(object)body))
			{
				if (Object.op_Implicit((Object)(object)body.teamComponent))
				{
					body.teamComponent.teamIndex = RogueTeamPlugin.RogueTeam;
				}
				string name2 = ((Object)body).name;
				object obj;
				if (!Object.op_Implicit((Object)(object)body.teamComponent))
				{
					obj = "no TeamComponent";
				}
				else
				{
					teamIndex = body.teamComponent.teamIndex;
					obj = ((object)(TeamIndex)(ref teamIndex)).ToString();
				}
				Debug.Log((object)("[Rogue][DEBUG] OnRogueSpawnedServer: Rogue Body=" + name2 + " | team=" + (string?)obj));
			}
			else
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] OnRogueSpawnedServer: Spawned Rogue has NO BODY yet.");
			}
			if (!rogueMasters.Contains(component))
			{
				rogueMasters.Add(component);
				Debug.Log((object)("[Rogue][DEBUG] OnRogueSpawnedServer: Added master to rogueMasters list. Count=" + rogueMasters.Count));
			}
			else
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] OnRogueSpawnedServer: Master already existed in rogueMasters list.");
			}
			RefreshLeaderFromSquad();
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			orCreateSquad.AddMember(component);
			Debug.Log((object)"[Rogue][DEBUG] OnRogueSpawnedServer: Rogue fully registered into squad.");
		}

		private bool TryGetSpawnPositionFarFrom(Vector3 anchor, out Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			position = anchor;
			SceneInfo val = SceneInfo.instance;
			if (!Object.op_Implicit((Object)(object)val))
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] TryGetSpawnPositionFarFrom: SceneInfo.instance is NULL.");
				return false;
			}
			NodeGraph nodeGraph = val.GetNodeGraph((GraphType)0);
			if (!Object.op_Implicit((Object)(object)nodeGraph))
			{
				Debug.LogWarning((object)"[Rogue][DEBUG] TryGetSpawnPositionFarFrom: Ground NodeGraph is NULL.");
				return false;
			}
			float[] distanceThresholds = DistanceThresholds;
			Vector3 val2;
			for (int i = 0; i < distanceThresholds.Length; i++)
			{
				float minDistance = distanceThresholds[i];
				if (TryFindNodeWithMinDistance(nodeGraph, anchor, minDistance, out position))
				{
					val2 = position;
					Debug.Log((object)("[Rogue][DEBUG] TryGetSpawnPositionFarFrom: Found node at " + ((object)(Vector3)(ref val2)).ToString() + " with minDistance=" + minDistance));
					return true;
				}
				Debug.Log((object)("[Rogue][DEBUG] TryGetSpawnPositionFarFrom: No node found for threshold " + minDistance));
			}
			if (TryFindAnyValidNode(nodeGraph, out position))
			{
				val2 = position;
				Debug.Log((object)("[Rogue][DEBUG] TryGetSpawnPositionFarFrom: Using ANY valid node fallback at " + ((object)(Vector3)(ref val2)).ToString()));
				return true;
			}
			Debug.LogWarning((object)"[Rogue][DEBUG] TryGetSpawnPositionFarFrom: Failed to find ANY valid node.");
			return false;
		}

		private bool TryFindNodeWithMinDistance(NodeGraph graph, Vector3 anchor, float minDistance, out Vector3 position)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			position = anchor;
			bool flag = false;
			int nodeCount = graph.GetNodeCount();
			NodeIndex val = default(NodeIndex);
			Vector3 val2 = default(Vector3);
			NodeFlags flags = default(NodeFlags);
			for (int i = 0; i < nodeCount; i++)
			{
				((NodeIndex)(ref val))..ctor(i);
				if (graph.GetNodePosition(val, ref val2) && !(Vector3.Distance(anchor, val2) < minDistance) && graph.GetNodeFlags(val, ref flags) && IsNodeValidForRogue(flags))
				{
					position = val2;
					flag = true;
					break;
				}
			}
			LastNodeThreshold = minDistance;
			LastNodeFound = flag;
			LastNodePosition = position;
			return flag;
		}

		private bool TryFindAnyValidNode(NodeGraph graph, out Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			int nodeCount = graph.GetNodeCount();
			NodeIndex val = default(NodeIndex);
			Vector3 val2 = default(Vector3);
			NodeFlags flags = default(NodeFlags);
			for (int i = 0; i < nodeCount; i++)
			{
				((NodeIndex)(ref val))..ctor(i);
				if (graph.GetNodePosition(val, ref val2) && graph.GetNodeFlags(val, ref flags) && IsNodeValidForRogue(flags))
				{
					position = val2;
					LastNodeThreshold = -1f;
					LastNodeFound = true;
					LastNodePosition = position;
					return true;
				}
			}
			LastNodeThreshold = -1f;
			LastNodeFound = false;
			LastNodePosition = Vector3.zero;
			return false;
		}

		private bool IsNodeValidForRogue(NodeFlags flags)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			if ((Object)(object)RogueSpawnCard.RogueCard == (Object)null)
			{
				return true;
			}
			NodeFlags requiredFlags = ((SpawnCard)RogueSpawnCard.RogueCard).requiredFlags;
			NodeFlags forbiddenFlags = ((SpawnCard)RogueSpawnCard.RogueCard).forbiddenFlags;
			if ((flags & forbiddenFlags) > 0)
			{
				return false;
			}
			if ((int)requiredFlags != 0 && (flags & requiredFlags) == 0)
			{
				return false;
			}
			return true;
		}

		private void PruneRogueList()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			for (int num = rogueMasters.Count - 1; num >= 0; num--)
			{
				CharacterMaster val = rogueMasters[num];
				if (!Object.op_Implicit((Object)(object)val))
				{
					Debug.LogWarning((object)"[Rogue][DEBUG] Prune: NULL master removed.");
					rogueMasters.RemoveAt(num);
				}
				else if (val.teamIndex != RogueTeamPlugin.RogueTeam)
				{
					string[] obj = new string[5]
					{
						"[Rogue][DEBUG] Prune: Master ",
						((Object)val).name,
						" removed due to WRONG TEAM (",
						null,
						null
					};
					TeamIndex teamIndex = val.teamIndex;
					obj[3] = ((object)(TeamIndex)(ref teamIndex)).ToString();
					obj[4] = ")";
					Debug.LogWarning((object)string.Concat(obj));
					rogueMasters.RemoveAt(num);
				}
				else
				{
					CharacterBody body = val.GetBody();
					if (!Object.op_Implicit((Object)(object)body))
					{
						Debug.LogWarning((object)("[Rogue][DEBUG] Prune: Master " + ((Object)val).name + " has NO BODY."));
						rogueMasters.RemoveAt(num);
					}
					else if (!Object.op_Implicit((Object)(object)body.healthComponent) || !body.healthComponent.alive)
					{
						Debug.LogWarning((object)("[Rogue][DEBUG] Prune: Master " + ((Object)val).name + " body is DEAD."));
						rogueMasters.RemoveAt(num);
					}
				}
			}
		}

		private void RefreshLeaderFromSquad()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			orCreateSquad.EnsureLeader();
			CharacterMaster leader = orCreateSquad.Leader;
			if (Object.op_Implicit((Object)(object)leader) && rogueMasters.Contains(leader))
			{
				if ((Object)(object)leaderMaster != (Object)(object)leader)
				{
					leaderMaster = leader;
					Debug.Log((object)("[Rogue][DEBUG] RefreshLeaderFromSquad: New leader=" + ((Object)leaderMaster).name));
				}
				return;
			}
			if ((Object)(object)leaderMaster != (Object)null)
			{
				Debug.Log((object)"[Rogue][DEBUG] RefreshLeaderFromSquad: No valid leader, clearing.");
			}
			leaderMaster = null;
			orCreateSquad.SetLeader(null);
		}

		private int CountAliveRogues()
		{
			int num = 0;
			foreach (CharacterMaster rogueMaster in rogueMasters)
			{
				if (Object.op_Implicit((Object)(object)rogueMaster))
				{
					CharacterBody body = rogueMaster.GetBody();
					if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
					{
						num++;
					}
				}
			}
			return num;
		}

		private Vector3? GetLeaderPosition()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)leaderMaster))
			{
				return null;
			}
			CharacterBody body = leaderMaster.GetBody();
			if (!Object.op_Implicit((Object)(object)body))
			{
				return null;
			}
			return body.corePosition;
		}

		private Vector3? GetAnyRoguePosition()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			foreach (CharacterMaster rogueMaster in rogueMasters)
			{
				if (Object.op_Implicit((Object)(object)rogueMaster))
				{
					CharacterBody body = rogueMaster.GetBody();
					if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
					{
						return body.corePosition;
					}
				}
			}
			return null;
		}

		private Vector3? GetAnyPlayerPosition()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (PlayerCharacterMasterController.instances == null || PlayerCharacterMasterController.instances.Count == 0)
			{
				return null;
			}
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.master))
				{
					CharacterBody body = instance.master.GetBody();
					if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
					{
						return body.corePosition;
					}
				}
			}
			return null;
		}
	}
	public static class RogueFormation
	{
		public static Dictionary<CharacterMaster, Vector3> ComputeFormationPositions(RogueFormationType type, Vector3 anchor, Vector3 forward, List<CharacterMaster> members, CharacterMaster leader)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<CharacterMaster, Vector3> dictionary = new Dictionary<CharacterMaster, Vector3>();
			if (members == null || members.Count == 0)
			{
				return dictionary;
			}
			List<Vector3> list = ComputeOffsets(type, members.Count);
			for (int i = 0; i < members.Count; i++)
			{
				CharacterMaster val = members[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					Vector3 val2 = list[i];
					Vector3 val3 = Quaternion.LookRotation(forward) * val2;
					dictionary[val] = anchor + val3;
				}
			}
			return dictionary;
		}

		private static List<Vector3> ComputeOffsets(RogueFormationType type, int count)
		{
			return type switch
			{
				RogueFormationType.Line => ComputeLineOffsets(count), 
				RogueFormationType.Square => ComputeSquareOffsets(count), 
				RogueFormationType.Wedge => ComputeWedgeOffsets(count), 
				RogueFormationType.Circle => ComputeCircleOffsets(count), 
				RogueFormationType.LeaderSquare => ComputeLeaderSquareOffsets(count), 
				_ => ComputeLineOffsets(count), 
			};
		}

		private static List<Vector3> ComputeLineOffsets(int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			list.Add(new Vector3(0f, 0f, 2f));
			float num = 2.5f;
			for (int i = 1; i < count; i++)
			{
				float num2 = (float)(i - 1) * num - (float)(count - 2) * num * 0.5f;
				list.Add(new Vector3(num2, 0f, 0f));
			}
			return list;
		}

		private static List<Vector3> ComputeSquareOffsets(int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			list.Add(new Vector3(0f, 0f, 2f));
			int num = count - 1;
			int num2 = Mathf.CeilToInt(Mathf.Sqrt((float)num));
			float num3 = 2.5f;
			for (int i = 0; i < num; i++)
			{
				int num4 = i / num2;
				int num5 = i % num2;
				float num6 = ((float)num5 - (float)(num2 - 1) * 0.5f) * num3;
				float num7 = (0f - (float)(num4 + 1)) * num3;
				list.Add(new Vector3(num6, 0f, num7));
			}
			return list;
		}

		private static List<Vector3> ComputeWedgeOffsets(int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			list.Add(new Vector3(0f, 0f, 2f));
			float num = 2.5f;
			int num2 = 1;
			int num3 = 1;
			for (int i = 1; i < count; i++)
			{
				if (i % 2 == 1)
				{
					list.Add(new Vector3((0f - (float)num2) * num, 0f, (0f - (float)num2) * num));
					num2++;
				}
				else
				{
					list.Add(new Vector3((float)num3 * num, 0f, (0f - (float)num3) * num));
					num3++;
				}
			}
			return list;
		}

		private static List<Vector3> ComputeCircleOffsets(int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			list.Add(new Vector3(0f, 0f, 3f));
			float num = 4f;
			int num2 = count - 1;
			for (int i = 0; i < num2; i++)
			{
				float num3 = 360f / (float)num2 * (float)i;
				float num4 = num3 * ((float)Math.PI / 180f);
				float num5 = Mathf.Cos(num4) * num;
				float num6 = Mathf.Sin(num4) * num;
				list.Add(new Vector3(num5, 0f, num6));
			}
			return list;
		}

		private static List<Vector3> ComputeLeaderSquareOffsets(int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			list.Add(new Vector3(0f, 0f, 3f));
			int num = count - 1;
			int num2 = Mathf.CeilToInt(Mathf.Sqrt((float)num));
			float num3 = 2.5f;
			for (int i = 0; i < num; i++)
			{
				int num4 = i / num2;
				int num5 = i % num2;
				float num6 = ((float)num5 - (float)(num2 - 1) * 0.5f) * num3;
				float num7 = (0f - (float)(num4 + 1)) * num3;
				list.Add(new Vector3(num6, 0f, num7));
			}
			return list;
		}
	}
	public enum RogueFormationType
	{
		Line,
		Square,
		Wedge,
		Circle,
		LeaderSquare
	}
	public static class RogueHostility
	{
		public static void ApplyCustomHostility(BaseAI ai, TeamIndex rogueTeam)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ai == (Object)null) && !((Object)(object)ai.master == (Object)null))
			{
				ai.master.teamIndex = rogueTeam;
				ai.enemyAttention = ai.enemyAttentionDuration;
				ai.prioritizePlayers = false;
				ai.neverRetaliateFriendlies = false;
			}
		}
	}
	public static class RogueOrders
	{
		public static void IssueLeaderFormationOrder(RogueFormationType type)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RogueDirector.instance == (Object)null)
			{
				Debug.LogWarning((object)"[RogueOrders] No RogueDirector instance.");
				return;
			}
			if (!RogueDirector.instance.HasLeader)
			{
				Debug.LogWarning((object)"[RogueOrders] No Rogue leader to issue formation order.");
				return;
			}
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			if (orCreateSquad.Members.Count == 0)
			{
				Debug.LogWarning((object)"[RogueOrders] Squad has no members.");
				return;
			}
			CharacterMaster leader = orCreateSquad.Leader;
			if (!Object.op_Implicit((Object)(object)leader))
			{
				Debug.LogWarning((object)"[RogueOrders] Squad leader is null.");
				return;
			}
			CharacterBody body = leader.GetBody();
			if (!Object.op_Implicit((Object)(object)body))
			{
				Debug.LogWarning((object)"[RogueOrders] Leader body is null.");
				return;
			}
			Vector3 corePosition = body.corePosition;
			Vector3 forward = ((Component)body).transform.forward;
			List<CharacterMaster> members = orCreateSquad.Members;
			Dictionary<CharacterMaster, Vector3> dictionary = RogueFormation.ComputeFormationPositions(type, corePosition, forward, members, leader);
			if (dictionary == null || dictionary.Count == 0)
			{
				Debug.LogWarning((object)"[RogueOrders] Formation returned no positions.");
				return;
			}
			CharacterMaster val = FindRoguePlayerMaster();
			Vector3 val2 = Vector3.zero;
			bool flag = false;
			foreach (KeyValuePair<CharacterMaster, Vector3> item in dictionary)
			{
				CharacterMaster key = item.Key;
				Vector3 value = item.Value;
				if (!Object.op_Implicit((Object)(object)key))
				{
					continue;
				}
				if (Object.op_Implicit((Object)(object)val) && (Object)(object)key == (Object)(object)val)
				{
					val2 = value;
					flag = true;
					continue;
				}
				CharacterBody body2 = key.GetBody();
				if (Object.op_Implicit((Object)(object)body2))
				{
					RogueTacticalAI component = ((Component)body2).GetComponent<RogueTacticalAI>();
					if ((Object)(object)component != (Object)null)
					{
						component.SetFormationPosition(value);
					}
				}
			}
			if (flag)
			{
				SpawnFormationPing(val2);
				Debug.Log((object)$"[RogueOrders] Leader issued {type} formation. Player slot at {val2}.");
			}
			else
			{
				Debug.Log((object)$"[RogueOrders] Leader issued {type} formation. No player in squad to ping.");
			}
		}

		public static CharacterMaster FindRoguePlayerMaster()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			CharacterMaster result;
			if (PlayerCharacterMasterController.instances == null)
			{
				result = null;
			}
			else
			{
				foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
				{
					if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.master))
					{
						CharacterMaster master = instance.master;
						if (master.teamIndex == RogueTeamPlugin.RogueTeam)
						{
							return master;
						}
					}
				}
				result = null;
			}
			return result;
		}

		private static void SpawnFormationPing(Vector3 position)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = Resources.Load<GameObject>("Prefabs/Effects/GenericPingEffect");
			if (Object.op_Implicit((Object)(object)val))
			{
				EffectData val2 = new EffectData
				{
					origin = position
				};
				EffectManager.SpawnEffect(val, val2, true);
			}
			Chat.AddMessage("<color=#00FFFF>Move to formation position!</color>");
		}
	}
	public class RoguePersistence : MonoBehaviour
	{
		public static RoguePersistence instance;

		private readonly List<CharacterMaster> survivors = new List<CharacterMaster>();

		public IReadOnlyList<CharacterMaster> SurvivorList => survivors;

		public static void Init()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			if (RogueArtifact.Enabled)
			{
				if (!Object.op_Implicit((Object)(object)instance))
				{
					GameObject val = new GameObject("RoguePersistence");
					instance = val.AddComponent<RoguePersistence>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				SceneDef sceneDefFromSceneName = SceneCatalog.GetSceneDefFromSceneName(((Scene)(ref scene)).name);
				if (Object.op_Implicit((Object)(object)sceneDefFromSceneName) && (int)sceneDefFromSceneName.sceneType == 1)
				{
					instance.RestoreSurvivors();
				}
			}
		}

		public static void CollectBeforeStageEnd()
		{
			if (Object.op_Implicit((Object)(object)instance))
			{
				instance.CollectSurvivors();
			}
		}

		private void CollectSurvivors()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			survivors.Clear();
			RogueDirector.ClearRogues();
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			foreach (CharacterMaster member in orCreateSquad.Members)
			{
				if (Object.op_Implicit((Object)(object)member))
				{
					CharacterBody body = member.GetBody();
					if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
					{
						survivors.Add(member);
					}
				}
			}
			Debug.Log((object)$"[Rogue] Collected {survivors.Count} surviving rogues for persistence.");
		}

		private void RestoreSurvivors()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (survivors.Count == 0)
			{
				Debug.Log((object)"[Rogue] No rogues to restore.");
				return;
			}
			SceneInfo val = SceneInfo.instance;
			if (!Object.op_Implicit((Object)(object)val))
			{
				Debug.LogWarning((object)"[Rogue] SceneInfo missing during restore.");
				return;
			}
			NodeGraph nodeGraph = val.GetNodeGraph((GraphType)0);
			if (!Object.op_Implicit((Object)(object)nodeGraph))
			{
				Debug.LogWarning((object)"[Rogue] Ground node graph missing during restore.");
				return;
			}
			if (!TryGetAlivePlayerPosition(out var position))
			{
				Debug.LogWarning((object)"[Rogue] No player anchor found for restore.");
				return;
			}
			if (!FindFurthestNode(nodeGraph, position, out var position2))
			{
				Debug.LogWarning((object)"[Rogue] Could not find furthest node for restore.");
				return;
			}
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeamPlugin.RogueTeam);
			foreach (CharacterMaster survivor in survivors)
			{
				if (!Object.op_Implicit((Object)(object)survivor))
				{
					continue;
				}
				CharacterBody body = survivor.GetBody();
				if (!Object.op_Implicit((Object)(object)body))
				{
					continue;
				}
				((Component)body).transform.position = position2;
				HealthComponent healthComponent = body.healthComponent;
				if (Object.op_Implicit((Object)(object)healthComponent))
				{
					float num = ((healthComponent.fullHealth > 0f) ? (healthComponent.health / healthComponent.fullHealth) : 1f);
					if (num < 0.4f)
					{
						healthComponent.health = healthComponent.fullHealth * 0.4f;
					}
				}
				RogueDirector.RegisterExistingRogue(survivor);
				orCreateSquad.AddMember(survivor);
			}
			Debug.Log((object)$"[Rogue] Restored {survivors.Count} rogues on new stage.");
			survivors.Clear();
		}

		private bool FindFurthestNode(NodeGraph graph, Vector3 anchor, out Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			position = anchor;
			bool flag = false;
			float num = 0f;
			int nodeCount = graph.GetNodeCount();
			NodeIndex val = default(NodeIndex);
			Vector3 val2 = default(Vector3);
			NodeFlags flags = default(NodeFlags);
			for (int i = 0; i < nodeCount; i++)
			{
				((NodeIndex)(ref val))..ctor(i);
				if (graph.GetNodePosition(val, ref val2) && graph.GetNodeFlags(val, ref flags) && IsNodeValidForRogue(flags))
				{
					float num2 = Vector3.Distance(anchor, val2);
					if (!flag || num2 > num)
					{
						num = num2;
						position = val2;
						flag = true;
					}
				}
			}
			return flag;
		}

		private bool IsNodeValidForRogue(NodeFlags flags)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			if ((Object)(object)RogueSpawnCard.RogueCard == (Object)null)
			{
				return true;
			}
			NodeFlags requiredFlags = ((SpawnCard)RogueSpawnCard.RogueCard).requiredFlags;
			NodeFlags forbiddenFlags = ((SpawnCard)RogueSpawnCard.RogueCard).forbiddenFlags;
			if ((flags & forbiddenFlags) > 0)
			{
				return false;
			}
			if ((int)requiredFlags != 0 && (flags & requiredFlags) == 0)
			{
				return false;
			}
			return true;
		}

		private bool TryGetAlivePlayerPosition(out Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			if (PlayerCharacterMasterController.instances == null || PlayerCharacterMasterController.instances.Count == 0)
			{
				return false;
			}
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.master))
				{
					CharacterBody body = instance.master.GetBody();
					if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
					{
						position = body.corePosition;
						return true;
					}
				}
			}
			return false;
		}
	}
	public static class RogueReputation
	{
		public static bool PlayerAttackedRogues;

		public static bool RoguesAttackedPlayer;

		public static float PeaceTimer;

		public static bool OfferShown;

		public static float OfferTimer;

		public const float OfferDuration = 30f;

		public static bool IsEligible => !PlayerAttackedRogues && !RoguesAttackedPlayer;

		public static void Reset()
		{
			PlayerAttackedRogues = false;
			RoguesAttackedPlayer = false;
			PeaceTimer = 0f;
			OfferShown = false;
			OfferTimer = 0f;
		}

		public static void Update(float deltaTime)
		{
			if (!IsEligible)
			{
				return;
			}
			if (OfferShown)
			{
				OfferTimer += deltaTime;
				if (OfferTimer >= 30f)
				{
					OfferShown = false;
					Chat.AddMessage("<color=#00FFAA>[Rogue]</color> The offer has expired.");
				}
				return;
			}
			PeaceTimer += deltaTime;
			if (PeaceTimer >= 180f && !OfferShown)
			{
				OfferShown = true;
				OfferTimer = 0f;
				Chat.AddMessage("<color=#00FFAA>[Rogue]</color> You have shown restraint. Join the Rogue Faction? Type: <color=#00FFAA>/joinrogue</color>");
			}
		}
	}
	public static class RogueSpawnCard
	{
		public static CharacterSpawnCard RogueCard;

		public static DirectorCardCategorySelection RogueDCCS;

		public static CharacterSpawnCard CaptainCard;

		public static void Init()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			RogueCard = ScriptableObject.CreateInstance<CharacterSpawnCard>();
			((Object)RogueCard).name = "cscRogueUnit";
			((SpawnCard)RogueCard).prefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Commando/CommandoMonsterMaster.prefab").WaitForCompletion();
			((SpawnCard)RogueCard).sendOverNetwork = true;
			((SpawnCard)RogueCard).hullSize = (HullClassification)0;
			((SpawnCard)RogueCard).nodeGraphType = (GraphType)0;
			((SpawnCard)RogueCard).requiredFlags = (NodeFlags)0;
			((SpawnCard)RogueCard).forbiddenFlags = (NodeFlags)4;
			((SpawnCard)RogueCard).directorCreditCost = 20;
			((SpawnCard)RogueCard).occupyPosition = false;
			RogueCard.noElites = true;
			RogueDCCS = ScriptableObject.CreateInstance<DirectorCardCategorySelection>();
			((Object)RogueDCCS).name = "dccsRogueUnits";
			RogueDCCS.AddCategory("RogueUnits", 1f);
			RogueDCCS.AddCard(0, new DirectorCard
			{
				spawnCard = (SpawnCard)(object)RogueCard,
				selectionWeight = 1,
				preventOverhead = false,
				minimumStageCompletions = 0
			});
			CaptainCard = ScriptableObject.CreateInstance<CharacterSpawnCard>();
			((Object)CaptainCard).name = "cscRogueCaptain";
			((SpawnCard)CaptainCard).prefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Captain/CaptainMonsterMaster.prefab").WaitForCompletion();
			((SpawnCard)CaptainCard).sendOverNetwork = true;
			((SpawnCard)CaptainCard).hullSize = (HullClassification)0;
			((SpawnCard)CaptainCard).nodeGraphType = (GraphType)0;
			((SpawnCard)CaptainCard).requiredFlags = (NodeFlags)0;
			((SpawnCard)CaptainCard).forbiddenFlags = (NodeFlags)4;
			((SpawnCard)CaptainCard).directorCreditCost = 0;
			((SpawnCard)CaptainCard).occupyPosition = false;
			CaptainCard.noElites = true;
			Debug.Log((object)"[Rogue] RogueSpawnCard + RogueDCCS + CaptainCard initialized.");
		}
	}
	public class RogueSquad
	{
		private static readonly Dictionary<TeamIndex, RogueSquad> squads = new Dictionary<TeamIndex, RogueSquad>();

		public readonly List<CharacterMaster> Members = new List<CharacterMaster>();

		public HurtBox SharedTarget;

		public TeamIndex Team { get; private set; }

		public CharacterMaster Leader { get; private set; }

		public bool HasLeader
		{
			get
			{
				if ((Object)(object)Leader == (Object)null)
				{
					return false;
				}
				CharacterBody body = Leader.GetBody();
				return (Object)(object)body != (Object)null && (Object)(object)body.healthComponent != (Object)null && body.healthComponent.alive;
			}
		}

		public static RogueSquad GetOrCreateSquad(TeamIndex team)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!squads.TryGetValue(team, out var value))
			{
				value = new RogueSquad(team);
				squads[team] = value;
			}
			return value;
		}

		public static void RemoveFromSquad(CharacterMaster master, TeamIndex team)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (squads.TryGetValue(team, out var value))
			{
				value.RemoveMember(master);
			}
		}

		public void SetLeader(CharacterMaster master)
		{
			Leader = master;
		}

		public RogueSquad(TeamIndex team)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Team = team;
		}

		public void AddMember(CharacterMaster master)
		{
			if (!((Object)(object)master == (Object)null) && !Members.Contains(master))
			{
				Members.Add(master);
			}
		}

		public void RemoveMember(CharacterMaster master)
		{
			if (!((Object)(object)master == (Object)null))
			{
				Members.Remove(master);
				if ((Object)(object)Leader == (Object)(object)master)
				{
					Leader = null;
					EnsureLeader();
				}
			}
		}

		public void EnsureLeader()
		{
			if (HasLeader)
			{
				return;
			}
			Leader = null;
			foreach (CharacterMaster member in Members)
			{
				if (Object.op_Implicit((Object)(object)member))
				{
					CharacterBody body = member.GetBody();
					if ((Object)(object)body != (Object)null && (Object)(object)body.healthComponent != (Object)null && body.healthComponent.alive)
					{
						Leader = member;
						break;
					}
				}
			}
		}

		public Vector3 GetLeaderPosition()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (HasLeader)
			{
				return Leader.GetBody().corePosition;
			}
			if (Members.Count == 0)
			{
				return Vector3.zero;
			}
			Vector3 val = Vector3.zero;
			int num = 0;
			foreach (CharacterMaster member in Members)
			{
				CharacterBody body = member.GetBody();
				if ((Object)(object)body != (Object)null)
				{
					val += body.corePosition;
					num++;
				}
			}
			return (num > 0) ? (val / (float)num) : Vector3.zero;
		}

		public int GetAliveCount()
		{
			int num = 0;
			foreach (CharacterMaster member in Members)
			{
				CharacterBody body = member.GetBody();
				if ((Object)(object)body != (Object)null && (Object)(object)body.healthComponent != (Object)null && body.healthComponent.alive)
				{
					num++;
				}
			}
			return num;
		}

		public void OrderHoldPosition(Vector3 pos)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			foreach (CharacterMaster member in Members)
			{
				if (Object.op_Implicit((Object)(object)member))
				{
					RogueTacticalAI component = ((Component)member).GetComponent<RogueTacticalAI>();
					if ((Object)(object)component != (Object)null)
					{
						component.SetHoldPosition(pos);
					}
				}
			}
		}

		public void OrderFlank(HurtBox target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			SharedTarget = target;
			for (int i = 0; i < Members.Count; i++)
			{
				CharacterMaster val = Members[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					RogueTacticalAI component = ((Component)val).GetComponent<RogueTacticalAI>();
					if (!((Object)(object)component == (Object)null))
					{
						bool leftSide = i % 2 == 0;
						component.SetFlankTarget(target, leftSide);
					}
				}
			}
		}
	}
	public class RogueTacticalAI : MonoBehaviour
	{
		private CharacterMaster master;

		private CharacterBody body;

		private BaseAI baseAI;

		private RogueSquad squad;

		private bool holdingPosition = false;

		private Vector3 holdPosition;

		private bool isFlanking = false;

		private bool flankLeft = false;

		private HurtBox flankTarget;

		private Vector3? formationTarget = null;

		private float formationCheckTimer = 0f;

		private int originalSquadSize = 0;

		private static readonly HashSet<CharacterMaster> roguePlayers = new HashSet<CharacterMaster>();

		public static void RegisterRoguePlayer(CharacterMaster master)
		{
			if ((Object)(object)master != (Object)null)
			{
				roguePlayers.Add(master);
			}
		}

		public void Init(RogueSquad squad)
		{
			this.squad = squad;
			master = ((Component)this).GetComponent<CharacterMaster>();
			if (!Object.op_Implicit((Object)(object)master))
			{
				CharacterBody component = ((Component)this).GetComponent<CharacterBody>();
				master = (Object.op_Implicit((Object)(object)component) ? component.master : null);
			}
			if (Object.op_Implicit((Object)(object)master))
			{
				body = master.GetBody();
				baseAI = ((Component)master).GetComponent<BaseAI>();
				if (!Object.op_Implicit((Object)(object)baseAI))
				{
					baseAI = ((Component)master).gameObject.AddComponent<BaseAI>();
				}
				if (squad != null && squad.Members != null && squad.Members.Count > 0)
				{
					originalSquadSize = Mathf.Max(originalSquadSize, squad.Members.Count);
				}
			}
		}

		private void FixedUpdate()
		{
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)body == (Object)null || (Object)(object)baseAI == (Object)null)
			{
				return;
			}
			bool flag = squad != null && (Object)(object)squad.Leader == (Object)(object)master;
			bool hasEnemy = false;
			bool surrounded = false;
			bool closeEnemy = false;
			bool midEnemy = false;
			if (squad != null && (Object)(object)squad.Leader != (Object)null)
			{
				CharacterBody val = squad.Leader.GetBody();
				if (Object.op_Implicit((Object)(object)val))
				{
					GetSquadEnemyInfo(val, out hasEnemy, out surrounded, out closeEnemy, out midEnemy);
				}
			}
			if (flag)
			{
				if (!hasEnemy && !holdingPosition && !isFlanking)
				{
					RogueOrders.IssueLeaderFormationOrder(RogueFormationType.LeaderSquare);
					Vector3 val2 = (Object.op_Implicit((Object)(object)body.inputBank) ? body.inputBank.aimDirection : ((Component)body).transform.forward);
					Vector3 targetPosition = body.corePosition + val2 * 8f;
					baseAI.localNavigator.targetPosition = targetPosition;
				}
				formationCheckTimer += Time.fixedDeltaTime;
				if (formationCheckTimer >= 5f)
				{
					formationCheckTimer = 0f;
					TryIssueFormationOrder();
				}
			}
			if (isFlanking && (Object)(object)flankTarget != (Object)null)
			{
				Vector3 position = ((Component)flankTarget).transform.position;
				Vector3 val3 = position - body.corePosition;
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				Vector3 val4 = Vector3.Cross(Vector3.up, normalized);
				Vector3 val5 = position + val4 * (flankLeft ? (-12f) : 12f);
				baseAI.localNavigator.targetPosition = val5;
				if (Vector3.Distance(body.corePosition, val5) < 5f)
				{
					isFlanking = false;
				}
				return;
			}
			if (holdingPosition)
			{
				baseAI.localNavigator.targetPosition = holdPosition;
				body.isSprinting = false;
				return;
			}
			if (formationTarget.HasValue)
			{
				float num = Vector3.Distance(body.corePosition, formationTarget.Value);
				if (num > 3f)
				{
					baseAI.localNavigator.targetPosition = formationTarget.Value;
					return;
				}
			}
			if (squad == null || !((Object)(object)squad.Leader != (Object)null) || !((Object)(object)squad.Leader != (Object)(object)master))
			{
				return;
			}
			CharacterBody val6 = squad.Leader.GetBody();
			if (Object.op_Implicit((Object)(object)val6))
			{
				if (!hasEnemy && formationTarget.HasValue)
				{
					baseAI.localNavigator.targetPosition = formationTarget.Value;
				}
				else
				{
					baseAI.localNavigator.targetPosition = val6.corePosition;
				}
			}
		}

		public void SetFormationPosition(Vector3 pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			formationTarget = pos;
			holdingPosition = false;
			isFlanking = false;
		}

		public void SetHoldPosition(Vector3 pos)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			holdingPosition = true;
			holdPosition = pos;
			formationTarget = null;
			isFlanking = false;
		}

		public void ClearHoldPosition()
		{
			holdingPosition = false;
		}

		public void SetFlankTarget(HurtBox target, bool leftSide)
		{
			flankTarget = target;
			flankLeft = leftSide;
			isFlanking = true;
			holdingPosition = false;
			formationTarget = null;
		}

		private void TryIssueFormationOrder()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (squad == null || squad.Members.Count <= 1)
			{
				return;
			}
			CharacterBody val = body;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			if (originalSquadSize <= 0)
			{
				originalSquadSize = squad.Members.Count;
			}
			int count = squad.Members.Count;
			int num = Mathf.Max(1, Mathf.CeilToInt((float)originalSquadSize * 0.5f));
			bool flag = count < num;
			Vector3 corePosition = val.corePosition;
			float num2 = 0f;
			foreach (CharacterMaster member in squad.Members)
			{
				if (!Object.op_Implicit((Object)(object)member))
				{
					continue;
				}
				CharacterBody val2 = member.GetBody();
				if (Object.op_Implicit((Object)(object)val2))
				{
					float num3 = Vector3.Distance(corePosition, val2.corePosition);
					if (num3 > num2)
					{
						num2 = num3;
					}
				}
			}
			bool flag2 = false;
			CharacterMaster val3 = RogueOrders.FindRoguePlayerMaster();
			if (Object.op_Implicit((Object)(object)val3))
			{
				CharacterBody val4 = val3.GetBody();
				if (Object.op_Implicit((Object)(object)val4))
				{
					float num4 = Vector3.Distance(corePosition, val4.corePosition);
					if (num4 > 30f)
					{
						flag2 = true;
					}
				}
			}
			GetSquadEnemyInfo(val, out var hasEnemy, out var surrounded, out var closeEnemy, out var midEnemy);
			if (Object.op_Implicit((Object)(object)val.healthComponent) && val.healthComponent.health / val.healthComponent.fullHealth < 0.35f)
			{
				flag = true;
			}
			if (flag)
			{
				if (!hasEnemy)
				{
					if (num2 > 20f || flag2)
					{
						RogueOrders.IssueLeaderFormationOrder(RogueFormationType.LeaderSquare);
					}
				}
				else
				{
					RogueOrders.IssueLeaderFormationOrder(RogueFormationType.Circle);
				}
			}
			else if (!hasEnemy)
			{
				if (num2 > 25f || flag2)
				{
					RogueOrders.IssueLeaderFormationOrder(RogueFormationType.LeaderSquare);
				}
			}
			else if (surrounded)
			{
				RogueOrders.IssueLeaderFormationOrder(RogueFormationType.Circle);
			}
			else if (closeEnemy)
			{
				RogueOrders.IssueLeaderFormationOrder(RogueFormationType.Wedge);
			}
			else if (midEnemy)
			{
				RogueOrders.IssueLeaderFormationOrder(RogueFormationType.Line);
			}
		}

		private void GetSquadEnemyInfo(CharacterBody leaderBody, out bool hasEnemy, out bool surrounded, out bool closeEnemy, out bool midEnemy)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			hasEnemy = false;
			surrounded = false;
			closeEnemy = false;
			midEnemy = false;
			if (squad == null || squad.Members == null || squad.Members.Count == 0)
			{
				return;
			}
			List<Vector3> list = new List<Vector3>();
			foreach (CharacterMaster member in squad.Members)
			{
				if (!Object.op_Implicit((Object)(object)member))
				{
					continue;
				}
				CharacterBody val = member.GetBody();
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				BullseyeSearch val2 = new BullseyeSearch
				{
					teamMaskFilter = TeamMask.GetUnprotectedTeams(RogueTeamPlugin.RogueTeam),
					maxDistanceFilter = 60f,
					searchOrigin = val.corePosition,
					searchDirection = (Object.op_Implicit((Object)(object)val.inputBank) ? val.inputBank.aimDirection : ((Component)val).transform.forward),
					filterByLoS = true,
					sortMode = (SortMode)1
				};
				val2.RefreshCandidates();
				foreach (HurtBox result in val2.GetResults())
				{
					if (!Object.op_Implicit((Object)(object)result) || (Object)(object)result.healthComponent == (Object)null || (Object)(object)result.healthComponent.body == (Object)null)
					{
						continue;
					}
					CharacterBody val3 = result.healthComponent.body;
					hasEnemy = true;
					float num = Vector3.Distance(val.corePosition, val3.corePosition);
					if (num <= 25f)
					{
						closeEnemy = true;
					}
					else if (num <= 40f)
					{
						midEnemy = true;
					}
					if (Object.op_Implicit((Object)(object)leaderBody))
					{
						Vector3 val4 = val3.corePosition - leaderBody.corePosition;
						Vector3 normalized = ((Vector3)(ref val4)).normalized;
						list.Add(normalized);
					}
					break;
				}
			}
			if (list.Count < 2)
			{
				return;
			}
			float num2 = 0f;
			for (int i = 0; i < list.Count; i++)
			{
				for (int j = i + 1; j < list.Count; j++)
				{
					float num3 = Vector3.Angle(list[i], list[j]);
					if (num3 > num2)
					{
						num2 = num3;
					}
				}
			}
			if (num2 >= 120f)
			{
				surrounded = true;
			}
		}
	}
	public static class RogueTeamDef
	{
		public static TeamIndex CreateTeam()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			TeamDef val = new TeamDef
			{
				nameToken = "ROGUE_TEAM"
			};
			TeamBehavior val2 = new TeamBehavior("ROGUE_TEAM", (TeamClassification)4);
			TeamIndex result = TeamsAPI.RegisterTeam(val, val2);
			Debug.Log((object)("[Rogue] Registered custom team via TeamsAPI: " + ((object)(TeamIndex)(ref result)).ToString()));
			return result;
		}
	}
	[BepInPlugin("com.dad.rogueteam", "Rogue Team Tactical AI", "1.0.0")]
	public class RogueTeamPlugin : BaseUnityPlugin
	{
		public static TeamIndex RogueTeam;

		private void Awake()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			RogueTeam = RogueTeamDef.CreateTeam();
			LanguageAPI.Add("NEW_FRIENDS_ACHIEVEMENT_NAME", "New Friends");
			LanguageAPI.Add("NEW_FRIENDS_ACHIEVEMENT_DESC", "You brought some friends along, yeah? Kept you waiting, huh.");
			LanguageAPI.Add("NEW_FRIENDS_UNLOCKABLE_NAME", "New Friends");
			RogueArtifact.Init();
			RogueSpawnCard.Init();
			RogueDirector.Init();
			CharacterBody.onBodyStartGlobal += OnBodyStart;
			GlobalEventManager.onCharacterDeathGlobal += OnCharacterDeath;
			GlobalEventManager.onServerDamageDealt += OnDamageDealt;
			TeleporterInteraction.onTeleporterChargedGlobal += OnTeleporterCharged;
			Run.onRunStartGlobal += delegate
			{
				RogueReputation.Reset();
			};
			Stage.onServerStageBegin += OnStageBegin;
			Run.onClientGameOverGlobal += OnGameOver;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Rogue] Plugin initialized.");
		}

		private void OnBodyStart(CharacterBody body)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (!RogueArtifact.Enabled || !Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)body.master) || !Object.op_Implicit((Object)(object)body.teamComponent) || body.teamComponent.teamIndex != RogueTeam)
			{
				return;
			}
			RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeam);
			if (body.isPlayerControlled)
			{
				RogueTacticalAI.RegisterRoguePlayer(body.master);
				return;
			}
			orCreateSquad.AddMember(body.master);
			if (!orCreateSquad.HasLeader)
			{
				orCreateSquad.SetLeader(body.master);
				if (body.bodyIndex != BodyCatalog.FindBodyIndex("CaptainBody"))
				{
					TransformLeaderIntoCaptain(body.master);
					return;
				}
			}
			BaseAI val = ((Component)body.master).GetComponent<BaseAI>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = ((Component)body.master).gameObject.AddComponent<BaseAI>();
			}
			RogueHostility.ApplyCustomHostility(val, RogueTeam);
			RogueTacticalAI rogueTacticalAI = ((Component)body.master).GetComponent<RogueTacticalAI>();
			if (!Object.op_Implicit((Object)(object)rogueTacticalAI))
			{
				rogueTacticalAI = ((Component)body.master).gameObject.AddComponent<RogueTacticalAI>();
			}
			rogueTacticalAI.Init(orCreateSquad);
		}

		private void OnCharacterDeath(DamageReport report)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (RogueArtifact.Enabled)
			{
				CharacterMaster val = (Object.op_Implicit((Object)(object)report?.victimBody) ? report.victimBody.master : null);
				if ((Object)(object)val != (Object)null)
				{
					RogueSquad.RemoveFromSquad(val, report.victimBody.teamComponent.teamIndex);
				}
			}
		}

		private void OnDamageDealt(DamageReport report)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (report == null)
			{
				return;
			}
			CharacterBody attackerBody = report.attackerBody;
			CharacterBody victimBody = report.victimBody;
			if (Object.op_Implicit((Object)(object)attackerBody) && Object.op_Implicit((Object)(object)victimBody))
			{
				if (attackerBody.isPlayerControlled && victimBody.teamComponent.teamIndex == RogueTeam)
				{
					RogueReputation.PlayerAttackedRogues = true;
				}
				if (victimBody.isPlayerControlled && attackerBody.teamComponent.teamIndex == RogueTeam)
				{
					RogueReputation.RoguesAttackedPlayer = true;
				}
			}
		}

		private void OnTeleporterCharged(TeleporterInteraction tp)
		{
			if (RogueArtifact.Enabled && RogueReputation.IsEligible)
			{
				RogueReputation.PlayerAttackedRogues = true;
				Chat.AddMessage("<color=#00FFAA>[Rogue]</color> You have shown restraint. Join the Rogue Faction? Type: <color=#00FFAA>/joinrogue</color>");
			}
		}

		private void OnStageBegin(Stage stage)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (!RogueArtifact.Enabled)
			{
				return;
			}
			SceneDef sceneDefForCurrentScene = SceneCatalog.GetSceneDefForCurrentScene();
			if (!Object.op_Implicit((Object)(object)sceneDefForCurrentScene) || sceneDefForCurrentScene.cachedName != "moon2")
			{
				return;
			}
			CharacterBody val = null;
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				CharacterBody body = instance.master.GetBody();
				if (Object.op_Implicit((Object)(object)body) && body.teamComponent.teamIndex == RogueTeam)
				{
					val = body;
					break;
				}
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				GameObject val2 = GameObject.Find("EscapeSequenceController");
				if (Object.op_Implicit((Object)(object)val2))
				{
					RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeam);
					orCreateSquad.OrderHoldPosition(val2.transform.position);
					Chat.AddMessage("<color=#00FFAA>[Rogue]</color> Your squad is holding the ship perimeter.");
				}
			}
		}

		private void OnGameOver(Run run, RunReport report)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!RogueArtifact.Enabled || (Object)(object)report?.gameEnding == (Object)null || !report.gameEnding.isWin)
			{
				return;
			}
			bool flag = false;
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				CharacterBody body = instance.master.GetBody();
				if (Object.op_Implicit((Object)(object)body) && body.teamComponent.teamIndex == RogueTeam)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				Chat.AddMessage("<color=#00FFAA>[Rogue Epilogue]</color> ...And so they left. The survivors escaped the planet once more — with a few new 'Rogue' friends at their side.");
			}
		}

		private void TransformLeaderIntoCaptain(CharacterMaster oldMaster)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			CharacterBody oldBody = (Object.op_Implicit((Object)(object)oldMaster) ? oldMaster.GetBody() : null);
			if (!Object.op_Implicit((Object)(object)oldBody))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"[Rogue] Cannot promote leader — no body found.");
				return;
			}
			Vector3 corePosition = oldBody.corePosition;
			Quaternion rotation = ((Component)oldBody).transform.rotation;
			Inventory oldInv = oldMaster.inventory;
			DirectorPlacementRule val = new DirectorPlacementRule
			{
				placementMode = (PlacementMode)0,
				position = corePosition
			};
			DirectorSpawnRequest val2 = new DirectorSpawnRequest((SpawnCard)(object)RogueSpawnCard.CaptainCard, val, RoR2Application.rng);
			val2.onSpawnedServer = (Action<SpawnResult>)Delegate.Combine(val2.onSpawnedServer, (Action<SpawnResult>)delegate(SpawnResult result)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				if (!result.success || !Object.op_Implicit((Object)(object)result.spawnedInstance))
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"[Rogue] Captain spawn failed.");
				}
				else
				{
					CharacterMaster component = result.spawnedInstance.GetComponent<CharacterMaster>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						((BaseUnityPlugin)this).Logger.LogError((object)"[Rogue] Spawned Captain missing CharacterMaster.");
					}
					else
					{
						component.teamIndex = RogueTeam;
						if (Object.op_Implicit((Object)(object)oldInv) && Object.op_Implicit((Object)(object)component.inventory))
						{
							component.inventory.CopyItemsFrom(oldInv);
						}
						CharacterBody body = component.GetBody();
						if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.teamComponent))
						{
							body.teamComponent.teamIndex = RogueTeam;
						}
						RogueDirector.RegisterExistingRogue(component);
						RogueSquad orCreateSquad = RogueSquad.GetOrCreateSquad(RogueTeam);
						orCreateSquad.AddMember(component);
						orCreateSquad.SetLeader(component);
						if (Object.op_Implicit((Object)(object)body) && !Object.op_Implicit((Object)(object)((Component)body).GetComponent<RogueTacticalAI>()))
						{
							((Component)body).gameObject.AddComponent<RogueTacticalAI>().Init(orCreateSquad);
						}
						if (Object.op_Implicit((Object)(object)oldBody))
						{
							Object.Destroy((Object)(object)((Component)oldBody).gameObject);
						}
						if (Object.op_Implicit((Object)(object)oldMaster))
						{
							Object.Destroy((Object)(object)((Component)oldMaster).gameObject);
						}
						((BaseUnityPlugin)this).Logger.LogInfo((object)"[Rogue] Leader promoted to Captain via DirectorSpawnRequest.");
					}
				}
			});
			if (!Object.op_Implicit((Object)(object)DirectorCore.instance))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"[Rogue] DirectorCore missing — cannot spawn Captain.");
			}
			else
			{
				DirectorCore.instance.TrySpawnObject(val2);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCJoinRogue(ConCommandArgs args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody senderBody = ((ConCommandArgs)(ref args)).senderBody;
			if (Object.op_Implicit((Object)(object)senderBody))
			{
				senderBody.teamComponent.teamIndex = RogueTeam;
				if (Object.op_Implicit((Object)(object)senderBody.master))
				{
					RogueTacticalAI.RegisterRoguePlayer(senderBody.master);
				}
				Chat.AddMessage("<color=#00FFAA>[Rogue]</color> You are now part of the Rogue Faction.");
			}
		}
	}
}
namespace RogueTeamPlugin.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("RogueTeamPlugin.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal Resources()
		{
		}
	}
	[CompilerGenerated]
	[GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.11.0.0")]
	internal sealed class Settings : ApplicationSettingsBase
	{
		private static Settings defaultInstance = (Settings)(object)SettingsBase.Synchronized((SettingsBase)(object)new Settings());

		public static Settings Default => defaultInstance;
	}
}