using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Text.Json.Serialization;
using AK;
using Agents;
using AssetShards;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ChainedPuzzles;
using Enemies;
using FX_EffectSystem;
using GTFO.API;
using GTFO.API.Components;
using GTFO.API.JSON.Converters;
using GTFO.API.Wrappers;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using LevelGeneration;
using MTFO.Managers;
using Microsoft.CodeAnalysis;
using Player;
using PortalPuzzleChanger.ConfigFiles;
using PortalPuzzleChanger.GameScripts;
using PortalPuzzleChanger.Plugin;
using SNetwork;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PortalPuzzleChanger")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PortalPuzzleChanger")]
[assembly: AssemblyTitle("PortalPuzzleChanger")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
namespace PortalPuzzleChanger.Plugin
{
	[BepInPlugin("com.Breeze.PortalPuzzleChanger", "PortalPuzzleChanger", "0.0.1")]
	[BepInProcess("GTFO.exe")]
	internal class EntryPoint : BasePlugin
	{
		public static Dictionary<string, Sprite> CachedSprites;

		public static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
		{
			ReadCommentHandling = JsonCommentHandling.Skip,
			PropertyNameCaseInsensitive = true,
			IncludeFields = true,
			AllowTrailingCommas = true,
			WriteIndented = true
		};

		public static ManualLogSource? LogSource { get; private set; }

		public static Harmony? m_Harmony { get; private set; }

		public override void Load()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			LogSource = ((BasePlugin)this).Log;
			m_Harmony = new Harmony("_PortalPuzzleChanger_");
			m_Harmony.PatchAll();
			SerializerOptions.Converters.Add((JsonConverter)new LocalizedTextConverter());
			SerializerOptions.Converters.Add((JsonConverter)new Vector3Converter());
			SerializerOptions.Converters.Add((JsonConverter)new Vector2Converter());
			SerializerOptions.Converters.Add((JsonConverter)new ColorConverter());
			PortalPuzzleChangerSetup.Load();
			EnemyTagChangerConfigSetup.Load();
			GrenadeLauncherConfigSetup.Load();
			ClassInjector.RegisterTypeInIl2Cpp<GrenadeProjectile>();
			AssetAPI.OnAssetBundlesLoaded += OnAssetsLoaded;
		}

		public void OnAssetsLoaded()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyTagChanger> list = EnemyTagChangerConfigSetup.EnabledConfigs.Values.ToList();
			for (int i = 0; i < list.Count; i++)
			{
				if (!string.IsNullOrEmpty(list[i].CustomImagePath))
				{
					Texture2D loadedAsset = AssetAPI.GetLoadedAsset<Texture2D>(list[i].CustomImagePath);
					Sprite val = Sprite.Create(loadedAsset, new Rect(0f, 0f, (float)((Texture)loadedAsset).width, (float)((Texture)loadedAsset).height), new Vector2(0.5f, 0.5f), 64f);
					((Object)val).hideFlags = (HideFlags)61;
					((Object)val).name = list[i].CustomImagePath;
					CachedSprites.Add(((Object)val).name, val);
					Debug("Created a sprite from path: " + list[i].CustomImagePath);
				}
			}
		}

		public static void Debug(string message)
		{
			LogSource.LogDebug((object)("[DEBUG] " + message));
		}

		public static void DebugWarning(string message)
		{
			LogSource.LogWarning((object)("[WARNING] " + message));
		}

		public static void DebugError(string message)
		{
			LogSource.LogError((object)("[ERROR] " + message));
		}
	}
	public class PortalPuzzleChangerSetup
	{
		public static Dictionary<uint, List<PortalEntry>> EnabledConfigs = new Dictionary<uint, List<PortalEntry>>();

		private static List<PortalChangerConfig>? Configs;

		public static string Name { get; } = "PortalPuzzleChanger.json";


		public static void Load()
		{
			string path = Path.Combine(ConfigManager.CustomPath, Name);
			if (File.Exists(path))
			{
				Configs = JsonSerializer.Deserialize<List<PortalChangerConfig>>(File.ReadAllText(path), EntryPoint.SerializerOptions);
				EntryPoint.Debug(Name + " has loaded successfully");
			}
			else
			{
				Configs = new List<PortalChangerConfig>
				{
					new PortalChangerConfig()
				};
				string contents = JsonSerializer.Serialize(Configs, EntryPoint.SerializerOptions);
				File.WriteAllText(path, contents);
				EntryPoint.DebugWarning(Name + " did not exist, creating it now");
			}
			EnabledConfigs.Clear();
			int count = Configs.Count;
			for (int i = 0; i < count; i++)
			{
				if (Configs[i].InternalEnabled)
				{
					EnabledConfigs.Add(Configs[i].MainLevelLayoutID, Configs[i].PortalEntries);
				}
			}
		}
	}
	public class EnemyTagChangerConfigSetup
	{
		public static Dictionary<uint, EnemyTagChanger> EnabledConfigs = new Dictionary<uint, EnemyTagChanger>();

		private static List<EnemyTagChanger>? Configs;

		public static string Name { get; } = "EnemyTags.json";


		public static void Load()
		{
			string path = Path.Combine(ConfigManager.CustomPath, Name);
			if (File.Exists(path))
			{
				Configs = JsonSerializer.Deserialize<List<EnemyTagChanger>>(File.ReadAllText(path), EntryPoint.SerializerOptions);
				EntryPoint.Debug(Name + " has loaded successfully");
			}
			else
			{
				Configs = new List<EnemyTagChanger>
				{
					new EnemyTagChanger()
				};
				string contents = JsonSerializer.Serialize(Configs, EntryPoint.SerializerOptions);
				File.WriteAllText(path, contents);
				EntryPoint.DebugWarning(Name + " did not exist, creating it now");
			}
			EnabledConfigs.Clear();
			int count = Configs.Count;
			for (int i = 0; i < count; i++)
			{
				if (Configs[i].internalEnabled)
				{
					EnabledConfigs.Add(Configs[i].EnemyID, Configs[i]);
				}
			}
		}
	}
	public class GrenadeLauncherConfigSetup
	{
		public static Dictionary<uint, GrenadeLauncherConfig> EnabledConfigs = new Dictionary<uint, GrenadeLauncherConfig>();

		private static List<GrenadeLauncherConfig>? Configs;

		public static string Name { get; } = "GrenadeLauncher.json";


		public static void Load()
		{
			string path = Path.Combine(ConfigManager.CustomPath, Name);
			if (File.Exists(path))
			{
				Configs = JsonSerializer.Deserialize<List<GrenadeLauncherConfig>>(File.ReadAllText(path), EntryPoint.SerializerOptions);
				EntryPoint.Debug(Name + " has loaded successfully");
			}
			else
			{
				Configs = new List<GrenadeLauncherConfig>
				{
					new GrenadeLauncherConfig()
				};
				string contents = JsonSerializer.Serialize(Configs, EntryPoint.SerializerOptions);
				File.WriteAllText(path, contents);
				EntryPoint.DebugWarning(Name + " did not exist, creating it now");
			}
			EnabledConfigs.Clear();
			int count = Configs.Count;
			for (int i = 0; i < count; i++)
			{
				if (Configs[i].internalEnabled)
				{
					EnabledConfigs.Add(Configs[i].PersistentID, Configs[i]);
				}
			}
		}
	}
}
namespace PortalPuzzleChanger.Patches
{
	[HarmonyPatch(typeof(LG_DimensionPortal), "Setup")]
	public static class DimensionPortalPatch
	{
		public static void Prefix(LG_DimensionPortal __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (!PortalPuzzleChangerSetup.EnabledConfigs.ContainsKey(RundownManager.ActiveExpedition.LevelLayoutData))
			{
				return;
			}
			(eDimensionIndex, LG_LayerType, eLocalZoneIndex) original = (__instance.SpawnNode.m_dimension.DimensionIndex, __instance.SpawnNode.LayerType, __instance.SpawnNode.m_zone.LocalIndex);
			List<PortalEntry> list = PortalPuzzleChangerSetup.EnabledConfigs[RundownManager.ActiveExpedition.LevelLayoutData];
			foreach (PortalEntry item in list)
			{
				(eDimensionIndex, LG_LayerType, eLocalZoneIndex) comparingTo = (item.DimensionIndex, item.LayerType, item.ZoneIndex);
				if (DoesZoneMatch(original, comparingTo))
				{
					__instance.m_targetDimension = item.TargetDimension;
					__instance.m_targetZone = item.TargetZoneIndex;
					__instance.PortalChainPuzzle = item.PortalChainedPuzzleId;
					EntryPoint.Debug("Changing the ChainedPuzzleID on " + __instance.PublicName);
				}
			}
		}

		public static void Postfix(LG_DimensionPortal __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if (!PortalPuzzleChangerSetup.EnabledConfigs.ContainsKey(RundownManager.ActiveExpedition.LevelLayoutData))
			{
				return;
			}
			(eDimensionIndex, LG_LayerType, eLocalZoneIndex) original = (__instance.SpawnNode.m_dimension.DimensionIndex, __instance.SpawnNode.LayerType, __instance.SpawnNode.m_zone.LocalIndex);
			List<PortalEntry> list = PortalPuzzleChangerSetup.EnabledConfigs[RundownManager.ActiveExpedition.LevelLayoutData];
			foreach (PortalEntry item in list)
			{
				(eDimensionIndex, LG_LayerType, eLocalZoneIndex) comparingTo = (item.DimensionIndex, item.LayerType, item.ZoneIndex);
				if (DoesZoneMatch(original, comparingTo) && item.CreateTeamScanAsLast)
				{
					ChainedPuzzleInstance puzzleInstance = ChainedPuzzleManager.CreatePuzzleInstance(4u, __instance.SpawnNode.m_area, __instance.m_portalBioScanPoint.position, __instance.m_portalBioScanPoint);
					puzzleInstance.OnPuzzleSolved = __instance.m_portalChainPuzzleInstance.OnPuzzleSolved;
					__instance.m_portalChainPuzzleInstance.OnPuzzleSolved = Action.op_Implicit((Action)delegate
					{
						puzzleInstance.AttemptInteract((eChainedPuzzleInteraction)0);
					});
					EntryPoint.Debug("Adding team scan on " + __instance.PublicName);
				}
			}
		}

		private static bool DoesZoneMatch((eDimensionIndex, LG_LayerType, eLocalZoneIndex) original, (eDimensionIndex, LG_LayerType, eLocalZoneIndex) comparingTo)
		{
			//IL_0006: 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)
			//IL_0014: 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_0022: 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)
			(eDimensionIndex, LG_LayerType, eLocalZoneIndex) tuple = original;
			(eDimensionIndex, LG_LayerType, eLocalZoneIndex) tuple2 = comparingTo;
			return tuple.Item1 == tuple2.Item1 && tuple.Item2 == tuple2.Item2 && tuple.Item3 == tuple2.Item3;
		}
	}
	[HarmonyPatch(typeof(HackingTool), "Setup")]
	public static class HackingToolTest
	{
		public static void Postfix(HackingTool __instance)
		{
		}
	}
	[HarmonyPatch(typeof(EnemyAgent), "SyncPlaceNavMarkerTag")]
	internal static class EnemyTagPatch
	{
		public static void Postfix(EnemyAgent __instance)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (EnemyTagChangerConfigSetup.EnabledConfigs.ContainsKey(__instance.EnemyDataID))
			{
				EnemyTagChanger enemyTagChanger = EnemyTagChangerConfigSetup.EnabledConfigs[__instance.EnemyDataID];
				NavMarker tagMarker = __instance.m_tagMarker;
				if (!string.IsNullOrEmpty(enemyTagChanger.CustomImagePath))
				{
					SpriteRenderer component = ((Component)tagMarker.m_enemySubObj).GetComponent<SpriteRenderer>();
					component.sprite = EntryPoint.CachedSprites[enemyTagChanger.CustomImagePath];
				}
				tagMarker.SetColor(enemyTagChanger.TagColor);
			}
		}
	}
	[HarmonyPatch(typeof(GrenadeBase), "Awake")]
	internal static class GrenadeBase_Setup
	{
		public static void Postfix(GrenadeBase __instance)
		{
			GrenadeProjectile grenadeProjectile = ((Component)__instance).gameObject.AddComponent<GrenadeProjectile>();
			((Behaviour)grenadeProjectile).enabled = true;
			grenadeProjectile.GrenadeBase = __instance;
		}
	}
	[HarmonyPatch(typeof(GrenadeBase), "GrenadeDelay")]
	internal static class GrenadeBase_GrenadeDelay
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(GrenadeBase), "Start")]
	internal static class GrenadeBase_Start
	{
		public static void Postfix(GrenadeBase __instance)
		{
			((MonoBehaviour)__instance).CancelInvoke("GrenadeDelay");
		}
	}
	[HarmonyPatch(typeof(BulletWeapon), "Fire")]
	internal static class BulletWeapon_Fire
	{
		public static void Prefix(BulletWeapon __instance)
		{
			if (GrenadeLauncherConfigSetup.EnabledConfigs.ContainsKey(((ItemEquippable)__instance).ArchetypeID))
			{
				GrenadeLauncherConfig config = GrenadeLauncherConfigSetup.EnabledConfigs[((ItemEquippable)__instance).ArchetypeID];
				GrenadeLauncherFire.Fire(__instance, config);
			}
		}
	}
	internal static class GrenadeLauncherFire
	{
		public static void Fire(BulletWeapon weapon, GrenadeLauncherConfig config)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			pItemData val = default(pItemData);
			val.itemID_gearCRC = 136u;
			Vector3 targetLookDir = ((Agent)((Item)weapon).Owner).TargetLookDir;
			Vector3 normalized = ((Vector3)(ref targetLookDir)).normalized;
			ItemReplicationManager.ThrowItem(val, (delItemCallback)null, (ItemMode)3, ((Component)((ItemEquippable)weapon).MuzzleAlign).transform.position, ((Component)((ItemEquippable)weapon).MuzzleAlign).transform.rotation, normalized * config.ShootForce, ((Component)weapon).transform.position, ((Agent)((Item)weapon).Owner).CourseNode, ((Item)weapon).Owner);
			((Weapon)weapon).MaxRayDist = 0f;
		}
	}
}
namespace PortalPuzzleChanger.GameScripts
{
	public class GrenadeProjectile : ConsumableInstance
	{
		public GrenadeBase GrenadeBase;

		private static FX_Pool explosionPool;

		private float damageRadiusHigh;

		private float damageRadiusLow;

		private float damageValueHigh;

		private float damageValueLow;

		private float explosionForce;

		private readonly int explosionTargetMask = LayerManager.MASK_EXPLOSION_TARGETS;

		private readonly int explosionBlockMask = LayerManager.MASK_EXPLOSION_BLOCKERS;

		private bool madeNoise = false;

		private bool collision = false;

		private bool addForce = false;

		private float decayTime;

		private Rigidbody rigidbody;

		private CellSoundPlayer cellSoundPlayer;

		public GrenadeProjectile(IntPtr hdl)
			: base(hdl)
		{
		}

		private void Awake()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			rigidbody = ((Component)this).GetComponent<Rigidbody>();
			cellSoundPlayer = new CellSoundPlayer();
			if (!Object.op_Implicit((Object)(object)explosionPool))
			{
				explosionPool = FX_Manager.GetEffectPool(AssetShardManager.GetLoadedAsset<GameObject>("Assets/AssetPrefabs/FX_Effects/FX_Tripmine.prefab", false));
			}
		}

		private void Start()
		{
			GrenadeLauncherConfig grenadeLauncherConfig = GrenadeLauncherConfigSetup.EnabledConfigs[((Item)GrenadeBase).Owner.Inventory.WieldedItem.ArchetypeID];
			damageRadiusHigh = grenadeLauncherConfig.MaximumDamageRange.Radius;
			damageRadiusLow = grenadeLauncherConfig.MinimumDamageRange.Radius;
			damageValueHigh = grenadeLauncherConfig.MaximumDamageRange.Damage;
			damageValueLow = grenadeLauncherConfig.MinimumDamageRange.Damage;
			explosionForce = grenadeLauncherConfig.ExplosionForce;
		}

		private void FixedUpdate()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (rigidbody.useGravity)
			{
				Vector3 val = ((Component)this).transform.position + rigidbody.velocity * Time.fixedDeltaTime;
			}
			else if (!madeNoise)
			{
				MakeNoise();
				((Component)this).transform.position = Vector3.down * 100f;
				madeNoise = true;
			}
		}

		private void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (rigidbody.useGravity)
			{
				cellSoundPlayer.UpdatePosition(((Component)this).transform.position);
				if (collision)
				{
					DetonateSequence();
				}
			}
			else if (Time.time > decayTime)
			{
				((Item)GrenadeBase).ReplicationWrapper.Replicator.Despawn();
			}
		}

		private void OnCollisionEnter()
		{
			if (rigidbody.useGravity)
			{
				DetonateSequence();
			}
		}

		private void DetonateSequence()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Detonate();
			decayTime = Time.time + 10f;
			rigidbody.velocity = Vector3.zero;
			rigidbody.angularVelocity = Vector3.zero;
			rigidbody.useGravity = false;
		}

		private void Detonate()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			FX_EffectBase val = (FX_EffectBase)(object)explosionPool.AquireEffect();
			val.Play((FX_Trigger)null, ((Component)this).transform.position, Quaternion.LookRotation(Vector3.up));
			if (SNet.IsMaster)
			{
				DamageUtil.DoExplosionDamage(((Component)this).transform.position, damageRadiusHigh, damageValueHigh, explosionTargetMask, explosionBlockMask, addForce, explosionForce);
				DamageUtil.DoExplosionDamage(((Component)this).transform.position, damageRadiusLow, damageValueLow, explosionTargetMask, explosionBlockMask, addForce, explosionForce);
			}
		}

		private void MakeNoise()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			List<string> list = new List<string>();
			Il2CppReferenceArray<Collider> val = Physics.OverlapSphere(((Component)this).transform.position, 50f, LayerManager.MASK_ENEMY_DAMAGABLE);
			foreach (Collider item in (Il2CppArrayBase<Collider>)(object)val)
			{
				Dam_EnemyDamageLimb component = ((Component)item).GetComponent<Dam_EnemyDamageLimb>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				EnemyAgent glueTargetEnemyAgent = component.GlueTargetEnemyAgent;
				if (!((Object)(object)glueTargetEnemyAgent == (Object)null) && !list.Contains(((Object)((Component)glueTargetEnemyAgent).gameObject).name))
				{
					list.Add(((Object)((Component)glueTargetEnemyAgent).gameObject).name);
					if (!Physics.Linecast(((Component)this).transform.position, ((Agent)glueTargetEnemyAgent).EyePosition, LayerManager.MASK_WORLD))
					{
						NM_NoiseData val2 = new NM_NoiseData
						{
							position = ((Agent)glueTargetEnemyAgent).EyePosition,
							node = ((Agent)glueTargetEnemyAgent).CourseNode,
							type = (NM_NoiseType)0,
							radiusMin = 0.01f,
							radiusMax = 100f,
							yScale = 1f,
							noiseMaker = null,
							raycastFirstNode = false,
							includeToNeightbourAreas = false
						};
						NoiseManager.MakeNoise(val2);
					}
				}
			}
			cellSoundPlayer.Post(EVENTS.FRAGGRENADEEXPLODE, true);
		}

		public override void OnDespawn()
		{
			((ItemWrapped)this).OnDespawn();
		}
	}
}
namespace PortalPuzzleChanger.ConfigFiles
{
	public class EnemyTagChanger
	{
		public bool internalEnabled { get; set; }

		public string internalName { get; set; }

		public uint EnemyID { get; set; }

		public Color TagColor { get; set; }

		public string CustomImagePath { get; set; }

		public EnemyTagChanger()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			internalEnabled = false;
			internalName = string.Empty;
			EnemyID = 0u;
			TagColor = Color.red;
			CustomImagePath = string.Empty;
		}
	}
	public class GrenadeLauncherConfig
	{
		public DamageMinMax MaximumDamageRange { get; set; }

		public DamageMinMax MinimumDamageRange { get; set; }

		public float ExplosionForce { get; set; }

		public float ShootForce { get; set; }

		public uint PersistentID { get; set; }

		public string internalName { get; set; }

		public bool internalEnabled { get; set; }

		public GrenadeLauncherConfig()
		{
			MaximumDamageRange = new DamageMinMax();
			MinimumDamageRange = new DamageMinMax();
			ExplosionForce = 1000f;
			PersistentID = 0u;
			internalName = string.Empty;
			internalEnabled = false;
		}
	}
	public class DamageMinMax
	{
		public float Radius { get; set; }

		public float Damage { get; set; }

		public DamageMinMax()
		{
			Radius = 0f;
			Damage = 0f;
		}
	}
	public class PortalChangerConfig
	{
		public uint MainLevelLayoutID { get; set; }

		public bool InternalEnabled { get; set; }

		public string? InternalName { get; set; }

		public List<PortalEntry> PortalEntries { get; set; }

		public PortalChangerConfig()
		{
			PortalEntries = new List<PortalEntry>
			{
				new PortalEntry()
			};
			InternalEnabled = false;
			InternalName = "Test";
			MainLevelLayoutID = 0u;
		}
	}
	public class PortalEntry
	{
		public eLocalZoneIndex ZoneIndex { get; set; }

		public LG_LayerType LayerType { get; set; }

		public eDimensionIndex DimensionIndex { get; set; }

		public eDimensionIndex TargetDimension { get; set; }

		public eLocalZoneIndex TargetZoneIndex { get; set; }

		public uint PortalChainedPuzzleId { get; set; }

		public bool CreateTeamScanAsLast { get; set; }

		public PortalEntry()
		{
			ZoneIndex = (eLocalZoneIndex)0;
			LayerType = (LG_LayerType)0;
			DimensionIndex = (eDimensionIndex)0;
			TargetDimension = (eDimensionIndex)1;
			TargetZoneIndex = (eLocalZoneIndex)0;
			PortalChainedPuzzleId = 4u;
			CreateTeamScanAsLast = false;
		}
	}
}

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils;
using DropServer.VanityItems;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AllVanity")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyProduct("AllVanity")]
[assembly: AssemblyTitle("AllVanity")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AllVanity;

[BepInPlugin("dev.aurirex.gtfo.allvanity", "All Vanity", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInIncompatibility("com.mccad00.AmongDrip")]
public class EntryPoint : BasePlugin
{
	public const string GUID = "dev.aurirex.gtfo.allvanity";

	public const string NAME = "All Vanity";

	public const string VERSION = "1.0.0";

	public const string DEVIOUSLICK_GUID = "com.mccad00.AmongDrip";

	public const string NOBOOSTERS_GUID = "dev.aurirex.gtfo.noboosters";

	private Harmony _harmonyInstance;

	internal static ManualLogSource L;

	internal static bool noboostersLoaded;

	public override void Load()
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Expected O, but got Unknown
		L = ((BasePlugin)this).Log;
		noboostersLoaded = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Any((KeyValuePair<string, PluginInfo> kvp) => kvp.Key == "dev.aurirex.gtfo.noboosters");
		((BasePlugin)this).Log.LogInfo((object)"Applying Patches ...");
		_harmonyInstance = new Harmony("dev.aurirex.gtfo.allvanity");
		_harmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
	}
}
internal class Patches
{
	[HarmonyPriority(500)]
	[HarmonyPatch(typeof(PersistentInventoryManager), "CommitPendingTransactions")]
	internal static class PersistentInventoryManager_CommitPendingTransactions_Patch
	{
		private static bool _dirtyFlag;

		public static bool Prefix(PersistentInventoryManager __instance)
		{
			if (EntryPoint.noboostersLoaded)
			{
				if (PersistentInventoryManager.m_dirty)
				{
					Unlock.SetupVanityInventory();
					PersistentInventoryManager.m_dirty = false;
					return false;
				}
				return true;
			}
			if (PersistentInventoryManager.m_dirty || __instance.m_vanityItemPendingTransactions.IsDirty())
			{
				_dirtyFlag = true;
				return true;
			}
			if (_dirtyFlag)
			{
				MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)__instance, Unlock.DelayedSetupVanity());
				_dirtyFlag = false;
			}
			return true;
		}
	}
}
public class Unlock
{
	public static IEnumerator DelayedSetupVanity()
	{
		EntryPoint.L.LogDebug((object)"Delayed Setup ...");
		yield return (object)new WaitForSeconds(0.5f);
		SetupVanityInventory();
	}

	public static void SetupVanityInventory()
	{
		EntryPoint.L.LogWarning((object)"Setting up Vanity Item Inventory!");
		PersistentInventoryManager.Current.m_vanityItemsInventory.UpdateItems(CreateVanityPlayerData());
	}

	internal static VanityItemPlayerData CreateVanityPlayerData()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		VanityItemPlayerData val = new VanityItemPlayerData(ClassInjector.DerivedConstructorPointer<VanityItemPlayerData>());
		Il2CppArrayBase<VanityItemsTemplateDataBlock> allBlocks = GameDataBlockBase<VanityItemsTemplateDataBlock>.GetAllBlocks();
		Il2CppReferenceArray<VanityItem> val2 = new Il2CppReferenceArray<VanityItem>((long)allBlocks.Count);
		int num = 0;
		foreach (VanityItemsTemplateDataBlock item in allBlocks)
		{
			VanityItem val3 = new VanityItem(ClassInjector.DerivedConstructorPointer<VanityItem>())
			{
				Flags = (InventoryItemFlags)3,
				ItemId = ((GameDataBlockBase<VanityItemsTemplateDataBlock>)(object)item).persistentID
			};
			((Il2CppArrayBase<VanityItem>)(object)val2)[num] = val3;
			num++;
		}
		val.Items = val2;
		return val;
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("NoBoosters")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyProduct("NoBoosters")]
[assembly: AssemblyTitle("NoBoosters")]
[assembly: AssemblyVersion("1.1.0.0")]
namespace NoBoosters;

[BepInPlugin("dev.aurirex.gtfo.noboosters", "No Boosters", "1.1.0")]
[BepInIncompatibility("com.mccad00.AmongDrip")]
public class EntryPoint : BasePlugin
{
	public const string PLUGIN_GUID = "dev.aurirex.gtfo.noboosters";

	public const string PLUGIN_NAME = "No Boosters";

	public const string PLUGIN_VERSION = "1.1.0";

	public const string DEVIOUSLICK_GUID = "com.mccad00.AmongDrip";

	private Harmony _harmony;

	internal static ManualLogSource L;

	public override void Load()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		L = ((BasePlugin)this).Log;
		_harmony = new Harmony("dev.aurirex.gtfo.noboosters");
		_harmony.PatchAll(Assembly.GetExecutingAssembly());
		((BasePlugin)this).Log.LogInfo((object)"Loaded and patched!");
	}
}
internal class Patches
{
	[HarmonyPatch(typeof(GameStateManager), "DoChangeState")]
	public static class GameStateManager_DoChangeState_Patch
	{
		public static void Postfix(eGameStateName nextState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if ((int)nextState == 6)
			{
				ManualLogSource l = EntryPoint.L;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(10, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Disabling ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("PersistentInventoryManager");
				}
				l.LogInfo(val);
				((Behaviour)PersistentInventoryManager.Current).enabled = false;
			}
		}
	}

	[HarmonyPatch(typeof(PersistentInventoryManager), "OnLevelCleanup")]
	public static class PersistentInventoryManager_OnLevelCleanup_Patch
	{
		public static void Prefix(PersistentInventoryManager __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ManualLogSource l = EntryPoint.L;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(9, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Enabling ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("PersistentInventoryManager");
			}
			l.LogInfo(val);
			((Behaviour)__instance).enabled = true;
		}
	}

	[HarmonyPriority(0)]
	[HarmonyPatch(typeof(PersistentInventoryManager), "CommitPendingTransactions")]
	public static class PersistentInventoryManager_CommitPendingTransactions_Patch
	{
		public static bool Prefix()
		{
			return false;
		}
	}

	[HarmonyPatch(typeof(CM_PlayerLobbyBar), "SetupFromPage")]
	public static class CM_PlayerLobbyBar_SetupFromPage_Patch
	{
		public static void Postfix(CM_PlayerLobbyBar __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			__instance.m_boosterImplantAlign.position = new Vector3(10000f, 0f, 0f);
			((Component)__instance.m_clothesButton).transform.localPosition = new Vector3(170f, -510f, 0f);
		}
	}

	[HarmonyPatch(typeof(PUI_BoosterIconActiveDisplay), "UpdateBoosterIconsActiveState")]
	public static class PUI_BoosterIconActiveDisplay_UpdateBoosterIconsActiveState_Patch
	{
		public static bool Prefix(PUI_BoosterIconActiveDisplay __instance)
		{
			((Component)__instance).gameObject.SetActive(false);
			return false;
		}
	}

	[HarmonyPatch(typeof(PUI_BoosterDetails), "SetupBoosterDetails")]
	public static class PUI_BoosterDetails_SetupBoosterDetails_Patch
	{
		public static void Postfix(PUI_BoosterDetails __instance)
		{
			((Component)__instance).gameObject.SetActive(false);
		}
	}

	[HarmonyPatch(typeof(PUI_BoosterDetails), "UpdateButtonActiveCheck")]
	public static class PUI_BoosterDetails_UpdateButtonActiveCheck_Patch
	{
		public static bool Prefix(PUI_BoosterDetails __instance)
		{
			((Component)__instance.m_leftButton).gameObject.SetActive(false);
			((Component)__instance.m_rightButton).gameObject.SetActive(false);
			return false;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BoosterImplants;
using Clonesoft.Json;
using DropServer;
using DropServer.BoosterImplants;
using DropServer.VanityItems;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Threading.Tasks;
using SimpleProgression.Impl;
using SimpleProgression.Interfaces;
using SimpleProgression.Progression;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyFileVersion("0.0.1")]
[assembly: AssemblyInformationalVersion("0.0.1")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SimpleProgression")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyProduct("SimpleProgression")]
[assembly: AssemblyTitle("SimpleProgression")]
[assembly: AssemblyVersion("0.0.1.0")]
namespace SimpleProgression
{
	public class LocalProgressionManager
	{
		private string _loadedRundownKey;

		public static LocalProgressionManager Instance { get; private set; }

		public static string SavePath { get; private set; }

		public ExpeditionSession CurrentActiveSession { get; private set; }

		public ILogger Logger { get; set; }

		public LocalRundownProgression CurrentLoadedLocalProgressionData { get; private set; } = null;


		public bool HasLocalRundownProgressionLoaded => CurrentLoadedLocalProgressionData != null;

		public static event Action<ExpeditionCompletionData> OnExpeditionCompleted;

		public LocalProgressionManager()
		{
			if (Instance != null)
			{
				throw new InvalidOperationException("One instance already exists!");
			}
			SavePath = Path.Combine(Paths.BepInExRootPath, "LocalProgression/");
			Directory.CreateDirectory(SavePath);
			Instance = this;
		}

		public LocalRundownProgression GetOrCreateLocalProgression(string rundownKeyToLoad)
		{
			if (string.IsNullOrEmpty(rundownKeyToLoad))
			{
				throw new ArgumentException("rundownKeyToLoad");
			}
			if (!HasLocalRundownProgressionLoaded)
			{
				CurrentLoadedLocalProgressionData = LoadFromProgressionFile(rundownKeyToLoad);
				return CurrentLoadedLocalProgressionData;
			}
			if (rundownKeyToLoad == _loadedRundownKey)
			{
				return CurrentLoadedLocalProgressionData;
			}
			Logger.Debug($"{"GetOrCreateLocalProgression"}() {"rundownKeyToLoad"} changed. ({_loadedRundownKey} -> {rundownKeyToLoad})");
			SaveToProgressionFile(CurrentLoadedLocalProgressionData);
			CurrentLoadedLocalProgressionData = LoadFromProgressionFile(rundownKeyToLoad);
			return CurrentLoadedLocalProgressionData;
		}

		public void Init()
		{
			Logger.Msg(ConsoleColor.Magenta, "New Progression Manager has inited!");
		}

		public void StartNewExpeditionSession(string rundownId, string expeditionId, string sessionId)
		{
			CurrentActiveSession = ExpeditionSession.InitNewSession(rundownId, expeditionId, sessionId, Logger);
		}

		public void OnLevelEntered()
		{
			CurrentActiveSession?.OnLevelEntered();
		}

		public void IncreaseLayerProgression(string strLayer, string strState)
		{
			if (!Enum.TryParse<Layers>(strLayer, out var result) | !Enum.TryParse<LayerState>(strState, out var result2))
			{
				Logger.Error($"Either {"Layers"} and/or {"LayerState"} could not be parsed! ({strLayer}, {strState})");
			}
			else
			{
				CurrentActiveSession?.SetLayer(result, result2);
			}
		}

		public void SaveAtCheckpoint()
		{
			CurrentActiveSession?.OnCheckpointSave();
		}

		public void ReloadFromCheckpoint()
		{
			CurrentActiveSession?.OnCheckpointReset();
		}

		public void ArtifactCountUpdated(int count)
		{
			if (CurrentActiveSession != null)
			{
				CurrentActiveSession.ArtifactsCollected = count;
				Logger.Info($"current Artifact count: {count}");
			}
		}

		public void EndCurrentExpeditionSession(bool success)
		{
			CurrentActiveSession?.OnExpeditionCompleted(success);
			GetOrCreateLocalProgression(CurrentActiveSession.RundownId);
			ExpeditionCompletionData completionData;
			bool flag = CurrentLoadedLocalProgressionData.AddSessionResults(CurrentActiveSession, out completionData);
			CurrentActiveSession = null;
			SaveToProgressionFile(CurrentLoadedLocalProgressionData);
			if (flag)
			{
				Logger.Notice($"Expedition time: {completionData.RawSessionData.EndTime - completionData.RawSessionData.StartTime}");
				LocalProgressionManager.OnExpeditionCompleted?.Invoke(completionData);
			}
		}

		public void SaveToProgressionFile(LocalRundownProgression data)
		{
			SaveToProgressionFile(data, _loadedRundownKey, out var path);
			Instance.Logger.Msg(ConsoleColor.DarkRed, "Saved progression file to disk at: " + path);
		}

		public static void SaveToProgressionFile(LocalRundownProgression data, string rundownKeyToSave, out string path)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			if (string.IsNullOrEmpty(rundownKeyToSave))
			{
				throw new InvalidOperationException("rundownKeyToSave");
			}
			path = GetLocalProgressionFilePath(rundownKeyToSave);
			string contents = JsonConvert.SerializeObject((object)data, (Formatting)1);
			File.WriteAllText(path, contents);
		}

		public static string GetLocalProgressionFilePath(string rundownKey)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				rundownKey = rundownKey.Replace(oldChar, '_');
			}
			return Path.Combine(SavePath, rundownKey + ".json");
		}

		public LocalRundownProgression LoadFromProgressionFile(string rundownKey)
		{
			string path;
			bool isNew;
			LocalRundownProgression localRundownProgression = LoadFromProgressionFile(rundownKey, out path, out isNew);
			_loadedRundownKey = rundownKey;
			if (isNew)
			{
				Instance.Logger.Msg(ConsoleColor.Green, "Created progression file at: " + path);
				SaveToProgressionFile(localRundownProgression, _loadedRundownKey, out var path2);
				Instance.Logger.Msg(ConsoleColor.DarkRed, "Saved fresh progression file to disk at: " + path2);
			}
			else
			{
				Instance.Logger.Msg(ConsoleColor.Green, "Loaded progression file from disk at: " + path);
			}
			return localRundownProgression;
		}

		public static LocalRundownProgression LoadFromProgressionFile(string rundownKey, out string path, out bool isNew)
		{
			path = GetLocalProgressionFilePath(rundownKey);
			if (!File.Exists(path))
			{
				isNew = true;
				return new LocalRundownProgression();
			}
			isNew = false;
			string text = File.ReadAllText(path);
			return JsonConvert.DeserializeObject<LocalRundownProgression>(text);
		}
	}
	public class Logger : ILogger
	{
		private readonly ManualLogSource _log;

		public Logger(ManualLogSource logger)
		{
			_log = logger;
		}

		public void Debug(string msg)
		{
			_log.LogDebug((object)msg);
		}

		public void Error(string msg)
		{
			_log.LogError((object)msg);
		}

		public void Exception(Exception ex)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ManualLogSource log = _log;
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(3, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetType().Name);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.StackTrace);
			}
			log.LogError(val);
		}

		public void Fail(string msg)
		{
			_log.LogError((object)msg);
		}

		public void Info(string msg)
		{
			_log.LogMessage((object)msg);
		}

		public void Msg(ConsoleColor col, string msg)
		{
			_log.LogMessage((object)msg);
		}

		public void Notice(string msg)
		{
			_log.LogWarning((object)msg);
		}

		public void Success(string msg)
		{
			_log.LogMessage((object)msg);
		}

		public void Warning(string msg)
		{
			_log.LogWarning((object)msg);
		}
	}
	[BepInPlugin("dev.aurirex.gtfo.simpleprogression", "Simple Progression", "0.0.1")]
	public class Plugin : BasePlugin
	{
		public const string GUID = "dev.aurirex.gtfo.simpleprogression";

		public const string NAME = "Simple Progression";

		public const string VERSION = "0.0.1";

		internal static Logger L;

		private static Harmony _harmony;

		public override void Load()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			L = new Logger(((BasePlugin)this).Log);
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExMessageLogInterpolatedStringHandler val = new BepInExMessageLogInterpolatedStringHandler(13, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initializing ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Simple Progression");
			}
			log.LogMessage(val);
			RegisterTypeOptions val2 = new RegisterTypeOptions();
			val2.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(new Type[2]
			{
				typeof(IDropServerGameSession),
				typeof(IDisposable)
			}));
			val2.set_LogSuccess(true);
			ClassInjector.RegisterTypeInIl2Cpp<LocalGameSession>(val2);
			val2 = new RegisterTypeOptions();
			val2.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(new Type[1] { typeof(IDropServerClientAPI) }));
			val2.set_LogSuccess(true);
			ClassInjector.RegisterTypeInIl2Cpp<LocalDropServerAPI>(val2);
			new LocalProgressionManager().Logger = L;
			_harmony = new Harmony("dev.aurirex.gtfo.simpleprogression");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
		}
	}
	public class LocalRundownProgression
	{
		public class Expedition
		{
			public class Layer
			{
				public LayerState State = LayerState.Undiscovered;

				public int CompletionCount = 0;

				public void IncreaseStateAndCompletion(LayerState newState)
				{
					if (State < newState)
					{
						State = newState;
					}
					if (newState == LayerState.Completed)
					{
						CompletionCount++;
					}
				}

				public static Layer FromBaseGame(Layer baseGameType)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					return new Layer
					{
						State = baseGameType.State.ToCustom(),
						CompletionCount = baseGameType.CompletionCount
					};
				}

				public Layer ToBaseGame()
				{
					//IL_0003: Unknown result type (might be due to invalid IL or missing references)
					//IL_001e: Unknown result type (might be due to invalid IL or missing references)
					//IL_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_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					Layer result = default(Layer);
					result.CompletionCount = CompletionCount;
					result.State = State.ToBasegame();
					return result;
				}
			}

			public int AllLayerCompletionCount = 0;

			public LayerSet Layers = new LayerSet();

			public float ArtifactHeat = 1f;

			public bool HasBeenCompletedBefore()
			{
				return (Layers?.Main?.CompletionCount).GetValueOrDefault() > 0;
			}

			public static Expedition FromBaseGame(Expedition baseGameExpedition)
			{
				return new Expedition
				{
					AllLayerCompletionCount = baseGameExpedition.AllLayerCompletionCount,
					Layers = LayerSet.FromBaseGame(baseGameExpedition.Layers)
				};
			}

			public Expedition ToBaseGame()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				return new Expedition(ClassInjector.DerivedConstructorPointer<Expedition>())
				{
					AllLayerCompletionCount = AllLayerCompletionCount,
					Layers = (Layers?.ToBaseGameLayers() ?? new LayerSet<Layer>())
				};
			}
		}

		public class LayerSet
		{
			public Expedition.Layer Main { get; set; }

			public Expedition.Layer Secondary { get; set; }

			public Expedition.Layer Third { get; set; }

			public static LayerSet FromBaseGame(LayerSet<Layer> baseGameLayers)
			{
				//IL_0008: 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_002c: Unknown result type (might be due to invalid IL or missing references)
				return new LayerSet
				{
					Main = Expedition.Layer.FromBaseGame(baseGameLayers.Main),
					Secondary = Expedition.Layer.FromBaseGame(baseGameLayers.Secondary),
					Third = Expedition.Layer.FromBaseGame(baseGameLayers.Third)
				};
			}

			public Expedition.Layer GetOrAddLayer(Layers layer)
			{
				Expedition.Layer layer2 = GetLayer(layer);
				if (layer2 == null)
				{
					layer2 = new Expedition.Layer();
					SetLayer(layer, layer2);
				}
				return layer2;
			}

			public Expedition.Layer GetLayer(Layers layer)
			{
				if (1 == 0)
				{
				}
				Expedition.Layer result = layer switch
				{
					Layers.Main => Main, 
					Layers.Secondary => Secondary, 
					Layers.Third => Third, 
					_ => throw new Exception($"Unknown layer enum {layer}"), 
				};
				if (1 == 0)
				{
				}
				return result;
			}

			public void SetLayer(Layers layer, Expedition.Layer data)
			{
				switch (layer)
				{
				case Layers.Main:
					Main = data;
					break;
				case Layers.Secondary:
					Secondary = data;
					break;
				case Layers.Third:
					Third = data;
					break;
				default:
					throw new Exception($"Unknown layer enum {layer}");
				}
			}

			public LayerSet<Layer> ToBaseGameLayers()
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: 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)
				return new LayerSet<Layer>
				{
					Main = (Layer)(((??)Main?.ToBaseGame()) ?? default(Layer)),
					Secondary = (Layer)(((??)Secondary?.ToBaseGame()) ?? default(Layer)),
					Third = (Layer)(((??)Third?.ToBaseGame()) ?? default(Layer))
				};
			}
		}

		public Dictionary<string, Expedition> Expeditions = new Dictionary<string, Expedition>();

		private ILogger _logger = null;

		public static float ARTIFACT_HEAT_MIN { get; set; } = 0.2f;


		public static float ARTIFACT_HEAT_UNCOMPLETED_MIN { get; set; } = 0.5f;


		public int GetUniqueExpeditionLayersStateCount(Layers layer = Layers.Main, LayerState state = LayerState.Completed)
		{
			return Expeditions.Count(delegate(KeyValuePair<string, Expedition> x)
			{
				Expedition value = x.Value;
				return value != null && value.Layers?.GetLayer(layer)?.State == state;
			});
		}

		internal bool AddSessionResults(ExpeditionSession session, out ExpeditionCompletionData completionData)
		{
			if (session == null)
			{
				completionData = default(ExpeditionCompletionData);
				return false;
			}
			if (Expeditions == null)
			{
				Expeditions = new Dictionary<string, Expedition>();
			}
			Expedition orAdd = GetOrAdd(Expeditions, session.ExpeditionId);
			bool flag = !orAdd.HasBeenCompletedBefore();
			foreach (KeyValuePair<Layers, LayerState> layerState2 in session.CurrentData.LayerStates)
			{
				Layers key = layerState2.Key;
				LayerState layerState = layerState2.Value;
				if (!session.ExpeditionSurvived && layerState == LayerState.Completed)
				{
					layerState = LayerState.Entered;
				}
				Expedition.Layer orAddLayer = orAdd.Layers.GetOrAddLayer(key);
				orAddLayer.IncreaseStateAndCompletion(layerState);
			}
			if (session.ExpeditionSurvived && session.PrisonerEfficiencyCompleted)
			{
				orAdd.AllLayerCompletionCount++;
			}
			float artifactHeat = orAdd.ArtifactHeat;
			if (session.ArtifactsCollected > 0)
			{
				float val = (flag ? ARTIFACT_HEAT_MIN : ARTIFACT_HEAT_UNCOMPLETED_MIN);
				float val2 = orAdd.ArtifactHeat - (float)session.ArtifactsCollected * 1.5f / 100f;
				orAdd.ArtifactHeat = Math.Max(val, val2);
				foreach (Expedition value in Expeditions.Values)
				{
					if (value != orAdd && value != null && !(value.ArtifactHeat >= 1f))
					{
						float val3 = value.ArtifactHeat + (float)session.ArtifactsCollected * 0.5f / 100f;
						value.ArtifactHeat = Math.Min(1f, val3);
					}
				}
			}
			if (!uint.TryParse(session.RundownId.Replace("Local_", string.Empty), out var result))
			{
				_logger?.Error($"[{"LocalRundownProgression"}.{"AddSessionResults"}] Could not parse rundown id from \"{session.RundownId}\"!");
				result = 0u;
			}
			completionData = new ExpeditionCompletionData
			{
				RundownId = result,
				PreArtifactHeat = artifactHeat,
				NewArtifactHeat = orAdd.ArtifactHeat,
				WasFirstTimeCompletion = flag,
				RawSessionData = session
			};
			return true;
		}

		public RundownProgression ToBaseGameProgression()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			RundownProgression val = new RundownProgression(ClassInjector.DerivedConstructorPointer<RundownProgression>());
			val.Expeditions = new Dictionary<string, Expedition>();
			if (Expeditions == null)
			{
				Expeditions = new Dictionary<string, Expedition>();
			}
			foreach (KeyValuePair<string, Expedition> expedition in Expeditions)
			{
				string key = expedition.Key;
				Expedition value = expedition.Value;
				Expedition val2 = new Expedition(ClassInjector.DerivedConstructorPointer<Expedition>());
				val2.AllLayerCompletionCount = value.AllLayerCompletionCount;
				SetArtifactHeat(val2, value);
				val2.Layers = value.Layers.ToBaseGameLayers();
				val.Expeditions.Add(key, val2);
			}
			return val;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void SetArtifactHeat(Expedition bgExp, Expedition cExp)
		{
			bgExp.ArtifactHeat = cExp.ArtifactHeat;
		}

		public Expedition GetOrAdd(Dictionary<string, Expedition> dict, string keyName)
		{
			if (dict.TryGetValue(keyName, out var value))
			{
				return value;
			}
			Expedition expedition = new Expedition();
			dict.Add(keyName, expedition);
			return expedition;
		}
	}
}
namespace SimpleProgression.Progression
{
	public struct ExpeditionCompletionData
	{
		public bool Success => RawSessionData.ExpeditionSurvived;

		public string RundownIdString => RawSessionData.RundownId;

		public uint RundownId { get; internal set; }

		public string ExpeditionId => RawSessionData.ExpeditionId;

		public string SessionId => RawSessionData.SessionId;

		public int ArtifactsCollected => RawSessionData.ArtifactsCollected;

		public bool WasPrisonerEfficiencyClear => RawSessionData.PrisonerEfficiencyCompleted;

		public bool WasFirstTimeCompletion { get; internal set; }

		public ExpeditionSession RawSessionData { get; internal set; }

		public float PreArtifactHeat { get; internal set; }

		public float NewArtifactHeat { get; internal set; }
	}
	public class ExpeditionSession
	{
		public class ExpeditionSessionData
		{
			private readonly ILogger _logger;

			public Dictionary<Layers, LayerState> LayerStates { get; private set; } = new Dictionary<Layers, LayerState>();


			internal ExpeditionSessionData(ILogger logger)
			{
				_logger = logger;
			}

			internal void SetOnlyIncreaseLayerState(Layers layer, LayerState state)
			{
				if (LayerStates.TryGetValue(layer, out var value))
				{
					if (value < state)
					{
						LayerStates.Remove(layer);
						_logger.Debug($"[{"ExpeditionSessionData"}] Set layer {layer} from {value} to {state}");
						LayerStates.Add(layer, state);
					}
				}
				else
				{
					_logger.Debug($"[{"ExpeditionSessionData"}] Set layer {layer} to {state}");
					LayerStates.Add(layer, state);
				}
			}

			internal void SetLayerState(Layers layer, LayerState state)
			{
				if (LayerStates.TryGetValue(layer, out var value))
				{
					LayerStates.Remove(layer);
					_logger.Debug($"[{"ExpeditionSessionData"}] Set layer {layer} from {value} to {state}");
				}
				else
				{
					_logger.Debug($"[{"ExpeditionSessionData"}] Set layer {layer} to {state}");
				}
				LayerStates.Add(layer, state);
			}

			public override string ToString()
			{
				string text = string.Empty;
				foreach (KeyValuePair<Layers, LayerState> layerState in LayerStates)
				{
					text += $"{layerState.Key}: {layerState.Value}, ";
				}
				return text.Substring(0, text.Length - 2);
			}

			public ExpeditionSessionData Clone()
			{
				ExpeditionSessionData expeditionSessionData = new ExpeditionSessionData(_logger);
				foreach (KeyValuePair<Layers, LayerState> layerState in LayerStates)
				{
					expeditionSessionData.LayerStates.Add(layerState.Key, layerState.Value);
				}
				return expeditionSessionData;
			}
		}

		private readonly ILogger _logger;

		private ExpeditionSessionData SavedData { get; set; } = null;


		public ExpeditionSessionData CurrentData { get; private set; } = null;


		public bool HasCheckpointBeenUsed { get; private set; } = false;


		public bool ExpeditionSurvived { get; private set; } = false;


		public DateTimeOffset DropTime { get; private set; }

		public DateTimeOffset StartTime { get; private set; }

		public DateTimeOffset EndTime { get; private set; }

		public string RundownId { get; private set; } = string.Empty;


		public string ExpeditionId { get; private set; } = string.Empty;


		public string SessionId { get; private set; } = string.Empty;


		public int ArtifactsCollected { get; internal set; } = 0;


		public bool PrisonerEfficiencyCompleted => CurrentData.LayerStates.Count() == 3 && CurrentData.LayerStates.All((KeyValuePair<Layers, LayerState> x) => x.Value == LayerState.Completed);

		private ExpeditionSession(string rundownId, string expeditionId, string sessionId, ILogger logger)
		{
			RundownId = rundownId;
			ExpeditionId = expeditionId;
			SessionId = sessionId;
			_logger = logger;
			DropTime = DateTimeOffset.UtcNow;
			CurrentData = new ExpeditionSessionData(logger);
			SetLayer(Layers.Main, LayerState.Entered);
		}

		internal static ExpeditionSession InitNewSession(string rundownId, string expeditionId, string sessionId, ILogger logger)
		{
			ExpeditionSession result = new ExpeditionSession(rundownId, expeditionId, sessionId, logger);
			logger.Info($"[{"ExpeditionSession"}] New expedition session started! (R:{rundownId}, E:{expeditionId}, S:{sessionId})");
			return result;
		}

		internal void OnLevelEntered()
		{
			StartTime = DateTimeOffset.UtcNow;
		}

		internal void OnCheckpointSave()
		{
			_logger.Info("Saving current ExpeditionSessionData at checkpoint.");
			SavedData = CurrentData.Clone();
		}

		internal void OnCheckpointReset()
		{
			if (!HasCheckpointBeenUsed)
			{
				_logger.Notice("Checkpoint has been used!");
			}
			HasCheckpointBeenUsed = true;
			if (SavedData != null)
			{
				_logger.Info("Resetting previous ExpeditionSessionData from checkpoint.");
				CurrentData = SavedData.Clone();
			}
		}

		internal void OnExpeditionCompleted(bool success)
		{
			EndTime = DateTimeOffset.UtcNow;
			_logger.Info($"[{"ExpeditionSession"}] Expedition session has ended! (R:{RundownId}, E:{ExpeditionId}, S:{SessionId}){(success ? " Expedition Successful!" : string.Empty)}");
			if (success)
			{
				ExpeditionSurvived = true;
				SetLayer(Layers.Main, LayerState.Completed);
			}
			_logger.Info($"[{"ExpeditionSession"}] Data: {CurrentData}");
		}

		internal void SetLayer(Layers layer, LayerState state)
		{
			CurrentData.SetOnlyIncreaseLayerState(layer, state);
		}

		public bool HasLayerBeenCompleted(Layers layer)
		{
			if (!CurrentData.LayerStates.TryGetValue(layer, out var value))
			{
				return false;
			}
			return value == LayerState.Completed;
		}
	}
	public static class LayerExtensions
	{
		public static Layers ToCustom(this ExpeditionLayers layer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			return (Layers)layer;
		}

		public static ExpeditionLayers ToBasegame(this Layers layer)
		{
			return (ExpeditionLayers)layer;
		}

		public static LayerState ToCustom(this LayerProgressionState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			return (LayerState)state;
		}

		public static LayerProgressionState ToBasegame(this LayerState layer)
		{
			return (LayerProgressionState)layer;
		}
	}
	[Flags]
	public enum LayerFlags
	{
		None = 0,
		Main = 1,
		Secondary = 2,
		Third = 4,
		All = 7
	}
	public enum Layers
	{
		Main,
		Secondary,
		Third
	}
	public enum LayerState
	{
		Undiscovered,
		Discovered,
		Entered,
		Completed
	}
}
namespace SimpleProgression.Patches
{
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(ArtifactInventory), "OnStateChange")]
	public static class ArtifactInventory_OnStateChange_Patch
	{
		public static void Postfix(ArtifactInventory __instance)
		{
			LocalProgressionManager.Instance.ArtifactCountUpdated(__instance.CommonCount + __instance.RareCount + __instance.UncommonCount);
		}
	}
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(CheckpointManager), "StoreCheckpoint")]
	public class CheckpointManager_StoreCheckpoint_Patch
	{
		public static void Prefix()
		{
			LocalProgressionManager.Instance.SaveAtCheckpoint();
		}
	}
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(CheckpointManager), "ReloadCheckpoint")]
	public class CheckpointManager_ReloadCheckpoint_Patch
	{
		public static void Prefix()
		{
			LocalProgressionManager.Instance.ReloadFromCheckpoint();
		}
	}
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(DropServerManager), "OnTitleDataUpdated")]
	internal class DropServerManager_OnTitleDataUpdated_Patch
	{
		public static bool Prefix(DropServerManager __instance)
		{
			__instance.ClientApi = ((Il2CppObjectBase)new LocalDropServerAPI()).TryCast<IDropServerClientAPI>();
			return false;
		}
	}
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(DropServerManager), "GetStatusText")]
	internal class DropServerManager_GetStatusText_Patch
	{
		public static bool Prefix(DropServerManager __instance, ref string __result)
		{
			if (!__instance.IsBusy)
			{
				__result = null;
				return false;
			}
			__result = "STORAGE SYNC";
			return false;
		}
	}
}
namespace SimpleProgression.Interfaces
{
	public interface ILogger
	{
		void Success(string msg);

		void Notice(string msg);

		void Msg(ConsoleColor col, string msg);

		void Info(string msg);

		void Fail(string msg);

		void Debug(string msg);

		void Warning(string msg);

		void Error(string msg);

		void Exception(Exception ex);
	}
}
namespace SimpleProgression.Impl
{
	internal class LocalDropServerAPI : Object
	{
		public LocalDropServerAPI()
			: base(ClassInjector.DerivedConstructorPointer<LocalDropServerAPI>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public LocalDropServerAPI(IntPtr ptr)
			: base(ptr)
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public Task<RundownProgressionResult> RundownProgressionAsync(RundownProgressionRequest request)
		{
			//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_0039: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: RundownProgressionAsync");
			LocalRundownProgression orCreateLocalProgression = LocalProgressionManager.Instance.GetOrCreateLocalProgression(request.Rundown);
			return Task.FromResult<RundownProgressionResult>(new RundownProgressionResult
			{
				Rundown = orCreateLocalProgression.ToBaseGameProgression()
			});
		}

		public Task<ClearRundownProgressionResult> ClearRundownProgressionAsync(ClearRundownProgressionRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: ClearRundownProgressionAsync");
			return Task.FromResult<ClearRundownProgressionResult>(new ClearRundownProgressionResult());
		}

		public Task<NewSessionResult> NewSessionAsync(NewSessionRequest request)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			Plugin.L.Warning($"{"LocalDropServerAPI"}: {"NewSessionAsync"}: {request.Rundown} {request.Expedition} {request.SessionId}");
			LocalProgressionManager.Instance.StartNewExpeditionSession(request.Rundown, request.Expedition, request.SessionId);
			return Task.FromResult<NewSessionResult>(new NewSessionResult
			{
				SessionBlob = "Chat, is this real?! " + request.SessionId
			});
		}

		public Task<LayerProgressionResult> LayerProgressionAsync(LayerProgressionRequest request)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: LayerProgressionAsync");
			LocalProgressionManager.Instance.IncreaseLayerProgression(request.Layer, request.LayerProgressionState);
			return Task.FromResult<LayerProgressionResult>(new LayerProgressionResult
			{
				SessionBlob = ((SessionRequestBase)request).SessionBlob
			});
		}

		public Task<EndSessionResult> EndSessionAsync(EndSessionRequest request)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: EndSessionAsync");
			LocalProgressionManager.Instance.EndCurrentExpeditionSession(request.Success);
			return Task.FromResult<EndSessionResult>(new EndSessionResult());
		}

		public Task<GetBoosterImplantPlayerDataResult> GetBoosterImplantPlayerDataAsync(GetBoosterImplantPlayerDataRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: GetBoosterImplantPlayerDataAsync");
			return Task.FromResult<GetBoosterImplantPlayerDataResult>(new GetBoosterImplantPlayerDataResult
			{
				Data = new BoosterImplantPlayerData()
			});
		}

		public Task<UpdateBoosterImplantPlayerDataResult> UpdateBoosterImplantPlayerDataAsync(UpdateBoosterImplantPlayerDataRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: UpdateBoosterImplantPlayerDataAsync");
			return Task.FromResult<UpdateBoosterImplantPlayerDataResult>(new UpdateBoosterImplantPlayerDataResult
			{
				Data = new BoosterImplantPlayerData()
			});
		}

		public Task<ConsumeBoostersResult> ConsumeBoostersAsync(ConsumeBoostersRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: ConsumeBoostersAsync");
			return Task.FromResult<ConsumeBoostersResult>(new ConsumeBoostersResult
			{
				SessionBlob = ((SessionRequestBase)request).SessionBlob
			});
		}

		public Task<GetInventoryPlayerDataResult> GetInventoryPlayerDataAsync(GetInventoryPlayerDataRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0022: 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_002d: Expected O, but got Unknown
			//IL_0033: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: GetInventoryPlayerDataAsync");
			return Task.FromResult<GetInventoryPlayerDataResult>(new GetInventoryPlayerDataResult
			{
				Boosters = new BoosterImplantPlayerData(),
				VanityItems = new VanityItemPlayerData()
			});
		}

		public Task<UpdateVanityItemPlayerDataResult> UpdateVanityItemPlayerDataAsync(UpdateVanityItemPlayerDataRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: UpdateVanityItemPlayerDataAsync");
			return Task.FromResult<UpdateVanityItemPlayerDataResult>(new UpdateVanityItemPlayerDataResult
			{
				Data = new VanityItemPlayerData()
			});
		}

		public Task<DebugBoosterImplantResult> DebugBoosterImplantAsync(DebugBoosterImplantRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: DebugBoosterImplantAsync");
			return Task.FromResult<DebugBoosterImplantResult>(new DebugBoosterImplantResult());
		}

		public Task<DebugVanityItemResult> DebugVanityItemAsync(DebugVanityItemRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: DebugVanityItemAsync");
			return Task.FromResult<DebugVanityItemResult>(new DebugVanityItemResult());
		}

		public Task<AddResult> AddAsync(AddRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: AddAsync");
			return Task.FromResult<AddResult>(new AddResult
			{
				Sum = request.X + request.Y
			});
		}

		public Task<IsTesterResult> IsTesterAsync(IsTesterRequest request)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			Plugin.L.Warning("LocalDropServerAPI: IsTesterAsync");
			return Task.FromResult<IsTesterResult>(new IsTesterResult
			{
				IsTester = false
			});
		}
	}
	public class LocalGameSession : Object
	{
		public bool IsCompleted { get; set; }

		public LocalGameSession(IntPtr ptr)
			: base(ptr)
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public static LocalGameSession NewGameSession(string sessionGUID, string activeRundownKey, string expeditionKey, uint[] uints)
		{
			return new LocalGameSession(ClassInjector.DerivedConstructorPointer<LocalGameSession>());
		}

		public void ReportLayerProgression(ExpeditionLayers layer, LayerProgressionState progressionState)
		{
			//IL_002b: 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)
			Plugin.L.Warning($"{"ReportLayerProgression"}: {layer}, {progressionState}");
		}

		public void ConsumeBoosters()
		{
			Plugin.L.Warning("ConsumeBoosters");
		}

		public void ReportSessionResult(bool success, PerBoosterCategoryInt boosterCurrency)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Plugin.L.Warning($"{"ReportSessionResult"}: {success}, {boosterCurrency}");
		}

		public void EndSession()
		{
			Plugin.L.Warning("EndSession");
		}

		public void CancelSession()
		{
			Plugin.L.Warning("CancelSession");
		}

		public Task WaitAsync()
		{
			throw new NotImplementedException();
		}

		public void Dispose()
		{
		}
	}
}