using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using On.EntityStates;
using On.RoR2;
using On.RoR2.UI;
using R2API;
using R2API.Networking;
using R2API.Networking.Interfaces;
using R2API.Utils;
using RoR2;
using RoR2.Artifacts;
using RoR2.Stats;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPathsBetter;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Tasks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5b08c45b6bd7226a94bce6c28bd1872d0c40934d")]
[assembly: AssemblyProduct("Tasks")]
[assembly: AssemblyTitle("Tasks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Tasks
{
	internal class AirKills : Task
	{
		private int[] kills;

		private int killsNeeded = 3;

		private List<HitGroundDelegate> groundDelegateList = new List<HitGroundDelegate>();

		protected new string description { get; } = "Get 3 kills whilst airborne";


		public override TaskType type { get; } = TaskType.AirKills;


		protected override string name { get; } = "Air Kills";


		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + ".";
		}

		protected override void SetHooks(int numPlayers)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			Debug.Log((object)$"Set Hooks in AirKills. {numPlayers} players");
			base.SetHooks(numPlayers);
			kills = new int[numPlayers];
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				CharacterMaster playerCharacterMaster = TasksPlugin.GetPlayerCharacterMaster(i);
				if (playerCharacterMaster == null || playerCharacterMaster.GetBody() == null || playerCharacterMaster.GetBody().characterMotor == null)
				{
					break;
				}
				int tempInt = i;
				HitGroundDelegate item = (HitGroundDelegate)delegate
				{
					PlayerHitGround(tempInt);
				};
				groundDelegateList.Add(item);
				playerCharacterMaster.GetBody().characterMotor.onHitGround += groundDelegateList[tempInt];
			}
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				CharacterMaster playerCharacterMaster = TasksPlugin.GetPlayerCharacterMaster(i);
				if (playerCharacterMaster == null || playerCharacterMaster.GetBody() == null || playerCharacterMaster.GetBody().characterMotor == null)
				{
					break;
				}
				int index = i;
				playerCharacterMaster.GetBody().characterMotor.onHitGround -= groundDelegateList[index];
			}
			ResetAllKills();
			base.Unhook();
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = (float)kills[i] / (float)killsNeeded;
			}
			base.UpdateProgress(progress);
		}

		protected override bool IsComplete(int playerNum)
		{
			return kills[playerNum] >= killsNeeded;
		}

		public void OnKill(DamageReport damageReport)
		{
			if (damageReport == null || damageReport.attackerMaster == null || damageReport.attackerMaster.playerCharacterMasterController == null)
			{
				return;
			}
			int playerNumber = TasksPlugin.GetPlayerNumber(damageReport.attackerMaster);
			if (!damageReport.attackerMaster.GetBody().characterMotor.isGrounded)
			{
				kills[playerNumber]++;
				UpdateProgress();
				if (IsComplete(playerNumber))
				{
					CompleteTask(playerNumber);
					ResetAllKills();
				}
			}
		}

		private void PlayerHitGround(int playerNum)
		{
			UpdateProgress();
			kills[playerNum] = 0;
		}

		private void ResetAllKills()
		{
			if (kills != null)
			{
				for (int i = 0; i < kills.Length; i++)
				{
					kills[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class BabyDrone : Task
	{
		private CharacterMaster[] drones;

		private CharacterMaster createdDrone;

		private bool[] playerFailed;

		private int numPlayersFailed;

		private bool alreadyAwarded;

		public override TaskType type { get; } = TaskType.BabyDrone;


		protected override string name { get; } = "Baby Drone";


		public override bool CanActivate(int numPlayers)
		{
			return true;
		}

		public override string GetDescription()
		{
			return "Keep your drone alive";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			if (winningPlayer < 0)
			{
				return "You failed " + GetStylizedTaskName(name) + " by letting your drone die.";
			}
			return GetStylizedName(winningPlayer) + " kept their drone alive the longest. Completed " + GetStylizedTaskName(name) + ".";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in BabyDrone. {numPlayers} players");
			base.SetHooks(numPlayers);
			drones = (CharacterMaster[])(object)new CharacterMaster[numPlayers];
			playerFailed = new bool[numPlayers];
			numPlayersFailed = 0;
			alreadyAwarded = false;
			for (int i = 0; i < numPlayers; i++)
			{
				playerFailed[i] = false;
				SpawnDrone(i);
			}
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			ResetProgress();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		private void Evaluate()
		{
			if (alreadyAwarded)
			{
				return;
			}
			for (int i = 0; i < playerFailed.Length; i++)
			{
				if (!playerFailed[i])
				{
					UpdateProgressMultiWinner();
					CompleteTask(i);
				}
			}
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				if (totalNumberPlayers > 1)
				{
					progress[i] = ((!playerFailed[i]) ? (numPlayersFailed / (totalNumberPlayers - 1)) : 0);
				}
				else
				{
					progress[i] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		private void UpdateProgressMultiWinner()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = ((!playerFailed[i]) ? 1 : 0);
			}
			base.UpdateProgress(progress);
		}

		public void OnKill(DamageReport damageReport)
		{
			if (damageReport == null || damageReport.victimMaster == null)
			{
				return;
			}
			for (int i = 0; i < drones.Length; i++)
			{
				if (playerFailed[i] || !((Object)(object)damageReport.victimMaster == (Object)(object)drones[i]))
				{
					continue;
				}
				string text = $"BABY_DRONE_{i}";
				ChatMessage.Send(GetDroneDeathMessage(Language.currentLanguage.GetLocalizedStringByToken(text)));
				playerFailed[i] = true;
				numPlayersFailed++;
				UpdateProgress();
				if (totalNumberPlayers > 1)
				{
					if (numPlayersFailed < totalNumberPlayers - 1)
					{
						continue;
					}
					for (int j = 0; j < playerFailed.Length; j++)
					{
						if (!playerFailed[j])
						{
							alreadyAwarded = true;
							CompleteTask(j);
							return;
						}
					}
				}
				else
				{
					CompleteTask(-1);
				}
			}
		}

		private void SpawnDrone(int playerNum)
		{
			//IL_001c: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0048: 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)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_005e: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			CharacterBody body = TasksPlugin.GetPlayerCharacterMaster(playerNum).GetBody();
			GameObject val = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(Resources.Load<SpawnCard>("SpawnCards/InteractableSpawnCard/iscbrokendrone1"), new DirectorPlacementRule
			{
				placementMode = (PlacementMode)0,
				position = body.transform.position + new Vector3(1f, 0f, 0f)
			}, new Xoroshiro128Plus(0uL)));
			PurchaseInteraction component = val.GetComponent<PurchaseInteraction>();
			component.cost = 0;
			Interactor component2 = ((Component)body).GetComponent<Interactor>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				MasterSummon.Perform += new hook_Perform(GrabDrone);
				component.OnInteractionBegin(component2);
				MasterSummon.Perform -= new hook_Perform(GrabDrone);
				string text = $"BABY_DRONE_{playerNum}";
				Language.currentLanguage.SetStringByToken(text, GetDroneName(playerNum));
				CharacterBody body2 = createdDrone.GetBody();
				body2.baseNameToken = text;
				body2.baseRegen = 0f;
				drones[playerNum] = createdDrone;
				((MonoBehaviour)TasksPlugin.instance).StartCoroutine(DamageDrone(body2));
			}
		}

		private CharacterMaster GrabDrone(orig_Perform orig_Perform, MasterSummon self)
		{
			return createdDrone = orig_Perform.Invoke(self);
		}

		private string GetDroneName(int playerNum)
		{
			string displayName = ((Component)TasksPlugin.GetPlayerCharacterMaster(playerNum)).GetComponent<PlayerCharacterMasterController>().GetDisplayName();
			WeightedSelection<string> val = new WeightedSelection<string>(14);
			val.AddChoice(displayName + " Junior", 1f);
			val.AddChoice(displayName + " Jr.", 1f);
			val.AddChoice("Baby " + displayName, 1f);
			val.AddChoice("Little " + displayName, 1f);
			val.AddChoice("Li'l " + displayName, 1f);
			val.AddChoice(displayName + " the Second", 1f);
			val.AddChoice(displayName + " the Third", 1f);
			val.AddChoice(displayName + " II", 1f);
			val.AddChoice(displayName + " III", 1f);
			val.AddChoice(displayName + " the Younger", 1f);
			val.AddChoice("Mini " + displayName, 1f);
			val.AddChoice(displayName + " Mk II", 1f);
			val.AddChoice(displayName + " 2.0", 1f);
			val.AddChoice(displayName + " (Clone)", 1f);
			return val.Evaluate(Random.value);
		}

		private string GetDroneDeathMessage(string droneName)
		{
			WeightedSelection<string> val = new WeightedSelection<string>(8);
			val.AddChoice(droneName + " died. And it was all your fault.", 1f);
			val.AddChoice(droneName + " died. And you just let it happen.", 1f);
			val.AddChoice(droneName + " died because you didn't love him enough.", 1f);
			val.AddChoice(droneName + " died. Play on an easier difficulty so this doesn't happen again.", 1f);
			val.AddChoice("You killed " + droneName + ". You monster.", 1f);
			val.AddChoice("You let " + droneName + " die. You monster.", 1f);
			val.AddChoice("You let " + droneName + " die. What did he ever do to you?", 1f);
			val.AddChoice(droneName + " said goodbye. When he died.", 1f);
			val.AddChoice(droneName + " died. You can repair him, but it won't be the same " + droneName + ".", 1f);
			val.AddChoice(droneName + " has went to a junkyard in the country.", 1f);
			val.AddChoice(droneName + " has went to a junkyard in the country.", 1f);
			val.AddChoice("MISSION FAILURE! " + droneName + " has been lost.", 1f);
			val.AddChoice("Well, " + droneName + " has been lost. Hope you're happy", 1f);
			val.AddChoice("Well, " + droneName + " is gone. Hope you're happy", 1f);
			val.AddChoice(droneName + " has gone and there shall never be another like him.", 1f);
			val.AddChoice("RIP " + droneName + ", the goodest boy.", 1f);
			val.AddChoice("RIP " + droneName + ".", 1f);
			val.AddChoice("At least " + droneName + " didn't suffer.", 1f);
			val.AddChoice(droneName + " deserved better.", 1f);
			return "<style=cDeath><sprite name=\"Skull\" tint=1> " + val.Evaluate(Random.value) + " <sprite name=\"Skull\" tint=1></style>";
		}

		private IEnumerator DamageDrone(CharacterBody droneBody)
		{
			yield return (object)new WaitForSeconds(1f);
			DamageInfo damageInfo = new DamageInfo
			{
				damage = droneBody.healthComponent.combinedHealth,
				position = droneBody.corePosition,
				force = Vector3.zero,
				damageColorIndex = (DamageColorIndex)0,
				crit = false,
				attacker = null,
				inflictor = null,
				damageType = DamageTypeCombo.op_Implicit((DamageType)3),
				procCoefficient = 0f,
				procChainMask = default(ProcChainMask)
			};
			droneBody.healthComponent.TakeDamage(damageInfo);
		}
	}
	internal class BiggestHit : Task
	{
		private float[] biggestHit;

		protected new string description { get; } = "Biggest hit wins";


		public override TaskType type { get; } = TaskType.BiggestHit;


		protected override string name { get; } = "Biggest Hit";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " with the big hit of " + GetStylizedTaskWinStat(biggestHit[winningPlayer].ToString()) + " damage.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in BiggestHit. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onServerDamageDealt += OnDamage;
			if (biggestHit == null || biggestHit.Length != numPlayers)
			{
				biggestHit = new float[numPlayers];
			}
			Reset();
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onServerDamageDealt -= OnDamage;
			base.Unhook();
		}

		protected void UpdateProgress()
		{
			float num = 0f;
			for (int i = 0; i < biggestHit.Length; i++)
			{
				if (biggestHit[i] > num)
				{
					num = biggestHit[i];
				}
			}
			if (num > 0f)
			{
				for (int j = 0; j < progress.Length; j++)
				{
					progress[j] = biggestHit[j] / num;
				}
			}
			else
			{
				for (int k = 0; k < progress.Length; k++)
				{
					progress[k] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		public void OnDamage(DamageReport report)
		{
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
				float damageDealt = report.damageDealt;
				if (damageDealt > biggestHit[playerNumber])
				{
					biggestHit[playerNumber] = damageDealt;
					UpdateProgress();
				}
			}
		}

		private void Evaluate()
		{
			float num = 0f;
			int playerNum = 0;
			for (int i = 0; i < biggestHit.Length; i++)
			{
				if (biggestHit[i] > num)
				{
					num = biggestHit[i];
					playerNum = i;
				}
			}
			CompleteTask(playerNum);
		}

		private void Reset()
		{
			if (biggestHit != null)
			{
				for (int i = 0; i < biggestHit.Length; i++)
				{
					biggestHit[i] = 0f;
				}
				ResetProgress();
			}
		}
	}
	internal class ConfigManager
	{
		public static ConfigManager instance;

		private ConfigFile config;

		public static ConfigEntry<int> TasksPerPlayer { get; set; }

		public static ConfigEntry<int> AdditionalTasks { get; set; }

		public static ConfigEntry<float> AirKillsWeight { get; set; }

		public static ConfigEntry<float> DamageMultipleWeight { get; set; }

		public static ConfigEntry<float> DamageInTimeWeight { get; set; }

		public static ConfigEntry<float> StayInAirWeight { get; set; }

		public static ConfigEntry<float> BiggestHitWeight { get; set; }

		public static ConfigEntry<float> MostDistanceWeight { get; set; }

		public static ConfigEntry<float> PreonEventWeight { get; set; }

		public static ConfigEntry<float> FarthestAwayWeight { get; set; }

		public static ConfigEntry<float> FailShrineWeight { get; set; }

		public static ConfigEntry<float> OpenChestsWeight { get; set; }

		public static ConfigEntry<float> StartTeleWeight { get; set; }

		public static ConfigEntry<float> UsePrintersWeight { get; set; }

		public static ConfigEntry<float> OrderedSkillsWeight { get; set; }

		public static ConfigEntry<float> BadSkillWeight { get; set; }

		public static ConfigEntry<float> BabyDroneWeight { get; set; }

		public static ConfigEntry<float> DieWeight { get; set; }

		public static ConfigEntry<float> FindLockboxWeight { get; set; }

		public static ConfigEntry<float> HealingItemWeight { get; set; }

		public static ConfigEntry<float> NoJumpWeight { get; set; }

		public static ConfigEntry<float> VeryBestWeight { get; set; }

		public static ConfigEntry<float> FewestElitesWeight { get; set; }

		public static ConfigEntry<float> GetLuckyWeight { get; set; }

		public static ConfigEntry<float> GetLowWeight { get; set; }

		public static ConfigEntry<float> KillStreakWeight { get; set; }

		public static ConfigEntry<float> QuickDrawWeight { get; set; }

		public static ConfigEntry<float> FarKillWeight { get; set; }

		public static ConfigEntry<float> FewEliteWeight { get; set; }

		public ConfigManager()
		{
			if (instance == null)
			{
				instance = this;
			}
		}

		public void Awake()
		{
			SetupWeights();
		}

		public void SetConfigFile(ConfigFile c)
		{
			config = c;
		}

		private void SetupWeights()
		{
			TasksPerPlayer = config.Bind<int>("TaskOptions", "TasksPerPlayer", 1, "Number of tasks per player. Number of tasks: (TasksPerPlayer * number of player) + AdditionalTasks");
			AdditionalTasks = config.Bind<int>("TaskOptions", "AdditionalTasks", 2, "Extra tasks. Number of tasks: (TasksPerPlayer * number of player) + AdditionalTasks");
			AirKillsWeight = config.Bind<float>("TaskWeights", "AirKills", 1.5f, "Relative weight of this task. Bigger number means more likely to roll task. 0 for no chance.");
			DamageMultipleWeight = config.Bind<float>("TaskWeights", "DamageMultiple", 2f, "Relative weight of this task.");
			DamageInTimeWeight = config.Bind<float>("TaskWeights", "DamageInTime", 2f, "Relative weight of this task. Do x damage within y seconds");
			StayInAirWeight = config.Bind<float>("TaskWeights", "StayInAir", 1.5f, "Relative weight of this task.");
			BiggestHitWeight = config.Bind<float>("TaskWeights", "BiggestHit", 2f, "Relative weight of this task.");
			MostDistanceWeight = config.Bind<float>("TaskWeights", "MostDistance", 1f, "Relative weight of this task.");
			PreonEventWeight = config.Bind<float>("TaskWeights", "PreonEvent", 1f, "Relative weight of this task.");
			FarthestAwayWeight = config.Bind<float>("TaskWeights", "FarthestAway", 1.5f, "Relative weight of this task.");
			FailShrineWeight = config.Bind<float>("TaskWeights", "FailShrine", 1f, "Relative weight of this task.");
			OpenChestsWeight = config.Bind<float>("TaskWeights", "OpenChests", 2f, "Relative weight of this task.");
			StartTeleWeight = config.Bind<float>("TaskWeights", "StartTele", 2f, "Relative weight of this task.");
			UsePrintersWeight = config.Bind<float>("TaskWeights", "UsePrinters", 1f, "Relative weight of this task.");
			OrderedSkillsWeight = config.Bind<float>("TaskWeights", "OrderedSkills", 0f, "Relative weight of this task. Use abilities in left-to-right order. This task sucks.");
			BadSkillWeight = config.Bind<float>("TaskWeights", "BadSkill", 0.5f, "Relative weight of this task. Don't use utility skill");
			BabyDroneWeight = config.Bind<float>("TaskWeights", "BabyDrone", 0.75f, "Relative weight of this task. Keep your drone alive");
			DieWeight = config.Bind<float>("TaskWeights", "Die", 0.25f, "Relative weight of this task.");
			FindLockboxWeight = config.Bind<float>("TaskWeights", "FindLockbox", 2f, "Relative weight of this task.");
			HealingItemWeight = config.Bind<float>("TaskWeights", "HealingItem", 1.5f, "Relative weight of this task. Find a healing item");
			NoJumpWeight = config.Bind<float>("TaskWeights", "NoJump", 1f, "Relative weight of this task.");
			VeryBestWeight = config.Bind<float>("TaskWeights", "VeryBest", 1.5f, "Relative weight of this task. Be the very best. Like no one ever was.");
			FewestElitesWeight = config.Bind<float>("TaskWeights", "FewestElites", 1.5f, "Relative weight of this task.");
			GetLuckyWeight = config.Bind<float>("TaskWeights", "GetLucky", 0.5f, "Relative weight of this task.");
			GetLowWeight = config.Bind<float>("TaskWeights", "GetLow", 1.5f, "Relative weight of this task.");
			KillStreakWeight = config.Bind<float>("TaskWeights", "KillStreaks", 1.5f, "Relative weight of this task.");
			QuickDrawWeight = config.Bind<float>("TaskWeights", "QuickDraw", 1.5f, "Relative weight of this task. Kill something that spawned 3s ago");
			FarKillWeight = config.Bind<float>("TaskWeights", "FarKill", 1f, "Relative weight of this task. Kill something far away from where you last left the ground");
			FewEliteWeight = config.Bind<float>("TaskWeights", "FewElites", 1f, "Relative weight of this task. Kill the boss before you kill 10 elites");
		}

		public float GetTaskWeight(TaskType type)
		{
			return type switch
			{
				TaskType.AirKills => AirKillsWeight.Value, 
				TaskType.DamageMultiple => DamageMultipleWeight.Value, 
				TaskType.DamageInTime => DamageInTimeWeight.Value, 
				TaskType.StayInAir => StayInAirWeight.Value, 
				TaskType.BiggestHit => BiggestHitWeight.Value, 
				TaskType.MostDistance => MostDistanceWeight.Value, 
				TaskType.PreonEvent => PreonEventWeight.Value, 
				TaskType.FarthestAway => FarthestAwayWeight.Value, 
				TaskType.FailShrine => FailShrineWeight.Value, 
				TaskType.OpenChests => OpenChestsWeight.Value, 
				TaskType.StartTele => StartTeleWeight.Value, 
				TaskType.UsePrinters => UsePrintersWeight.Value, 
				TaskType.OrderedSkills => OrderedSkillsWeight.Value, 
				TaskType.BadSkill => BadSkillWeight.Value, 
				TaskType.BabyDrone => BabyDroneWeight.Value, 
				TaskType.Die => DieWeight.Value, 
				TaskType.FindLockbox => FindLockboxWeight.Value, 
				TaskType.HealingItem => HealingItemWeight.Value, 
				TaskType.NoJump => NoJumpWeight.Value, 
				TaskType.VeryBest => VeryBestWeight.Value, 
				TaskType.FewestElites => FewestElitesWeight.Value, 
				TaskType.GetLucky => GetLuckyWeight.Value, 
				TaskType.GetLow => GetLowWeight.Value, 
				TaskType.KillStreak => KillStreakWeight.Value, 
				TaskType.QuickDraw => QuickDrawWeight.Value, 
				TaskType.FarKill => FarKillWeight.Value, 
				TaskType.FewElites => FewEliteWeight.Value, 
				_ => 1f, 
			};
		}

		public int GetNumberOfTasks(int numPlayers)
		{
			return numPlayers * TasksPerPlayer.Value + AdditionalTasks.Value;
		}
	}
	internal class DamageMultipleTargets : Task
	{
		private int numToHit = 4;

		private HashSet<GameObject>[] targets;

		protected new string description { get; } = "Have 4 enemies damaged by you alive at once";


		public override TaskType type { get; } = TaskType.DamageMultiple;


		protected override string name { get; } = "Damage Multiple";


		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by having " + GetStylizedTaskWinStat(numToHit.ToString()) + " enemies damaged, but alive, at once.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in DamageMultiple. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onServerDamageDealt += OnDamage;
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			targets = new HashSet<GameObject>[numPlayers];
			for (int i = 0; i < targets.Length; i++)
			{
				targets[i] = new HashSet<GameObject>();
			}
		}

		protected override void Unhook()
		{
			GlobalEventManager.onServerDamageDealt -= OnDamage;
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			ResetKills();
			base.Unhook();
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = (float)targets[i].Count / (float)numToHit;
			}
			base.UpdateProgress(progress);
		}

		public void OnDamage(DamageReport report)
		{
			if (report == null || report.attackerMaster == null || report.attackerMaster.playerCharacterMasterController == null)
			{
				return;
			}
			int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
			if (report.victim.alive && !targets[playerNumber].Contains(((Component)report.victim).gameObject))
			{
				targets[playerNumber].Add(((Component)report.victim).gameObject);
				UpdateProgress();
				if (IsComplete(playerNumber))
				{
					CompleteTask(playerNumber);
					ResetKills();
				}
			}
		}

		protected override bool IsComplete(int playerNum)
		{
			return targets[playerNum].Count >= numToHit;
		}

		private void OnKill(DamageReport report)
		{
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
				targets[playerNumber].Remove(((Component)report.victim).gameObject);
				UpdateProgress();
			}
		}

		private void ResetKills()
		{
			if (targets != null)
			{
				for (int i = 0; i < targets.Length; i++)
				{
					targets[i].Clear();
				}
				ResetProgress();
			}
		}
	}
	internal class DealDamageInTime : Task
	{
		private float damageToDeal = 500f;

		private float timeLimit = 5f;

		private float[] currentDamage;

		private bool active = false;

		protected new string description { get; } = "Deal 500 damage in 5 seconds";


		public override TaskType type { get; } = TaskType.DamageInTime;


		protected override string name { get; } = "Damage In Time";


		public override string GetDescription()
		{
			return $"Deal {damageToDeal:N0} damage in 5 seconds";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by dealing " + GetStylizedTaskWinStat(damageToDeal.ToString()) + " damage within 5s.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in DamageInTime. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onServerDamageDealt += OnDamage;
			damageToDeal = Run.instance.difficultyCoefficient * damageToDeal;
			if (currentDamage == null || currentDamage.Length != numPlayers)
			{
				currentDamage = new float[numPlayers];
			}
			active = true;
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onServerDamageDealt -= OnDamage;
			Reset();
			base.Unhook();
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = currentDamage[i] / damageToDeal;
			}
			base.UpdateProgress(progress);
		}

		public void OnDamage(DamageReport report)
		{
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
				currentDamage[playerNumber] += report.damageDealt;
				UpdateProgress();
				((MonoBehaviour)TasksPlugin.instance).StartCoroutine(ReduceDamage(report.damageDealt, playerNumber));
				if (IsComplete(playerNumber))
				{
					active = false;
					CompleteTask(playerNumber);
					Reset();
				}
			}
		}

		protected override bool IsComplete(int playerNum)
		{
			return currentDamage[playerNum] >= damageToDeal;
		}

		private IEnumerator ReduceDamage(float damage, int playerNum)
		{
			yield return (object)new WaitForSeconds(timeLimit);
			currentDamage[playerNum] = Mathf.Max(0f, currentDamage[playerNum] - damage);
			if (active)
			{
				UpdateProgress();
			}
		}

		private void Reset()
		{
			if (currentDamage != null)
			{
				for (int i = 0; i < currentDamage.Length; i++)
				{
					currentDamage[i] = 0f;
				}
				ResetProgress();
			}
		}
	}
	internal class Die : Task
	{
		public override TaskType type { get; } = TaskType.Die;


		protected override string name { get; } = "Die";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return "Die";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by dying first. Congratulations.";
		}

		protected override void SetHooks(int numPlayers)
		{
			base.SetHooks(numPlayers);
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		public void OnKill(DamageReport damageReport)
		{
			if (damageReport != null && damageReport.victimMaster != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(damageReport.victimMaster);
				if (playerNumber > -1)
				{
					CompleteTask(playerNumber);
				}
			}
		}
	}
	internal class DontUseSkill : Task
	{
		private SkillSlot badSkill;

		private bool[] playerFailed;

		private int numPlayersFailed;

		protected new string description { get; } = "Last to use their utility skill wins";


		public override TaskType type { get; } = TaskType.BadSkill;


		protected override string name { get; } = "Bad Skill";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by not using their " + GetStylizedTaskWinStat(((object)(SkillSlot)(ref badSkill)).ToString()) + " skill.";
		}

		protected override void SetHooks(int numPlayers)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)$"Set Hooks in DontUseSkill. {numPlayers} players");
			base.SetHooks(numPlayers);
			badSkill = (SkillSlot)2;
			playerFailed = new bool[numPlayers];
			Reset();
			TasksPlugin.OnAbilityUsed += AbilityUsed;
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			TasksPlugin.OnAbilityUsed -= AbilityUsed;
			base.Unhook();
		}

		private void Evaluate()
		{
			if (totalNumberPlayers - numPlayersFailed <= 1)
			{
				return;
			}
			for (int i = 0; i < playerFailed.Length; i++)
			{
				if (!playerFailed[i])
				{
					UpdateProgressMultiWinner();
					CompleteTask(i);
				}
			}
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = ((!playerFailed[i]) ? (numPlayersFailed / (totalNumberPlayers - 1)) : 0);
			}
			base.UpdateProgress(progress);
		}

		private void UpdateProgressMultiWinner()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = ((!playerFailed[i]) ? 1 : 0);
			}
			base.UpdateProgress(progress);
		}

		private void AbilityUsed(int playerNum, SkillSlot slot)
		{
			//IL_0001: 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)
			if (slot != badSkill || playerFailed[playerNum])
			{
				return;
			}
			Debug.Log((object)$"Player {playerNum} failed BadSkill");
			playerFailed[playerNum] = true;
			numPlayersFailed++;
			UpdateProgress();
			if (numPlayersFailed < totalNumberPlayers - 1)
			{
				return;
			}
			for (int i = 0; i < playerFailed.Length; i++)
			{
				if (!playerFailed[i])
				{
					CompleteTask(i);
					break;
				}
			}
		}

		private void Reset()
		{
			if (playerFailed != null)
			{
				for (int i = 0; i < playerFailed.Length; i++)
				{
					playerFailed[i] = false;
				}
				ResetProgress();
			}
		}
	}
	internal class FailShrine : Task
	{
		protected new string description { get; } = "First to Fail";


		public override TaskType type { get; } = TaskType.FailShrine;


		protected override string name { get; } = "Fail a Chance Shrine";


		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by " + GetStylizedTaskWinStat("failing") + " a chance shrine.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in FailShrine. {numPlayers} players");
			base.SetHooks(numPlayers);
			ShrineChanceBehavior.onShrineChancePurchaseGlobal += OnShrineChancePurchase;
		}

		protected override void Unhook()
		{
			ShrineChanceBehavior.onShrineChancePurchaseGlobal -= OnShrineChancePurchase;
			base.Unhook();
		}

		private void OnShrineChancePurchase(bool failed, Interactor interactor)
		{
			if (!failed)
			{
				return;
			}
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				if ((Object)(object)((Component)TasksPlugin.GetPlayerCharacterMaster(i).GetBody()).GetComponent<Interactor>() == (Object)(object)interactor)
				{
					CompleteTask(i);
					break;
				}
			}
		}
	}
	internal class FarKill : Task
	{
		private int distance = 70;

		private Vector3[] playerGroundPositions;

		private bool active = false;

		public override TaskType type { get; } = TaskType.FarKill;


		protected override string name { get; } = "Far Kill";


		public override string GetDescription()
		{
			return $"Kill an enemy {distance}m from where you left the ground";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by killing something from a ways away.";
		}

		protected override void SetHooks(int numPlayers)
		{
			//IL_0056: 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)
			Debug.Log((object)$"Set hooks in FarKill. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			playerGroundPositions = (Vector3[])(object)new Vector3[numPlayers];
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				CharacterMaster playerCharacterMaster = TasksPlugin.GetPlayerCharacterMaster(i);
				playerGroundPositions[i] = playerCharacterMaster.GetBody().corePosition;
			}
			active = true;
			((MonoBehaviour)TasksPlugin.instance).StartCoroutine(CalculatePositions());
		}

		protected override void Unhook()
		{
			if (active)
			{
				active = false;
				GlobalEventManager.onCharacterDeathGlobal -= OnKill;
				base.Unhook();
			}
		}

		private void OnKill(DamageReport report)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
				float num = Vector3.Distance(report.victimBody.corePosition, playerGroundPositions[playerNumber]);
				if (num > (float)distance)
				{
					CompleteTask(playerNumber);
					return;
				}
				progress[playerNumber] = num / (float)distance;
				UpdateProgress(progress);
			}
		}

		private IEnumerator CalculatePositions()
		{
			while (active)
			{
				for (int i = 0; i < totalNumberPlayers; i++)
				{
					CharacterBody body = TasksPlugin.GetPlayerCharacterMaster(i).GetBody();
					if (body.characterMotor.isGrounded)
					{
						playerGroundPositions[i] = body.corePosition;
					}
				}
				yield return null;
			}
		}
	}
	internal class FarthestAway : Task
	{
		private Vector3[] startPositions;

		private bool active = false;

		private IEnumerator timerRoutine;

		private float winnerDist = 0f;

		protected new string description { get; } = "Farthest away in 20s wins";


		public override TaskType type { get; } = TaskType.FarthestAway;


		protected override string name { get; } = "Farthest From Spawn";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by being " + GetStylizedTaskWinStat(winnerDist.ToString("F2")) + "m away in 20 seconds.";
		}

		protected override void SetHooks(int numPlayers)
		{
			//IL_00a4: 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_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)
			Debug.Log((object)$"Set Hooks in FarthestAway. {numPlayers} players");
			base.SetHooks(numPlayers);
			if (startPositions == null || startPositions.Length != numPlayers)
			{
				startPositions = (Vector3[])(object)new Vector3[numPlayers];
			}
			for (int i = 0; i < startPositions.Length; i++)
			{
				if (TasksPlugin.GetPlayerCharacterMaster(i).GetBody() == null)
				{
					Debug.Log((object)$"Task.FarthestAway player body is null. Player: {i}");
					startPositions[i] = Vector3.zero;
				}
				else
				{
					startPositions[i] = TasksPlugin.GetPlayerCharacterMaster(i).GetBody().transform.position;
				}
			}
			timerRoutine = EndTask();
			((MonoBehaviour)TasksPlugin.instance).StartCoroutine(timerRoutine);
			active = true;
		}

		protected override void Unhook()
		{
			if (active)
			{
				active = false;
				if (timerRoutine != null)
				{
					((MonoBehaviour)TasksPlugin.instance).StopCoroutine(timerRoutine);
				}
				base.Unhook();
			}
		}

		private void UpdateProgress(int time)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			float[] array = new float[startPositions.Length];
			float num = 0f;
			if (time > 0)
			{
				for (int i = 0; i < startPositions.Length; i++)
				{
					array[i] = Vector3.Distance(startPositions[i], TasksPlugin.GetPlayerCharacterMaster(i).GetBody().transform.position);
					if (array[i] > num)
					{
						num = array[i];
					}
				}
			}
			if (num > 0f)
			{
				for (int j = 0; j < progress.Length; j++)
				{
					progress[j] = (float)time * (array[j] / num) / 20f;
				}
			}
			else
			{
				for (int k = 0; k < progress.Length; k++)
				{
					progress[k] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		private IEnumerator EndTask()
		{
			for (int i = 0; i < 20; i++)
			{
				yield return (object)new WaitForSeconds(1f);
				UpdateProgress(i + 1);
			}
			Evaluate();
		}

		private void Evaluate()
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			int playerNum = 0;
			for (int i = 0; i < startPositions.Length; i++)
			{
				CharacterMaster playerCharacterMaster = TasksPlugin.GetPlayerCharacterMaster(i);
				if ((Object)(object)playerCharacterMaster == (Object)null)
				{
					continue;
				}
				CharacterBody body = playerCharacterMaster.GetBody();
				if (!((Object)(object)body == (Object)null))
				{
					Vector3 position = body.transform.position;
					float num2 = Vector3.Distance(startPositions[i], position);
					if (num2 > num)
					{
						num = num2;
						playerNum = i;
					}
				}
			}
			winnerDist = num;
			CompleteTask(playerNum);
			ResetProgress();
		}
	}
	internal class FewElites : Task
	{
		private int[] kills;

		private int maxKills = 5;

		private bool taskFinished = false;

		public override TaskType type { get; } = TaskType.FewElites;


		protected override string name { get; } = "Few Elites";


		public override bool CanActivate(int numPlayers)
		{
			return true;
		}

		public override string GetDescription()
		{
			return "Kill the boss before you kill 5 elites.";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			if (winningPlayer < 0)
			{
				return "You failed " + GetStylizedTaskName(name) + " by killing too many elites.";
			}
			return $"{GetStylizedName(winningPlayer)} completed {GetStylizedTaskName(name)} by killing the boss while only killing {GetStylizedTaskWinStat(kills[winningPlayer].ToString())}/{maxKills} elites.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set hooks in FewElites. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			BossGroup.onBossGroupDefeatedServer += BossDied;
			kills = new int[numPlayers];
			taskFinished = false;
			Reset();
			UpdateProgress();
		}

		private void BossDied(BossGroup group)
		{
			Evaluate();
			taskFinished = true;
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			BossGroup.onBossGroupDefeatedServer -= BossDied;
			base.Unhook();
		}

		public void OnKill(DamageReport damageReport)
		{
			if (taskFinished || damageReport == null || damageReport.attackerMaster == null || damageReport.attackerMaster.playerCharacterMasterController == null)
			{
				return;
			}
			int playerNumber = TasksPlugin.GetPlayerNumber(damageReport.attackerMaster);
			if (damageReport.victimIsElite)
			{
				kills[playerNumber]++;
				if (totalNumberPlayers == 1 && kills[playerNumber] > maxKills)
				{
					CompleteTask(-1);
				}
			}
			UpdateProgress();
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				if (taskFinished)
				{
					progress[i] = 0f;
					continue;
				}
				float num = (float)(maxKills - kills[i]) / (float)maxKills;
				num = Mathf.Max(num, 0f);
				progress[i] = num;
			}
			base.UpdateProgress(progress);
		}

		private void Evaluate()
		{
			if (kills == null)
			{
				return;
			}
			string text = "";
			string text2 = "";
			for (int i = 0; i < kills.Length; i++)
			{
				if (kills[i] <= maxKills)
				{
					CompleteTask(i);
					text += $"{i}, ";
					text2 += $"{kills[i]}, ";
				}
			}
			Debug.Log((object)$"Players {text} won with {text2} /{maxKills} kills");
		}

		private void Reset()
		{
			if (kills != null)
			{
				taskFinished = false;
				for (int i = 0; i < kills.Length; i++)
				{
					kills[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class FewestElites : Task
	{
		private int[] kills;

		public override TaskType type { get; } = TaskType.FewestElites;


		protected override string name { get; } = "Fewest Elites";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return "Kill the fewest elites.";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by killing the fewest (" + GetStylizedTaskWinStat(kills[winningPlayer].ToString()) + ") elites.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set hooks in FewestElites. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			kills = new int[numPlayers];
			Reset();
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		public void OnKill(DamageReport damageReport)
		{
			if (damageReport != null && damageReport.attackerMaster != null && damageReport.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(damageReport.attackerMaster);
				if (damageReport.victimIsElite)
				{
					kills[playerNumber]++;
				}
				UpdateProgress();
			}
		}

		private void UpdateProgress()
		{
			int num = 0;
			for (int i = 0; i < kills.Length; i++)
			{
				int num2 = kills[i];
				if (num2 > num)
				{
					num = num2;
				}
			}
			if (num > 0)
			{
				for (int j = 0; j < progress.Length; j++)
				{
					progress[j] = (float)kills[j] / (float)num;
				}
			}
			else
			{
				for (int k = 0; k < progress.Length; k++)
				{
					progress[k] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		private void Evaluate()
		{
			if (kills == null)
			{
				return;
			}
			int num = 0;
			int num2 = kills[0];
			for (int i = 1; i < kills.Length; i++)
			{
				int num3 = kills[i];
				if (num3 < num2)
				{
					num = i;
					num2 = num3;
				}
			}
			Debug.Log((object)$"Player {num} won with {num2} elite kills");
			CompleteTask(num);
		}

		private void Reset()
		{
			if (kills != null)
			{
				for (int i = 0; i < kills.Length; i++)
				{
					kills[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class FindLockbox : Task
	{
		public override TaskType type { get; } = TaskType.FindLockbox;


		protected override string name { get; } = "Find Lockbox";


		public override bool CanActivate(int numPlayers)
		{
			int num = 0;
			foreach (CharacterMaster readOnlyInstances in CharacterMaster.readOnlyInstancesList)
			{
				num += readOnlyInstances.inventory.GetItemCount(Items.TreasureCache);
			}
			return num > 0;
		}

		public override string GetDescription()
		{
			return "Find the Lockbox";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by finding the lockbox first.";
		}

		protected override void SetHooks(int numPlayers)
		{
			base.SetHooks(numPlayers);
			GlobalEventManager.OnInteractionsGlobal += ChestsOpened;
			TasksPlugin.StartLockboxTask();
		}

		protected override void Unhook()
		{
			GlobalEventManager.OnInteractionsGlobal -= ChestsOpened;
			base.Unhook();
		}

		private void ChestsOpened(Interactor interactor, IInteractable interactable, GameObject go)
		{
			int playerNum = 0;
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				if ((Object)(object)((Component)TasksPlugin.GetPlayerCharacterMaster(i).GetBody()).GetComponent<Interactor>() == (Object)(object)interactor)
				{
					playerNum = i;
				}
			}
			if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<ChestBehavior>() : null)) && ((Object)go).name.Contains("Lockbox"))
			{
				CompleteTask(playerNum);
			}
		}
	}
	internal class GetLow : Task
	{
		private float[] lowPercents;

		public override TaskType type { get; } = TaskType.GetLow;


		protected override string name { get; } = "Get Low";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return "Get to the lowest life. No dying.";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by getting down to " + GetStylizedTaskWinStat(lowPercents[winningPlayer].ToString("F2")) + "% hp.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in GetLow. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onServerDamageDealt += OnDamage;
			lowPercents = new float[numPlayers];
			Reset();
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onServerDamageDealt -= OnDamage;
			base.Unhook();
		}

		private void OnDamage(DamageReport report)
		{
			if (report == null || report.victimMaster == null || report.victim == null || report.victimMaster.playerCharacterMasterController == null)
			{
				return;
			}
			int playerNumber = TasksPlugin.GetPlayerNumber(report.victimMaster);
			float num = 100f * (report.victim.health + report.victim.shield) / report.victim.fullCombinedHealth;
			if (num > 0f)
			{
				if (num < lowPercents[playerNumber])
				{
					lowPercents[playerNumber] = num;
					UpdateProgress();
				}
			}
			else
			{
				lowPercents[playerNumber] = 101f;
				UpdateProgress();
			}
		}

		protected void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = (100f - lowPercents[i]) / 100f;
			}
			base.UpdateProgress(progress);
		}

		private void Evaluate()
		{
			float num = 100f;
			int playerNum = 0;
			for (int i = 0; i < lowPercents.Length; i++)
			{
				if (lowPercents[i] < num)
				{
					num = lowPercents[i];
					playerNum = i;
				}
			}
			CompleteTask(playerNum);
		}

		private void Reset()
		{
			if (lowPercents != null)
			{
				for (int i = 0; i < lowPercents.Length; i++)
				{
					lowPercents[i] = 100f;
				}
				ResetProgress();
			}
		}
	}
	internal class GetLucky : Task
	{
		private bool active = false;

		public override TaskType type { get; } = TaskType.GetLucky;


		protected override string name { get; } = "Get Lucky";


		public override bool CanActivate(int numPlayers)
		{
			return true;
		}

		public override string GetDescription()
		{
			return "Be the luckiest.";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by getting " + GetStylizedTaskWinStat("lucky") + ".";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set hooks in GetLucky. {numPlayers} players");
			base.SetHooks(numPlayers);
			active = true;
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
		}

		protected override void Unhook()
		{
			base.Unhook();
		}

		private void Evaluate()
		{
			int playerNum = Random.Range(0, totalNumberPlayers);
			if (totalNumberPlayers == 1)
			{
				playerNum = Random.Range(0, 4);
			}
			if (Object.op_Implicit((Object)(object)TasksPlugin.instance))
			{
				((MonoBehaviour)TasksPlugin.instance).StartCoroutine(RollEvent(playerNum));
			}
		}

		private string GetRollMessage()
		{
			WeightedSelection<string> val = new WeightedSelection<string>(8);
			val.AddChoice("Rolling...", 1f);
			val.AddChoice("Who's going to be the lucky one?", 1f);
			val.AddChoice("Feeling lucky?", 1f);
			val.AddChoice("Choosing the winner. Stand by.", 1f);
			val.AddChoice("Scratching the lottery ticket.", 1f);
			val.AddChoice("Rolling for the winner.", 1f);
			val.AddChoice("Flipping a coin. Call it in the air.", 1f);
			val.AddChoice("Rigging the draw. Please wait.", 1f);
			return "<style=cEvent>" + val.Evaluate(Random.value) + "</style>";
		}

		private string GetWinFlavourMessage(string playerName)
		{
			WeightedSelection<string> val = new WeightedSelection<string>(8);
			playerName = GetStylizedTaskName(playerName);
			val.AddChoice(playerName + " won!", 1f);
			val.AddChoice(playerName + " was the lucky one!", 1f);
			val.AddChoice("Congrats, " + playerName + ".", 1f);
			val.AddChoice("The winner is " + playerName + ".", 1f);
			val.AddChoice("Your winner was " + playerName + ".", 1f);
			val.AddChoice("Congrats, " + playerName + ".", 1f);
			val.AddChoice("It's your lucky day, " + playerName + ".", 1f);
			val.AddChoice("Enjoy your prize, " + playerName + ".", 1f);
			val.AddChoice(playerName + " won, but it was rigged from the start.", 1f);
			val.AddChoice("Everyone loses except for " + playerName + ".", 1f);
			return val.Evaluate(Random.value);
		}

		private IEnumerator RollEvent(int playerNum)
		{
			ChatMessage.Send(GetRollMessage());
			yield return (object)new WaitForSeconds(1.5f);
			string name = "Nobody";
			if (totalNumberPlayers > 1 || playerNum == 0)
			{
				name = Util.GetBestMasterName(TasksPlugin.GetPlayerCharacterMaster(playerNum));
				CompleteTask(playerNum);
			}
			ChatMessage.Send(GetWinFlavourMessage(name));
		}
	}
	internal class HealingItem : Task
	{
		public override TaskType type { get; } = TaskType.HealingItem;


		protected override string name { get; } = "Find a Healing Item";


		public override string GetDescription()
		{
			return "Find a healing item";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by finding a " + GetStylizedTaskWinStat("healing") + " item first.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in HealingItem. {numPlayers} players");
			base.SetHooks(numPlayers);
			Inventory.onServerItemGiven += OnItemGained;
		}

		protected override void Unhook()
		{
			Inventory.onServerItemGiven -= OnItemGained;
			base.Unhook();
		}

		private void OnItemGained(Inventory inventory, ItemIndex item, int count)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemCatalog.GetItemDef(item).ContainsTag((ItemTag)2))
			{
				return;
			}
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				if ((Object)(object)TasksPlugin.GetPlayerCharacterMaster(i).inventory == (Object)(object)inventory)
				{
					CompleteTask(i);
					break;
				}
			}
		}
	}
	internal class KillStreak : Task
	{
		private int[] bestStreaks;

		private int[] currentStreaks;

		public override TaskType type { get; } = TaskType.KillStreak;


		protected override string name { get; } = "Kill Streak";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return "Most kills without getting hit";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " with a streak of " + GetStylizedTaskWinStat(bestStreaks[winningPlayer].ToString()) + ".";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in KillStreak. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onServerDamageDealt += OnDamage;
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			bestStreaks = new int[numPlayers];
			currentStreaks = new int[numPlayers];
			Reset();
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onServerDamageDealt -= OnDamage;
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		private void OnDamage(DamageReport report)
		{
			if (report == null || report.victimMaster == null || report.victimMaster.playerCharacterMasterController == null)
			{
				return;
			}
			if (report.damageInfo.attacker == null && !report.isFallDamage)
			{
				Debug.Log((object)"KillStreak. Self damage ignore.");
				return;
			}
			int playerNumber = TasksPlugin.GetPlayerNumber(report.victimMaster);
			if (playerNumber > -1)
			{
				currentStreaks[playerNumber] = 0;
			}
		}

		private void OnKill(DamageReport report)
		{
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
				if (playerNumber > -1)
				{
					currentStreaks[playerNumber]++;
					UpdateStreaks(playerNumber);
				}
			}
		}

		private void UpdateStreaks(int playerNum)
		{
			if (currentStreaks[playerNum] > bestStreaks[playerNum])
			{
				Debug.Log((object)$"Player {playerNum} improved their streak. {bestStreaks[playerNum]} -> {currentStreaks[playerNum]}");
				bestStreaks[playerNum] = currentStreaks[playerNum];
				UpdateProgress();
			}
		}

		protected void UpdateProgress()
		{
			int num = 0;
			for (int i = 0; i < bestStreaks.Length; i++)
			{
				if (bestStreaks[i] > num)
				{
					num = bestStreaks[i];
				}
			}
			if (num > 0)
			{
				for (int j = 0; j < progress.Length; j++)
				{
					progress[j] = (float)bestStreaks[j] / (float)num;
				}
			}
			else
			{
				for (int k = 0; k < progress.Length; k++)
				{
					progress[k] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		private void Evaluate()
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < bestStreaks.Length; i++)
			{
				if (bestStreaks[i] > num2)
				{
					num2 = bestStreaks[i];
					num = i;
				}
			}
			Debug.Log((object)$"Player {num} won with a streak of {num2}");
			CompleteTask(num);
		}

		private void Reset()
		{
			if (bestStreaks != null && currentStreaks != null)
			{
				for (int i = 0; i < bestStreaks.Length; i++)
				{
					bestStreaks[i] = 0;
					currentStreaks[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class MostDistance : Task
	{
		private double[] startDistances;

		private double winnerDist;

		protected new string description { get; } = "Most distance wins";


		public override TaskType type { get; } = TaskType.MostDistance;


		protected override string name { get; } = "Most Distance";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by covering the most (" + GetStylizedTaskWinStat(winnerDist.ToString("F2")) + "m) distance.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in MostDistance. {numPlayers} players");
			base.SetHooks(numPlayers);
			if (startDistances == null || startDistances.Length != numPlayers)
			{
				startDistances = new double[numPlayers];
			}
			for (int i = 0; i < startDistances.Length; i++)
			{
				StatSheet currentStats = TasksPlugin.GetPlayerCharacterMaster(i).playerStatsComponent.currentStats;
				startDistances[i] = currentStats.GetStatValueDouble(StatDef.totalDistanceTraveled);
			}
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
		}

		protected override void Unhook()
		{
			base.Unhook();
		}

		private void Evaluate()
		{
			double num = 0.0;
			int num2 = 0;
			for (int i = 0; i < startDistances.Length; i++)
			{
				StatSheet currentStats = TasksPlugin.GetPlayerCharacterMaster(i).playerStatsComponent.currentStats;
				double statValueDouble = currentStats.GetStatValueDouble(StatDef.totalDistanceTraveled);
				double num3 = statValueDouble - startDistances[i];
				if (num3 > num)
				{
					num = num3;
					num2 = i;
				}
				Chat.AddMessage($"MostDist({i}): {startDistances[i]} -> {statValueDouble} = {num3}. Winner: {num2} with {num}");
			}
			winnerDist = num;
			CompleteTask(num2);
		}
	}
	internal class NoJump : Task
	{
		private bool[] playerFailed;

		private int numPlayersFailed;

		public override TaskType type { get; } = TaskType.NoJump;


		protected override string name { get; } = "No Jump";


		public override string GetDescription()
		{
			return "Don't jump";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by being the last to jump.";
		}

		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		protected override void SetHooks(int numPlayers)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Debug.Log((object)$"Set Hooks in NoJump. {numPlayers} players");
			base.SetHooks(numPlayers);
			playerFailed = new bool[numPlayers];
			Reset();
			GenericCharacterMain.ApplyJumpVelocity += new hook_ApplyJumpVelocity(OnJump);
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			Reset();
		}

		protected override void Unhook()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			GenericCharacterMain.ApplyJumpVelocity -= new hook_ApplyJumpVelocity(OnJump);
			base.Unhook();
		}

		private void Evaluate()
		{
			if (totalNumberPlayers - numPlayersFailed <= 1)
			{
				return;
			}
			for (int i = 0; i < playerFailed.Length; i++)
			{
				if (!playerFailed[i])
				{
					UpdateProgressMultiWinner();
					CompleteTask(i);
				}
			}
		}

		private void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = ((!playerFailed[i]) ? (numPlayersFailed / (totalNumberPlayers - 1)) : 0);
			}
			base.UpdateProgress(progress);
		}

		private void UpdateProgressMultiWinner()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = ((!playerFailed[i]) ? 1 : 0);
			}
			base.UpdateProgress(progress);
		}

		private void OnJump(orig_ApplyJumpVelocity orig, CharacterMotor characterMotor, CharacterBody characterBody, float horizontalBonus, float verticalBonus, bool vault = false)
		{
			orig.Invoke(characterMotor, characterBody, horizontalBonus, verticalBonus, vault);
			int playerNumber = TasksPlugin.GetPlayerNumber(characterBody.master);
			if (playerNumber < 0 || playerFailed[playerNumber])
			{
				return;
			}
			Debug.Log((object)$"Player {playerNumber} failed NoJump");
			playerFailed[playerNumber] = true;
			numPlayersFailed++;
			UpdateProgress();
			if (numPlayersFailed < totalNumberPlayers - 1)
			{
				return;
			}
			for (int i = 0; i < playerFailed.Length; i++)
			{
				if (!playerFailed[i])
				{
					CompleteTask(i);
					break;
				}
			}
		}

		private void Reset()
		{
			if (playerFailed != null)
			{
				for (int i = 0; i < playerFailed.Length; i++)
				{
					playerFailed[i] = false;
				}
				ResetProgress();
			}
		}
	}
	internal class OpenChests : Task
	{
		private int[] chestsOpened;

		private int numToOpen = 5;

		protected new string description { get; } = "First to open 5 chests wins (multishops count too)";


		public override TaskType type { get; } = TaskType.OpenChests;


		protected override string name { get; } = "Open 5 Chests";


		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by opening " + GetStylizedTaskWinStat(numToOpen.ToString()) + " chests first.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in OpenChests. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.OnInteractionsGlobal += ChestsOpened;
			chestsOpened = new int[numPlayers];
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.OnInteractionsGlobal -= ChestsOpened;
			Reset();
			base.Unhook();
		}

		protected void UpdateProgress()
		{
			for (int i = 0; i < progress.Length; i++)
			{
				progress[i] = (float)chestsOpened[i] / (float)numToOpen;
			}
			base.UpdateProgress(progress);
		}

		private void ChestsOpened(Interactor interactor, IInteractable interactable, GameObject go)
		{
			int num = 0;
			for (int i = 0; i < chestsOpened.Length; i++)
			{
				if ((Object)(object)((Component)TasksPlugin.GetPlayerCharacterMaster(i).GetBody()).GetComponent<Interactor>() == (Object)(object)interactor)
				{
					num = i;
				}
			}
			if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<ChestBehavior>() : null)))
			{
				chestsOpened[num]++;
			}
			else if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<ShopTerminalBehavior>() : null)) && ((Object)go).name.Contains("MultiShop"))
			{
				chestsOpened[num]++;
			}
			UpdateProgress();
			if (IsComplete(num))
			{
				CompleteTask(num);
			}
		}

		protected override bool IsComplete(int playerNum)
		{
			return chestsOpened[playerNum] >= numToOpen;
		}

		private void Reset()
		{
			if (chestsOpened != null)
			{
				for (int i = 0; i < chestsOpened.Length; i++)
				{
					chestsOpened[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class OrderedSkills : Task
	{
		private SkillSlot[] order;

		private int[] whereInOrder;

		protected new string description { get; } = "Use skills in order";


		public override TaskType type { get; } = TaskType.OrderedSkills;


		protected override string name { get; } = "Ordered Skills";


		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by using their abilities in order.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in OrderedSkills. {numPlayers} players");
			base.SetHooks(numPlayers);
			SkillSlot[] array = new SkillSlot[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			order = (SkillSlot[])(object)array;
			whereInOrder = new int[numPlayers];
			Reset();
			TasksPlugin.OnAbilityUsed += AbilityUsed;
		}

		protected override void Unhook()
		{
			TasksPlugin.OnAbilityUsed -= AbilityUsed;
			Reset();
			base.Unhook();
		}

		private void AbilityUsed(int playerNum, SkillSlot slot)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between I4 and Unknown
			int num = whereInOrder[playerNum];
			if ((int)order[num] == (int)slot)
			{
				whereInOrder[playerNum]++;
				if (whereInOrder[playerNum] >= order.Length)
				{
					CompleteTask(playerNum);
				}
			}
			else
			{
				whereInOrder[playerNum] = 0;
			}
		}

		private void Reset()
		{
			if (whereInOrder != null)
			{
				for (int i = 0; i < whereInOrder.Length; i++)
				{
					whereInOrder[i] = 0;
				}
			}
		}
	}
	internal class PreonEvent : Task
	{
		private int[] kills;

		private int preonIndex = -1;

		protected new string description { get; } = "Most Preon kills wins";


		public override TaskType type { get; } = TaskType.PreonEvent;


		protected override string name { get; } = "Preon Event";


		public override bool CanActivate(int numPlayers)
		{
			return numPlayers > 1;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by getting " + GetStylizedTaskWinStat(kills[winningPlayer].ToString()) + " kills with the Preon Accumulator.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in PreonEvent. {numPlayers} players");
			base.SetHooks(numPlayers);
			preonIndex = ProjectileCatalog.FindProjectileIndex("BeamSphere");
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
			if (kills == null || kills.Length != numPlayers)
			{
				kills = new int[numPlayers];
			}
			Reset();
			TasksPlugin.StartPreonEvent();
		}

		protected override void StageEnd()
		{
			base.StageEnd();
			Evaluate();
			TasksPlugin.EndPreonEvent();
			Reset();
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		protected void UpdateProgress()
		{
			int num = 0;
			for (int i = 0; i < kills.Length; i++)
			{
				if (kills[i] > num)
				{
					num = kills[i];
				}
			}
			if (num > 0)
			{
				for (int j = 0; j < progress.Length; j++)
				{
					progress[j] = (float)kills[j] / (float)num;
				}
			}
			else
			{
				for (int k = 0; k < progress.Length; k++)
				{
					progress[k] = 0f;
				}
			}
			base.UpdateProgress(progress);
		}

		public void OnKill(DamageReport damageReport)
		{
			if (damageReport != null && damageReport.attackerMaster != null && damageReport.attackerMaster.playerCharacterMasterController != null)
			{
				int playerNumber = TasksPlugin.GetPlayerNumber(damageReport.attackerMaster);
				if (ProjectileCatalog.GetProjectileIndex(damageReport.damageInfo.inflictor) == preonIndex)
				{
					kills[playerNumber]++;
					UpdateProgress();
				}
			}
		}

		private void Evaluate()
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < kills.Length; i++)
			{
				if (kills[i] > num)
				{
					num = kills[i];
					num2 = i;
				}
			}
			Chat.AddMessage($"Player {num2} won Preon event with {num} kills");
			CompleteTask(num2);
		}

		private void Reset()
		{
			if (kills != null)
			{
				for (int i = 0; i < kills.Length; i++)
				{
					kills[i] = 0;
				}
				ResetProgress();
			}
		}
	}
	internal class QuickDraw : Task
	{
		public override TaskType type { get; } = TaskType.QuickDraw;


		protected override string name { get; } = "Quick Draw";


		public override string GetDescription()
		{
			return "Kill an enemy within 3s of spawning.";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by killing an enemy within " + GetStylizedTaskWinStat("3") + "s of spawning.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in KillStreak. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.onCharacterDeathGlobal += OnKill;
		}

		protected override void Unhook()
		{
			GlobalEventManager.onCharacterDeathGlobal -= OnKill;
			base.Unhook();
		}

		private void OnKill(DamageReport report)
		{
			//IL_002e: 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)
			if (report != null && report.attackerMaster != null && report.attackerMaster.playerCharacterMasterController != null)
			{
				float num = FixedTimeStamp.now.t - report.victimBody.localStartTime.t;
				if (num < 3f)
				{
					int playerNumber = TasksPlugin.GetPlayerNumber(report.attackerMaster);
					CompleteTask(playerNumber);
				}
			}
		}
	}
	internal class RewardBuilder
	{
		public static Reward CreateRandomReward()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			WeightedSelection<RewardType> val = new WeightedSelection<RewardType>(8);
			val.AddChoice(RewardType.Item, 2f);
			val.AddChoice(RewardType.TempItem, 1f);
			val.AddChoice(RewardType.Command, 0.5f);
			val.AddChoice(RewardType.Drone, 0.5f);
			RewardType rewardType = val.Evaluate(Random.value);
			List<PickupIndex> list = Run.instance.smallChestDropTierSelector.Evaluate(Random.value);
			PickupIndex item = Run.instance.treasureRng.NextElementUniform<PickupIndex>(list);
			string randomDronePath = GetRandomDronePath();
			Reward result = new Reward(rewardType, item, (rewardType != RewardType.TempItem) ? 1 : 5, _temporary: false, 100, 100, randomDronePath);
			return result;
		}

		public static string GetRandomDronePath()
		{
			WeightedSelection<string> val = new WeightedSelection<string>(8);
			val.AddChoice("iscBrokenDrone1", 4f);
			val.AddChoice("iscBrokenDrone2", 4f);
			val.AddChoice("iscBrokenTurret1", 3f);
			val.AddChoice("iscBrokenFlameDrone", 1f);
			val.AddChoice("iscBrokenEmergencyDrone", 1f);
			val.AddChoice("iscBrokenMissileDrone", 0.5f);
			return val.Evaluate(Random.value);
		}

		public static string GetDroneTexturePath(string spawnCardName)
		{
			return spawnCardName switch
			{
				"iscBrokenDrone1" => "Textures/BodyIcons/texDrone1Icon", 
				"iscBrokenDrone2" => "Textures/BodyIcons/texDrone2Icon", 
				"iscBrokenTurret1" => "Textures/BodyIcons/texTurret1Icon", 
				"iscBrokenFlameDrone" => "Textures/BodyIcons/FlameDroneBody", 
				"iscBrokenEmergencyDrone" => "Textures/BodyIcons/EmergencyDroneBody", 
				"iscBrokenMissileDrone" => "Textures/BodyIcons/texMissileDroneIcon", 
				_ => "Textures/BodyIcons/texDrone1Icon", 
			};
		}

		public static void GivePlayerDrone(int playerNum, string droneSpawnCardName)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_002e: 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_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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0064: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			CharacterBody body = TasksPlugin.GetPlayerCharacterMaster(playerNum).GetBody();
			GameObject val = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(Resources.Load<SpawnCard>("SpawnCards/InteractableSpawnCard/" + droneSpawnCardName), new DirectorPlacementRule
			{
				placementMode = (PlacementMode)3,
				position = body.transform.position + new Vector3(1f, 0f, 0f)
			}, new Xoroshiro128Plus(0uL)));
			PurchaseInteraction component = val.GetComponent<PurchaseInteraction>();
			component.cost = 0;
			Interactor component2 = ((Component)body).GetComponent<Interactor>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				component.OnInteractionBegin(component2);
			}
		}
	}
	public struct Reward
	{
		public RewardType type;

		public PickupIndex item;

		public int numItems;

		public bool temporary;

		public int gold;

		public int xp;

		public string dronePath;

		public Reward(RewardType _type, PickupIndex _item, int _numItems, bool _temporary, int _gold, int _xp, string _path)
		{
			//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)
			type = _type;
			item = _item;
			numItems = _numItems;
			temporary = _temporary;
			gold = _gold;
			xp = _xp;
			dronePath = _path;
		}

		public override string ToString()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return $"{type:g}, {item:g}";
		}
	}
	public struct TempItem
	{
		public PickupIndex item;

		public int count;

		public TempItem(PickupIndex _item, int _count)
		{
			//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)
			item = _item;
			count = _count;
		}
	}
	public enum RewardType
	{
		Item,
		TempItem,
		Command,
		Gold,
		Xp,
		Drone
	}
	public class TaskInfo : MessageBase
	{
		public int taskType;

		public string description;

		public bool completed;

		public int index;

		public int total;

		public Reward reward;

		public override void Serialize(NetworkWriter writer)
		{
			writer.Write(taskType);
			writer.Write(description);
			writer.Write(completed);
			writer.Write(index);
			writer.Write(total);
			writer.Write((int)reward.type);
			writer.Write(reward.item.value);
			writer.Write(reward.numItems);
			writer.Write(reward.temporary);
			writer.Write(reward.gold);
			writer.Write(reward.xp);
			writer.Write(reward.dronePath);
		}

		public override void Deserialize(NetworkReader reader)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			taskType = reader.ReadInt32();
			description = reader.ReadString();
			completed = reader.ReadBoolean();
			index = reader.ReadInt32();
			total = reader.ReadInt32();
			int type = reader.ReadInt32();
			int num = reader.ReadInt32();
			int numItems = reader.ReadInt32();
			bool temporary = reader.ReadBoolean();
			int gold = reader.ReadInt32();
			int xp = reader.ReadInt32();
			string path = reader.ReadString();
			PickupIndex item = default(PickupIndex);
			((PickupIndex)(ref item))..ctor(num);
			reward = new Reward((RewardType)type, item, numItems, temporary, gold, xp, path);
		}

		public TaskInfo(int _type, string _description, bool _completed, int _index, int _total, Reward _reward)
		{
			taskType = _type;
			description = _description;
			completed = _completed;
			index = _index;
			total = _total;
			reward = _reward;
		}

		public TaskInfo(NetworkReader reader)
		{
			((MessageBase)this).Deserialize(reader);
		}

		public override string ToString()
		{
			return $"TaskInfo: {taskType}, {description}, {completed}, {index}/{total}";
		}
	}
	public class ProgressInfo : MessageBase
	{
		public int taskIndex;

		private float myProgress;

		private float rivalProgress;

		public ProgressInfo(int _taskIndex, float _myProgress, float _rivalProgress)
		{
			taskIndex = _taskIndex;
			myProgress = _myProgress;
			rivalProgress = _rivalProgress;
		}

		public ProgressInfo(int _taskIndex, int _myProgress, int _rivalProgress)
		{
			taskIndex = _taskIndex;
			myProgress = _myProgress;
			rivalProgress = _rivalProgress;
		}

		public float GetMyProgress()
		{
			return myProgress;
		}

		public float GetRivalProgress()
		{
			return rivalProgress;
		}

		public override void Serialize(NetworkWriter writer)
		{
			writer.Write(taskIndex);
			writer.Write(myProgress);
			writer.Write(rivalProgress);
		}

		public override void Deserialize(NetworkReader reader)
		{
			taskIndex = reader.ReadInt32();
			myProgress = reader.ReadSingle();
			rivalProgress = reader.ReadSingle();
		}
	}
	public class TaskCompletionInfo : MessageBase
	{
		public int taskType;

		public string winnerName;

		public TaskCompletionInfo(int _taskType, string _winnerName)
		{
			taskType = _taskType;
			winnerName = _winnerName;
		}

		public override void Serialize(NetworkWriter writer)
		{
			writer.Write(taskType);
			writer.Write(winnerName);
		}

		public override void Deserialize(NetworkReader reader)
		{
			taskType = reader.ReadInt32();
			winnerName = reader.ReadString();
		}
	}
	internal class StartTeleporter : Task
	{
		private float soloTimer;

		private float soloTimeAmountSec = 90f;

		private bool hasFailed = false;

		private bool succeeded = false;

		protected new string description { get; } = "Better be First";


		public override TaskType type { get; } = TaskType.StartTele;


		protected override string name { get; } = "Activate the Teleporter";


		public override bool CanActivate(int numPlayers)
		{
			return true;
		}

		public override string GetDescription()
		{
			return description;
		}

		public override string GetWinMessage(int winningPlayer)
		{
			if (winningPlayer < 0)
			{
				return "You failed " + GetStylizedTaskName(name) + " by not getting to the " + GetStylizedTaskWinStat("teleporter") + " in " + GetStylizedTaskWinStat(soloTimeAmountSec.ToString()) + " seconds.";
			}
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by triggering the " + GetStylizedTaskWinStat("teleporter") + " first.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in StartTele. {numPlayers} players");
			base.SetHooks(numPlayers);
			GlobalEventManager.OnInteractionsGlobal += OnInteraction;
			if (numPlayers == 1)
			{
				StartSolo();
			}
		}

		protected override void Unhook()
		{
			GlobalEventManager.OnInteractionsGlobal -= OnInteraction;
			base.Unhook();
		}

		private void OnInteraction(Interactor interactor, IInteractable interactable, GameObject go)
		{
			int playerNum = 0;
			for (int i = 0; i < totalNumberPlayers; i++)
			{
				if ((Object)(object)((Component)TasksPlugin.GetPlayerCharacterMaster(i).GetBody()).GetComponent<Interactor>() == (Object)(object)interactor)
				{
					playerNum = i;
				}
			}
			if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<TeleporterInteraction>() : null)))
			{
				Evaluate(playerNum);
			}
		}

		private void StartSolo()
		{
			if (Object.op_Implicit((Object)(object)TasksPlugin.instance))
			{
				((MonoBehaviour)TasksPlugin.instance).StartCoroutine(Countdown());
			}
		}

		private IEnumerator Countdown()
		{
			hasFailed = false;
			succeeded = false;
			soloTimer = soloTimeAmountSec;
			for (int i = 0; (float)i < soloTimeAmountSec; i++)
			{
				yield return (object)new WaitForSeconds(1f);
				soloTimer -= 1f;
				UpdateProgressSolo();
			}
			hasFailed = true;
			if (!succeeded)
			{
				CompleteTask(-1);
			}
		}

		private void Evaluate(int playerNum)
		{
			if (totalNumberPlayers > 1)
			{
				CompleteTask(playerNum);
			}
			else if (!hasFailed)
			{
				succeeded = true;
				CompleteTask(playerNum);
			}
		}

		private void UpdateProgressSolo()
		{
			if (succeeded)
			{
				progress[0] = 0f;
			}
			else
			{
				progress[0] = Mathf.Max(0f, soloTimer / soloTimeAmountSec);
			}
			base.UpdateProgress(progress);
		}
	}
	internal class StayInAir : Task
	{
		private CharacterMotor[] motors;

		private CharacterBody[] bodies;

		private float[] timeInAir;

		private float timeToStayInAir;

		protected new string description { get; } = "Stay airborne for 10 seconds";


		public override TaskType type { get; } = TaskType.StayInAir;


		protected override string name { get; } = "Stay Airborne";


		public override string GetDescription()
		{
			return $"Stay in the air for {Math.Round(timeToStayInAir, 1)} seconds";
		}

		public override string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + GetStylizedTaskName(name) + " by staying in the air for " + GetStylizedTaskWinStat(timeToStayInAir.ToString("0.00")) + "s.";
		}

		protected override void SetHooks(int numPlayers)
		{
			Debug.Log((object)$"Set Hooks in Stay Airborne. {numPlayers} players");
			base.SetHooks(numPlayers);
			timeToStayInAir = 2f + Run.instance.difficultyCoefficient;
			if (timeInAir == null || timeInAir.Length != numPlayers)
			{
				timeInAir = new float[numPlayers];
				for (int i = 0; i < timeInAir.Length; i++)
				{
					timeInAir[i] = 0f;
				}
			}
			if (motors == null || motors.Length != numPlayers)
			{
				motors = (CharacterMotor[])(object)new CharacterMotor[numPlayers];
			}
			if (bodies == null || motors.Length != numPlayers)
			{
				bodies = (CharacterBody[])(object)new CharacterBody[numPlayers];
			}
			SetupBodies();
			RoR2Application.onFixedUpdate += AirborneFixedUpdate;
		}

		protected override void Unhook()
		{
			RoR2Application.onFixedUpdate -= AirborneFixedUpdate;
			Reset();
			base.Unhook();
		}

		protected void UpdateProgress()
		{
			if (timeInAir != null && progress != null)
			{
				for (int i = 0; i < progress.Length; i++)
				{
					progress[i] = timeInAir[i] / timeToStayInAir;
				}
				base.UpdateProgress(progress);
			}
		}

		private void AirborneFixedUpdate()
		{
			UpdateProgress();
			for (int i = 0; i < timeInAir.Length; i++)
			{
				timeInAir[i] = ((Object.op_Implicit((Object)(object)motors[i]) && !motors[i].isGrounded && !Object.op_Implicit((Object)(object)bodies[i].currentVehicle)) ? (timeInAir[i] + Time.fixedDeltaTime) : 0f);
				if (IsComplete(i))
				{
					CompleteTask(i);
					Reset();
				}
			}
		}

		protected override bool IsComplete(int playerNum)
		{
			return timeInAir[playerNum] >= timeToStayInAir;
		}

		private void Reset()
		{
			UpdateProgress();
			if (timeInAir != null)
			{
				for (int i = 0; i < timeInAir.Length; i++)
				{
					timeInAir[i] = 0f;
				}
				ResetProgress();
			}
		}

		private void SetupBodies()
		{
			for (int i = 0; i < motors.Length; i++)
			{
				CharacterMaster playerCharacterMaster = TasksPlugin.GetPlayerCharacterMaster(i);
				bodies[i] = playerCharacterMaster.GetBody();
				motors[i] = playerCharacterMaster.GetBody().characterMotor;
			}
		}
	}
	public enum TaskType
	{
		Base,
		AirKills,
		DamageMultiple,
		DamageInTime,
		StayInAir,
		BiggestHit,
		MostDistance,
		PreonEvent,
		FarthestAway,
		FailShrine,
		OpenChests,
		StartTele,
		UsePrinters,
		OrderedSkills,
		BadSkill,
		BabyDrone,
		Die,
		FindLockbox,
		HealingItem,
		NoJump,
		VeryBest,
		FewestElites,
		GetLucky,
		GetLow,
		KillStreak,
		QuickDraw,
		FarKill,
		FewElites
	}
	internal class Task
	{
		private static string myName = "SOLRUN_";

		private static string myMod = "TASKS_";

		protected static string thisClass = "BASE_TASK_";

		protected int totalNumberPlayers;

		protected float[] progress;

		private bool taskActive = false;

		protected string description { get; } = "Base description";


		public virtual TaskType type { get; } = TaskType.Base;


		protected virtual string name { get; } = "Base Task";


		public static event Action<TaskType, int, string> OnCompletion;

		public static event Action<TaskType, float[]> OnUpdateProgress;

		public Task()
		{
			OnInstall();
		}

		protected virtual void SetupName()
		{
		}

		public virtual string GetDescription()
		{
			return description;
		}

		public virtual void OnInstall()
		{
			Run.onRunDestroyGlobal += RunOver;
			TasksPlugin.OnActivate += Activate;
			TasksPlugin.OnDeactivate += Deactivate;
			TasksPlugin.OnCancelAll += CancelAllTasks;
		}

		public virtual void OnUninstall()
		{
			Run.onRunDestroyGlobal -= RunOver;
			TasksPlugin.OnActivate -= Activate;
			TasksPlugin.OnDeactivate -= Deactivate;
			TasksPlugin.OnCancelAll -= CancelAllTasks;
		}

		protected virtual void UpdateProgress(float[] progress)
		{
			if (taskActive)
			{
				Task.OnUpdateProgress?.Invoke(type, progress);
			}
		}

		protected void ResetProgress()
		{
			TasksPlugin instance = TasksPlugin.instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(ResetProgressInTime());
			}
		}

		private IEnumerator ResetProgressInTime()
		{
			yield return (object)new WaitForSeconds(4f);
			if (progress != null)
			{
				for (int i = 0; i < progress.Length; i++)
				{
					progress[i] = 0f;
				}
				if (taskActive)
				{
					Task.OnUpdateProgress?.Invoke(type, progress);
				}
				else
				{
					Debug.Log((object)$"{type:g} was inactive. Don't update progress");
				}
			}
		}

		public virtual string GetWinMessage(int winningPlayer)
		{
			return GetStylizedName(winningPlayer) + " completed " + name;
		}

		protected string GetStylizedName(int playerNum)
		{
			return "<color=#ffffff>" + TasksPlugin.GetPlayerName(playerNum) + "</color>";
		}

		protected string GetStylizedTaskName(string taskName)
		{
			return "<style=cIsUtility>" + taskName + "</style>";
		}

		protected string GetStylizedTaskWinStat(string stat)
		{
			return "<style=cIsUtility>" + stat + "</style>";
		}

		protected virtual void CompleteTask(int playerNum)
		{
			Unhook();
			Task.OnCompletion?.Invoke(type, playerNum, GetWinMessage(playerNum));
		}

		protected virtual bool IsComplete(int playerNum)
		{
			return false;
		}

		public virtual bool CanActivate(int numPlayers)
		{
			return true;
		}

		private void Activate(int id, int numPlayers)
		{
			if (id == (int)type)
			{
				totalNumberPlayers = numPlayers;
				progress = new float[numPlayers];
				SetHooks(numPlayers);
				taskActive = true;
			}
		}

		public void Deactivate(int id)
		{
			if (id == (int)type || id < 0)
			{
				taskActive = false;
				StageEnd();
				Unhook();
			}
		}

		public void CancelAllTasks()
		{
			taskActive = false;
			Unhook();
		}

		protected virtual void StageEnd()
		{
		}

		protected virtual void SetHooks(int numPlayers)
		{
		}

		protected virtual void Unhook()
		{
		}

		private void RunOver(Run run)
		{
			Unhook();
			OnUninstall();
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.Solrun.Tasks", "Tasks", "1.2.4")]
	public sealed class TasksPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnCollisionEnter <0>__TurnOffCommand;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnSkillActivated <>9__48_0;

			public static Func<string> <>9__65_1;

			internal void <SetGameHooks>b__48_0(orig_OnSkillActivated orig, CharacterBody self, GenericSkill param)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				if (NetworkServer.active && self.isPlayerControlled)
				{
					int playerNumber = GetPlayerNumber(self.master);
					SkillSlot arg = self.skillLocator.FindSkillSlot(param);
					TasksPlugin.OnAbilityUsed?.Invoke(playerNumber, arg);
				}
				orig.Invoke(self, param);
			}

			internal string <CreateNotification>b__65_1()
			{
				return "Task Complete!";
			}
		}

		public const string MODNAME = "Tasks";

		public const string AUTHOR = "Solrun";

		public const string GUID = "com.Solrun.Tasks";

		public const string VERSION = "1.2.4";

		public static TasksPlugin instance;

		private static List<CharacterMaster> playerCharacterMasters;

		private int totalNumPlayers = 0;

		private int totalNumTasks;

		public Reward[] rewards;

		private List<TempItem>[] TempItemLists;

		private EquipmentIndex[] preonEventEqCache;

		private int[] stageStartTasks;

		private int[] teleStartTasks;

		private Task[] taskCopies;

		private bool telePlaced = false;

		public TaskInfo[] currentTasks;

		public GameObject[] tasksUIObjects;

		public RectTransform[] tasksUIRects;

		public RectTransform[] rivalTasksUIRects;

		private HUD hud;

		private ObjectivePanelController panel;

		private GameObject itemIconPrefabCopy;

		private bool rectWasAlreadyNull = false;

		private bool rivalRectWasAlreadyNull = false;

		public static event Action<int, int> OnActivate;

		public static event Action<int> OnDeactivate;

		public static event Action OnCancelAll;

		public static event Action<int> OnPopup;

		public static event Action<int, SkillSlot> OnAbilityUsed;

		public void InvokeOnPopup(int taskType)
		{
			TasksPlugin.OnPopup?.Invoke(taskType);
		}

		private void Awake()
		{
			Chat.AddMessage("Loaded Task plugin");
			if (instance == null)
			{
				instance = this;
			}
			ConfigManager configManager = new ConfigManager();
			ConfigManager.instance.SetConfigFile(((BaseUnityPlugin)this).Config);
			ConfigManager.instance.Awake();
			Task.OnCompletion += TaskCompletion;
			Task.OnUpdateProgress += UpdateTaskProgress;
			Run.onRunStartGlobal += GameSetup;
			SetupNetworking();
			SetGameHooks();
		}

		private void Start()
		{
		}

		public void Update()
		{
			if (0 == 0)
			{
			}
		}

		private void GameSetup(Run run)
		{
			totalNumTasks = Enum.GetNames(typeof(TaskType)).Length;
			rewards = new Reward[totalNumTasks];
			Debug.Log((object)$"Tasks mod: Number of players: {run.participatingPlayerCount} Living Players: {run.livingPlayerCount}");
			totalNumPlayers = run.participatingPlayerCount;
			playerCharacterMasters = new List<CharacterMaster>(totalNumPlayers);
			rectWasAlreadyNull = false;
			rivalRectWasAlreadyNull = false;
			PopulatePlayerCharaterMasterList();
			if (NetworkServer.active)
			{
				TaskSetup();
				PopulateTempItemLists();
				TasksPlugin.OnCancelAll?.Invoke();
			}
		}

		private void TaskSetup()
		{
			Debug.Log((object)"Creating Task Objects");
			taskCopies = new Task[27];
			AirKills airKills = new AirKills();
			DamageMultipleTargets damageMultipleTargets = new DamageMultipleTargets();
			DealDamageInTime dealDamageInTime = new DealDamageInTime();
			StayInAir stayInAir = new StayInAir();
			BiggestHit biggestHit = new BiggestHit();
			MostDistance mostDistance = new MostDistance();
			PreonEvent preonEvent = new PreonEvent();
			FarthestAway farthestAway = new FarthestAway();
			FailShrine failShrine = new FailShrine();
			OpenChests openChests = new OpenChests();
			StartTeleporter startTeleporter = new StartTeleporter();
			UsePrinters usePrinters = new UsePrinters();
			OrderedSkills orderedSkills = new OrderedSkills();
			DontUseSkill dontUseSkill = new DontUseSkill();
			BabyDrone babyDrone = new BabyDrone();
			Die die = new Die();
			FindLockbox findLockbox = new FindLockbox();
			HealingItem healingItem = new HealingItem();
			NoJump noJump = new NoJump();
			VeryBest veryBest = new VeryBest();
			FewestElites fewestElites = new FewestElites();
			GetLucky getLucky = new GetLucky();
			GetLow getLow = new GetLow();
			KillStreak killStreak = new KillStreak();
			QuickDraw quickDraw = new QuickDraw();
			FarKill farKill = new FarKill();
			FewElites fewElites = new FewElites();
			taskCopies[(int)(airKills.type - 1)] = airKills;
			taskCopies[(int)(damageMultipleTargets.type - 1)] = damageMultipleTargets;
			taskCopies[(int)(dealDamageInTime.type - 1)] = dealDamageInTime;
			taskCopies[(int)(stayInAir.type - 1)] = stayInAir;
			taskCopies[(int)(biggestHit.type - 1)] = biggestHit;
			taskCopies[(int)(mostDistance.type - 1)] = mostDistance;
			taskCopies[(int)(preonEvent.type - 1)] = preonEvent;
			taskCopies[(int)(farthestAway.type - 1)] = farthestAway;
			taskCopies[(int)(failShrine.type - 1)] = failShrine;
			taskCopies[(int)(openChests.type - 1)] = openChests;
			taskCopies[(int)(startTeleporter.type - 1)] = startTeleporter;
			taskCopies[(int)(usePrinters.type - 1)] = usePrinters;
			taskCopies[(int)(orderedSkills.type - 1)] = orderedSkills;
			taskCopies[(int)(dontUseSkill.type - 1)] = dontUseSkill;
			taskCopies[(int)(babyDrone.type - 1)] = babyDrone;
			taskCopies[(int)(die.type - 1)] = die;
			taskCopies[(int)(findLockbox.type - 1)] = findLockbox;
			taskCopies[(int)(healingItem.type - 1)] = healingItem;
			taskCopies[(int)(noJump.type - 1)] = noJump;
			taskCopies[(int)(veryBest.type - 1)] = veryBest;
			taskCopies[(int)(fewestElites.type - 1)] = fewestElites;
			taskCopies[(int)(getLucky.type - 1)] = getLucky;
			taskCopies[(int)(getLow.type - 1)] = getLow;
			taskCopies[(int)(killStreak.type - 1)] = killStreak;
			taskCopies[(int)(quickDraw.type - 1)] = quickDraw;
			taskCopies[(int)(farKill.type - 1)] = farKill;
			taskCopies[(int)(fewElites.type - 1)] = fewElites;
		}

		private void PopulatePlayerCharaterMasterList()
		{
			for (int i = 0; i < CharacterMaster.readOnlyInstancesList.Count; i++)
			{
				if ((Object)(object)CharacterMaster.readOnlyInstancesList[i].playerCharacterMasterController != (Object)null)
				{
					playerCharacterMasters.Add(CharacterMaster.readOnlyInstancesList[i]);
				}
			}
		}

		private void PopulateTempItemLists()
		{
			TempItemLists = new List<TempItem>[CharacterMaster.readOnlyInstancesList.Count];
			for (int i = 0; i < TempItemLists.Length; i++)
			{
				TempItemLists[i] = new List<TempItem>();
			}
		}

		private void SetupNetworking()
		{
			NetworkingAPI.RegisterMessageType<SyncTaskCompletion>();
			NetworkingAPI.RegisterMessageType<SyncTaskEnded>();
			NetworkingAPI.RegisterMessageType<SyncUpdateTask>();
			NetworkingAPI.RegisterMessageType<SyncUpdateProgress>();
		}

		private void SetGameHooks()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			object obj = <>c.<>9__48_0;
			if (obj == null)
			{
				hook_OnSkillActivated val = delegate(orig_OnSkillActivated orig, CharacterBody self, GenericSkill param)
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002e: Unknown result type (might be due to invalid IL or missing references)
					//IL_003b: Unknown result type (might be due to invalid IL or missing references)
					if (NetworkServer.active && self.isPlayerControlled)
					{
						int playerNumber = GetPlayerNumber(self.master);
						SkillSlot arg = self.skillLocator.FindSkillSlot(param);
						TasksPlugin.OnAbilityUsed?.Invoke(playerNumber, arg);
					}
					orig.Invoke(self, param);
				};
				<>c.<>9__48_0 = val;
				obj = (object)val;
			}
			CharacterBody.OnSkillActivated += (hook_OnSkillActivated)obj;
			GlobalEventManager.OnInteractionsGlobal += delegate(Interactor interactor, IInteractable interactable, GameObject go)
			{
				string text = ((object)interactable).GetType().ToString();
				if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<TeleporterInteraction>() : null)))
				{
					Debug.Log((object)("Interacted with TP. InterType: " + text + " name: " + ((Object)go).name));
				}
				else if (Object.op_Implicit((Object)(object)((go != null) ? go.GetComponent<SceneExitController>() : null)))
				{
					Debug.Log((object)("Interacted with a SceneExitController " + ((Object)go).name));
					StageEnd();
				}
			};
			TeleporterInteraction.onTeleporterFinishGlobal += delegate
			{
				Debug.Log((object)"TP finished and player chose to leave");
				if (NetworkServer.active)
				{
					StageEnd();
				}
			};
			Run.OnServerTeleporterPlaced += (hook_OnServerTeleporterPlaced)delegate(orig_OnServerTeleporterPlaced orig, Run self, SceneDirector director, GameObject teleporter)
			{
				orig.Invoke(self, director, teleporter);
				telePlaced = true;
			};
			HudObjectiveTargetSetter.Update += (hook_Update)delegate(orig_Update orig, HudObjectiveTargetSetter self)
			{
				orig.Invoke(self);
				if ((Object)(object)panel == (Object)null)
				{
					Debug.Log((object)"Panel is null in HudObjSetter.Update");
				}
				if (self.objectivePanelController == null)
				{
					Debug.Log((object)"Task mod: objectivePanelController was null");
				}
				if (Object.op_Implicit((Object)(object)self.objectivePanelController))
				{
					panel = self.objectivePanelController;
				}
			};
			HUD.Awake += (hook_Awake)delegate(orig_Awake orig, HUD self)
			{
				orig.Invoke(self);
				hud = self;
				int numberOfTasks = ConfigManager.instance.GetNumberOfTasks(totalNumPlayers);
				numberOfTasks = Math.Min(numberOfTasks, 7);
				tasksUIObjects = (GameObject[])(object)new GameObject[numberOfTasks];
				tasksUIRects = (RectTransform[])(object)new RectTransform[numberOfTasks];
				rivalTasksUIRects = (RectTransform[])(object)new RectTransform[numberOfTasks];
				if (telePlaced && NetworkServer.active)
				{
					GenerateTasks(numberOfTasks);
				}
			};
			GameOverController.Awake += (hook_Awake)delegate(orig_Awake orig, GameOverController self)
			{
				Debug.Log((object)"GameOverController.Awake");
				CancelAllTasks();
				orig.Invoke(self);
			};
		}

		public void UpdateTasksUI(int taskIndex, string text = "")
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be