using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("CraniusHunt")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0-alpha.0.3+fefc36594d7ece82fdf9840a22830b403f478945")]
[assembly: AssemblyProduct("CraniusHunt")]
[assembly: AssemblyTitle("CraniusHunt")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[BepInPlugin("sparroh.craniushunt", "CraniusHunt", "1.1.0")]
public class SparrohPlugin : BaseUnityPlugin
{
	public const string PluginGUID = "sparroh.craniushunt";

	public const string PluginName = "CraniusHunt";

	public const string PluginVersion = "1.1.0";

	public static ManualLogSource Logger;

	private void Awake()
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		Logger = ((BaseUnityPlugin)this).Logger;
		try
		{
			new Harmony("sparroh.craniushunt").PatchAll(typeof(MissionSelectWindowInitPatch));
			Logger.LogInfo((object)"CraniusHunt loaded successfully.");
		}
		catch (Exception arg)
		{
			Logger.LogError((object)string.Format("Failed to initialize {0}: {1}", "CraniusHunt", arg));
		}
	}
}
public class CraniusMission : FlatTundraMission
{
	public override bool OverrideScene(out SceneData scene, WorldRegion region, int seed)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		scene = new SceneData("Tundra1Flat", (string)null);
		return true;
	}

	public override void ModifyTeamRevives(ref int revives)
	{
		revives = 0;
	}

	public override bool GetResetDateTime(out long unixTime)
	{
		unixTime = 0L;
		return false;
	}

	public override bool CanShowInMissionSelect(out bool showLocked, out string lockedMessage)
	{
		showLocked = false;
		lockedMessage = null;
		return true;
	}
}
[HarmonyPatch(typeof(MissionSelectWindow), "Awake")]
public class MissionSelectWindowInitPatch
{
	public static CraniusMission craniusMission;

	[HarmonyPostfix]
	public static void Postfix(MissionSelectWindow __instance)
	{
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Mission val = Global.Instance.Missions[0];
			SparrohPlugin.Logger.LogInfo((object)"CraniusHunt: Listing all regions and their scenes:");
			WorldRegion[] regions = Global.Instance.Regions;
			foreach (WorldRegion val2 in regions)
			{
				string text = string.Join(", ", val2.Scenes.Select((SceneData s) => s.scene));
				SparrohPlugin.Logger.LogInfo((object)("CraniusHunt: Region " + val2.NameID + " (" + val2.RegionName + ") has scenes: " + text));
			}
			craniusMission = ScriptableObject.CreateInstance<CraniusMission>();
			FieldInfo[] fields = typeof(Mission).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(craniusMission, fieldInfo.GetValue(val));
			}
			FieldInfo field = typeof(Mission).GetField("_missionName", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field != null)
			{
				field.SetValue(craniusMission, "Cranius Hunt");
			}
			FieldInfo field2 = typeof(Mission).GetField("_description", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field2 != null)
			{
				field2.SetValue(craniusMission, "Hunt down the secret boss Cranius!");
			}
			((Mission)craniusMission).MissionIcon = val.MissionIcon;
			((Mission)craniusMission).MissionColor = Color.magenta;
			((Mission)craniusMission).ShowInReplayMenu = false;
			((Mission)craniusMission).Selectable = true;
			Mission[] missions = Global.Instance.Missions;
			bool flag = false;
			Mission[] array = missions;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] is CraniusMission)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mission[] array2 = (Mission[])(object)new Mission[missions.Length + 1];
				Array.Copy(missions, array2, missions.Length);
				array2[missions.Length] = (Mission)(object)craniusMission;
				Global.Instance.Missions = array2;
			}
			if (PlayerData.Instance != null && PlayerData.Instance.GetFlag("cranius") == 0)
			{
				PlayerData.Instance.SetFlag("cranius", 1);
			}
			if (PlayerData.Instance.GetFlag("cranius") != 1)
			{
				PlayerData.Instance.SetFlag("cranius", 1);
			}
		}
		catch (Exception arg)
		{
			SparrohPlugin.Logger.LogError((object)$"Error in MissionSelectWindowInitPatch: {arg}");
		}
	}
}
[CompilerGenerated]
[ExcludeFromCodeCoverage]
internal static class GitVersionInformation
{
	public const string AssemblySemFileVer = "0.0.1.0";

	public const string AssemblySemVer = "0.0.1.0";

	public const string BranchName = "master";

	public const string BuildMetaData = "";

	public const string CommitDate = "2025-12-26";

	public const string CommitsSinceVersionSource = "4";

	public const string EscapedBranchName = "master";

	public const string FullBuildMetaData = "Branch.master.Sha.fefc36594d7ece82fdf9840a22830b403f478945";

	public const string FullSemVer = "0.0.1-4";

	public const string InformationalVersion = "0.0.1-4+Branch.master.Sha.fefc36594d7ece82fdf9840a22830b403f478945";

	public const string Major = "0";

	public const string MajorMinorPatch = "0.0.1";

	public const string Minor = "0";

	public const string Patch = "1";

	public const string PreReleaseLabel = "";

	public const string PreReleaseLabelWithDash = "";

	public const string PreReleaseNumber = "4";

	public const string PreReleaseTag = "4";

	public const string PreReleaseTagWithDash = "-4";

	public const string SemVer = "0.0.1-4";

	public const string Sha = "fefc36594d7ece82fdf9840a22830b403f478945";

	public const string ShortSha = "fefc365";

	public const string UncommittedChanges = "9";

	public const string VersionSourceSha = "";

	public const string WeightedPreReleaseNumber = "55004";
}
namespace CraniusHunt
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "CraniusHunt";

		public const string PLUGIN_NAME = "CraniusHunt";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}