using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using Newtonsoft.Json;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.U2D;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("TrophyHuntMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("TrophyHuntMod")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("93c3a5ae-6334-4635-88ba-d61d730b4124")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class DiscordOAuthFlow
{
	public delegate void StatusCallback();

	private const string TokenEndpoint = "https://discord.com/api/oauth2/token";

	private const string UserEndpoint = "https://discord.com/api/users/@me";

	private HttpListener httpListener;

	private string m_clientId = string.Empty;

	private string m_redirectUri = string.Empty;

	private string m_code = string.Empty;

	private DiscordUserResponse m_userInfo;

	private bool VERBOSE;

	private StatusCallback m_statusCallback;

	public DiscordUserResponse GetUserResponse()
	{
		return m_userInfo;
	}

	public void ClearUserResponse()
	{
		m_userInfo = null;
	}

	public void StartOAuthFlow(string clientId, string redirectUri, StatusCallback callback)
	{
		m_clientId = clientId;
		m_redirectUri = redirectUri;
		m_statusCallback = callback;
		_ = VERBOSE;
		StartServer(redirectUri);
		OpenDiscordAuthorization(clientId, redirectUri);
	}

	private void OpenDiscordAuthorization(string clientId, string redirectUri)
	{
		_ = VERBOSE;
		string text = "identify";
		_ = VERBOSE;
		string fileName = "https://discord.com/oauth2/authorize?client_id=" + clientId + "&redirect_uri=" + Uri.EscapeDataString(redirectUri) + "&response_type=token&scope=" + text;
		Process.Start(new ProcessStartInfo
		{
			FileName = fileName,
			UseShellExecute = true
		});
	}

	private void StartServer(string redirectUri)
	{
		_ = VERBOSE;
		if (httpListener != null)
		{
			httpListener.Stop();
		}
		else
		{
			httpListener = new HttpListener();
			httpListener.Prefixes.Add("http://localhost:5000/");
		}
		httpListener.Start();
		Task.Run(() => ImplicitGrantWaitForCallback());
	}

	private void StopServer()
	{
		_ = VERBOSE;
		httpListener.Stop();
	}

	private async Task ImplicitGrantWaitForCallback()
	{
		_ = VERBOSE;
		HttpListenerRequest request;
		HttpListenerResponse response;
		while (true)
		{
			HttpListenerContext httpListenerContext = await httpListener.GetContextAsync();
			request = httpListenerContext.Request;
			response = httpListenerContext.Response;
			if (request.Url.AbsolutePath == "/callback" && string.IsNullOrEmpty(request.QueryString["token"]))
			{
				string callbackHtml = GetCallbackHtml();
				byte[] bytes = Encoding.UTF8.GetBytes(callbackHtml);
				response.ContentLength64 = bytes.Length;
				response.ContentType = "text/html";
				await response.OutputStream.WriteAsync(bytes, 0, bytes.Length);
				response.OutputStream.Close();
			}
			else if (request.QueryString["token"] != null)
			{
				break;
			}
		}
		string accessToken = request.QueryString["token"];
		_ = VERBOSE;
		string s = "<html>\r\n\r\n<body style=\"background-color:#202020;\\\">\r\n    <center>\r\n        <figure class=\"image image-style-align-left\\\"><img style=\"aspect-ratio:256/256;\" src=\"https://gcdn.thunderstore.io/live/repository/icons/oathorse-TrophyHuntMod-0.8.8.png.256x256_q95_crop.jpg\" width=\"256\\\" height=\"256\\\"></figure>\r\n        <p>&nbsp;</p>\r\n        <p><span style=\"color:#f0e080;font-size:22px;\"><strong>Congratulations! You've connected Discord to the TrophyHuntMod and have enabled online reporting!</p></strong></span>\r\n        \r\n        <p><span style=\"color:#e0e0e0;font-size:20px;\"><strong>Data reported by the mod can now be used in official Trophy Hunt Tournaments.</strong></span></p>\r\n        <p>&nbsp;</p>\r\n        <p><span style=\"color:#e0e0e0;font-size:22px;\"><strong>Only your Discord id and username are used, and not for anything but Trophy Hunt event leaderboards.</strong></span></p>\r\n        <p><span style=\"color:#e04040;font-size:20px;\"><strong>They will not be shared with anyone else.</strong></span></p>\r\n        <p>&nbsp;</p>\r\n        <p>&nbsp;</p>\r\n        <p><span style=\"color:#e0e0e0;font-size:24px;\\\"><strong>You can now close this window.</strong></span></p>\r\n    </center>\r\n</body>\r\n\r\n</html>";
		byte[] bytes2 = Encoding.UTF8.GetBytes(s);
		response.ContentLength64 = bytes2.Length;
		response.ContentType = "text/html";
		await response.OutputStream.WriteAsync(bytes2, 0, bytes2.Length);
		response.OutputStream.Close();
		StopServer();
		await ImplicitGrantGetDiscordUserInfo(accessToken);
		m_statusCallback();
	}

	private async Task ImplicitGrantGetDiscordUserInfo(string accessToken)
	{
		HttpClient client = new HttpClient();
		try
		{
			((HttpHeaders)client.DefaultRequestHeaders).Add("Authorization", "Bearer " + accessToken);
			HttpResponseMessage response = await client.GetAsync("https://discord.com/api/users/@me");
			string text = await response.Content.ReadAsStringAsync();
			_ = VERBOSE;
			if (response.IsSuccessStatusCode)
			{
				m_userInfo = JsonConvert.DeserializeObject<DiscordUserResponse>(text);
			}
			else
			{
				_ = VERBOSE;
			}
		}
		finally
		{
			((IDisposable)client)?.Dispose();
		}
	}

	private string GetCallbackHtml()
	{
		return "<!DOCTYPE html>\r\n<html>\r\n<head>\r\n    <title>Discord Auth</title>\r\n    <script>\r\n        window.onload = function() {\r\n            const params = new URLSearchParams(window.location.hash.substr(1));\r\n            const accessToken = params.get('access_token');\r\n            if (accessToken) {\r\n                window.location.href = 'http://localhost:5000/callback?token=' + encodeURIComponent(accessToken);\r\n            } else {\r\n                document.body.innerHTML = '<h2>Error: No access token found.</h2>';\r\n            }\r\n        };\r\n    </script>\r\n</head>\r\n<body>\r\n    <h2>Authenticating...</h2>\r\n</body>\r\n</html>";
	}
}
public class DiscordUserResponse
{
	public Sprite avatarSprite;

	public string id { get; set; }

	public string username { get; set; }

	public string discriminator { get; set; }

	public string avatar { get; set; }

	public string global_name { get; set; }
}
public class MainThreadDispatcher : MonoBehaviour
{
	private static MainThreadDispatcher _instance;

	private readonly Queue<Action> _actions = new Queue<Action>();

	public static MainThreadDispatcher Instance
	{
		get
		{
			//IL_0012: 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_0027: Expected O, but got Unknown
			if ((Object)(object)_instance == (Object)null)
			{
				GameObject val = new GameObject("MainThreadDispatcher");
				_instance = val.AddComponent<MainThreadDispatcher>();
				Object.DontDestroyOnLoad((Object)val);
			}
			return _instance;
		}
	}

	private void Update()
	{
		lock (_actions)
		{
			while (_actions.Count > 0)
			{
				_actions.Dequeue()?.Invoke();
			}
		}
	}

	public void Enqueue(Action action)
	{
		if (action == null)
		{
			return;
		}
		lock (_actions)
		{
			_actions.Enqueue(action);
		}
	}
}
namespace TrophyHuntMod;

[BepInPlugin("com.oathorse.TrophyHuntMod", "TrophyHuntMod", "0.10.15")]
public class TrophyHuntMod : BaseUnityPlugin
{
	public class GandrArrowData
	{
		public string m_arrowName = "";

		public string m_ingredient = "";

		public string m_name = "";

		public string m_description = "";

		public Type m_statusEffectType;

		public GandrTypeIndex m_spriteIndex;

		public GandrArrowData(string arrowName, string ingredient, string name, string description, Type statusEffectType, GandrTypeIndex spriteIndex)
		{
			m_arrowName = arrowName;
			m_ingredient = ingredient;
			m_name = name;
			m_description = description;
			m_statusEffectType = statusEffectType;
			m_spriteIndex = spriteIndex;
		}
	}

	[HarmonyPatch(typeof(Character), "GetJogSpeedFactor")]
	public static class Character_GetJogSpeedFactor_Patch
	{
		public static void Postfix(Character __instance, ref float __result)
		{
			if (IsPacifist())
			{
				Guid cGUID = GetGUIDFromCharacter(__instance);
				if (__m_allCharmedCharacters.Find((CharmedCharacter c) => c.m_charmGUID == cGUID) != null)
				{
					__result = 3.5f;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Character), "GetRunSpeedFactor")]
	public static class Character_GetRunSpeedFactor_Patch
	{
		public static void Postfix(Character __instance, ref float __result)
		{
			if (IsPacifist())
			{
				Guid cGUID = GetGUIDFromCharacter(__instance);
				if (__m_allCharmedCharacters.Find((CharmedCharacter c) => c.m_charmGUID == cGUID) != null)
				{
					__result = 3.5f;
				}
			}
		}
	}

	[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
	public static class MonsterAI_UpdateAI_Patch
	{
		public static void Postfix(MonsterAI __instance, float dt)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			if (!IsPacifist() || (Object)(object)__instance == (Object)null || (Object)(object)((BaseAI)__instance).m_character == (Object)null || !IsCharmed(((BaseAI)__instance).m_character))
			{
				return;
			}
			if ((Object)(object)((BaseAI)__instance).m_character == (Object)null)
			{
				Debug.LogError((object)"MonsterAI_UpdateAI_Patch: __instance.m_character is null!");
				return;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				Debug.LogError((object)"MonsterAI_UpdateAI_Patch: Player.m_localPlayer is null!");
				return;
			}
			Vector3.Distance(((Component)Player.m_localPlayer).transform.position, ((Component)((BaseAI)__instance).m_character).transform.position);
			Character targetCreature = ((BaseAI)__instance).GetTargetCreature();
			if (Object.op_Implicit((Object)(object)targetCreature))
			{
				Vector3.Distance(((Component)targetCreature).transform.position, ((Component)((BaseAI)__instance).m_character).transform.position);
				__instance.SetFollowTarget(((Component)Player.m_localPlayer).gameObject);
			}
		}
	}

	[HarmonyPatch(typeof(BaseAI), "Follow")]
	public static class BaseAI_Follow_Patch
	{
		public static bool Prefix(BaseAI __instance, GameObject go, float dt)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			float num = 0f;
			float num2 = Vector3.Distance(go.transform.position, ((Component)__instance.m_character).transform.position);
			bool flag = num2 > 10f;
			if (num2 < 3f + __instance.m_character.GetRadius() * 2f - num)
			{
				__instance.StopMoving();
			}
			else
			{
				__instance.MoveTo(dt, go.transform.position, 0f, flag);
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(BaseAI), "FindEnemy")]
	public static class BaseAI_FindEnemy_Patch
	{
		public static bool Prefix(BaseAI __instance, ref Character __result)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPacifist())
			{
				return true;
			}
			if (!IsCharmed(__instance.m_character))
			{
				return true;
			}
			Character localPlayer = (Character)(object)Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return true;
			}
			List<Character> allCharacters = Character.GetAllCharacters();
			Character val = null;
			float num = 99999f;
			foreach (Character item in allCharacters)
			{
				if (!BaseAI.IsEnemy(__instance.m_character, item) || item.IsDead() || item.m_aiSkipTarget)
				{
					continue;
				}
				BaseAI baseAI = item.GetBaseAI();
				if (((Object)(object)baseAI == (Object)null || !baseAI.IsSleeping()) && __instance.CanSenseTarget(item))
				{
					float num2 = Vector3.Distance(((Component)item).transform.position, ((Component)localPlayer).transform.position);
					if (num2 < num || (Object)(object)val == (Object)null)
					{
						val = item;
						num = num2;
					}
				}
			}
			if ((Object)(object)val == (Object)null && __instance.HuntPlayer())
			{
				Player closestPlayer = Player.GetClosestPlayer(((Component)__instance).transform.position, 200f);
				if ((Object)(object)closestPlayer != (Object)null && (closestPlayer.InDebugFlyMode() || ((Character)closestPlayer).InGhostMode()))
				{
					__result = null;
					return false;
				}
				__result = (Character)(object)closestPlayer;
				return false;
			}
			if (num > 50f)
			{
				MonsterAI val2 = (MonsterAI)(object)((__instance is MonsterAI) ? __instance : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.m_timeSinceSensedTargetCreature = 0f;
					val2.m_targetCreature = null;
					val2.m_targetStatic = null;
					((BaseAI)val2).SetTargetInfo(ZDOID.None);
				}
				__result = null;
				return false;
			}
			__result = val;
			return false;
		}
	}

	[HarmonyPatch(typeof(Humanoid), "GiveDefaultItems")]
	public static class Humanoid_GiveDefaultItems_Patch
	{
		public static void Postfix(Humanoid __instance)
		{
			if (!IsPacifist() || (Object)(object)__instance == (Object)null || !(((object)__instance).GetType() == typeof(Player)))
			{
				return;
			}
			Inventory inventory = __instance.GetInventory();
			if (inventory != null && !inventory.HaveItem("$item_bow", true))
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Bow");
				if ((Object)(object)itemPrefab != (Object)null)
				{
					__instance.GiveDefaultItem(itemPrefab);
				}
				else
				{
					Debug.LogWarning((object)"Could not find Bow prefab in ObjectDB");
				}
			}
		}
	}

	[HarmonyPatch(typeof(Character), "RPC_Damage")]
	public static class Character_RPC_Damage_Patch
	{
		public static bool Prefix(Character __instance, long sender, HitData hit)
		{
			if (!IsPacifist())
			{
				return true;
			}
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Humanoid), "StartAttack")]
	public static class Humanoid_StartAttack_Patch
	{
		public static bool Prefix(Humanoid __instance, Character target, bool secondaryAttack, bool __result)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			if (!IsPacifist())
			{
				return true;
			}
			if ((Object)(object)__instance != (Object)null && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon != null && (int)currentWeapon.m_shared.m_itemType == 4)
				{
					ItemData ammoItem = __instance.GetAmmoItem();
					if (ammoItem != null && IsThrallArrow(ammoItem.m_shared.m_name))
					{
						return true;
					}
				}
				else if ((int)currentWeapon.m_shared.m_skillType == 7 || (int)currentWeapon.m_shared.m_skillType == 12 || (int)currentWeapon.m_shared.m_skillType == 13)
				{
					return true;
				}
				__result = false;
				return false;
			}
			return true;
		}
	}

	public class CharmedCharacter
	{
		public Guid m_charmGUID = Guid.Empty;

		public PinData m_pin;

		public long m_charmExpireTime;

		public Faction m_originalFaction = (Faction)12;

		public float m_swimSpeed = 2f;

		public int m_charmLevel = 1;
	}

	[HarmonyPatch(typeof(MonsterAI), "Awake")]
	public static class MonsterAI_Awake_Patch
	{
		public static void Postfix(MonsterAI __instance)
		{
			if (IsPacifist() && !((Object)(object)__instance == (Object)null) && !((Object)(object)((BaseAI)__instance).m_character == (Object)null))
			{
				Guid cGUID = GetGUIDFromCharacter(((BaseAI)__instance).m_character);
				CharmedCharacter charmedCharacter = __m_allCharmedCharacters.Find((CharmedCharacter c) => c.m_charmGUID == cGUID);
				if (charmedCharacter != null)
				{
					SetCharmedState(charmedCharacter);
				}
			}
		}
	}

	[HarmonyPatch(typeof(Character), "OnDestroy")]
	public static class Character_OnDestroy_Patch
	{
		public static void Prefix(Character __instance)
		{
			IsPacifist();
		}
	}

	[HarmonyPatch(typeof(Projectile), "OnHit")]
	public static class Projectile_OnHit_Patch
	{
		public static bool Prefix(Projectile __instance, Collider collider)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPacifist())
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			ItemData ammo = __instance.m_ammo;
			if (ammo == null || ammo.m_shared == null)
			{
				return true;
			}
			if (!IsThrallArrow(ammo.m_shared.m_name))
			{
				return true;
			}
			__instance.m_damage = default(DamageTypes);
			return false;
		}

		public static void Postfix(Projectile __instance, Collider collider)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			if (!IsPacifist())
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_owner == (Object)null)
				{
					return;
				}
				ItemData ammo = __instance.m_ammo;
				if (ammo == null || ammo.m_shared == null)
				{
					return;
				}
				string name = ammo.m_shared.m_name;
				if (!IsThrallArrow(name))
				{
					return;
				}
				GameObject val = Projectile.FindHitObject(collider);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Unable find hit object for Projectile with collilder " + ((Object)collider).name));
					return;
				}
				Character component = val.GetComponent<Character>();
				if ((Object)(object)component == (Object)null || component.IsPlayer() || component.IsDead())
				{
					return;
				}
				if ((int)component.m_faction == 8)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, "Bosses cannot be charmed.", 0, (Sprite)null);
					return;
				}
				if (IsCharmed(component))
				{
					CharmedCharacter charmedCharacter = GetCharmedCharacter(component);
					if (charmedCharacter != null)
					{
						charmedCharacter.m_charmExpireTime = __m_charmTimerSeconds + (long)GetCharmDuration();
					}
				}
				else
				{
					AddToCharmedList(component, (long)GetCharmDuration());
				}
				ApplyGandrEffect(name, component);
				ZNetScene.instance.Destroy(((Component)__instance).gameObject);
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[WoodArrowCharm] Error: {arg}");
			}
		}
	}

	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	public static class ObjectDB_Awake_Patch
	{
		public static void ChangeArrow(ObjectDB db, string prefabName, string ingredient, string newName, string newDescription)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			GameObject itemPrefab = db.GetItemPrefab(prefabName);
			if (!Object.op_Implicit((Object)(object)itemPrefab))
			{
				Debug.LogError((object)("Could not find " + prefabName));
				return;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				Debug.LogError((object)("Could not find ItemDrop on " + prefabName));
				return;
			}
			component.m_itemData.m_shared.m_description = newDescription;
			component.m_itemData.m_shared.m_name = newName;
			Recipe val = db.m_recipes.Find((Recipe r) => ((Object)r).name == "Recipe_" + prefabName);
			if (!Object.op_Implicit((Object)(object)val))
			{
				Debug.LogError((object)("Could not find Recipe_" + prefabName));
				return;
			}
			val.m_item = component;
			val.m_amount = 20;
			val.m_enabled = true;
			if (prefabName == "ArrowWood")
			{
				val.m_craftingStation = null;
				val.m_minStationLevel = 0;
			}
			val.m_resources = (Requirement[])(object)new Requirement[1]
			{
				new Requirement
				{
					m_resItem = db.GetItemPrefab(ingredient).GetComponent<ItemDrop>(),
					m_amount = 1,
					m_amountPerLevel = 0
				}
			};
		}

		private static void Postfix(ObjectDB __instance)
		{
			if (IsPacifist() && (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null)
			{
				GandrArrowData[] _m_gandrArrowData = __m_gandrArrowData;
				foreach (GandrArrowData gandrArrowData in _m_gandrArrowData)
				{
					ChangeArrow(__instance, gandrArrowData.m_arrowName, gandrArrowData.m_ingredient, gandrArrowData.m_name, gandrArrowData.m_description);
				}
			}
		}
	}

	[HarmonyPatch(typeof(Player), "AddAdrenaline")]
	public static class Player_AddAdrenaline_Patch
	{
		public static bool Prefix(Player __instance, ref float v)
		{
			if (!IsPacifist())
			{
				return true;
			}
			if (HasThrall())
			{
				if (v > 0f)
				{
					v *= 2f;
				}
				else
				{
					v *= 0.5f;
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(SEMan), "ModifyAdrenaline")]
	public static class SEMan_ModifyAdrenaline_Patch
	{
		public static bool Prefix(SEMan __instance, float baseValue, ref float use)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPacifist())
			{
				return true;
			}
			if ((Object)(object)__instance.m_character != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if (use > 0f)
			{
				use *= 2f;
				if (localPlayer.m_adrenaline + use > localPlayer.m_maxAdrenaline)
				{
					bool flag = false;
					StatusEffect val = null;
					foreach (ItemData allItem in ((Humanoid)localPlayer).GetInventory().GetAllItems())
					{
						if (allItem.m_equipped && (Object)(object)allItem.m_shared.m_fullAdrenalineSE != (Object)null)
						{
							flag = true;
							val = allItem.m_shared.m_fullAdrenalineSE;
							break;
						}
					}
					foreach (CharmedCharacter _m_allCharmedCharacter in __m_allCharmedCharacters)
					{
						Character characterFromGUID = GetCharacterFromGUID(_m_allCharmedCharacter.m_charmGUID);
						if (!Object.op_Implicit((Object)(object)characterFromGUID))
						{
							continue;
						}
						characterFromGUID.Heal(characterFromGUID.GetMaxHealth() - characterFromGUID.GetHealth(), true);
						if (flag)
						{
							localPlayer.m_adrenalinePopEffects.Create(((Component)characterFromGUID).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
							StatusEffect statusEffect = characterFromGUID.m_seman.GetStatusEffect(val.m_nameHash);
							if (Object.op_Implicit((Object)(object)statusEffect))
							{
								statusEffect.ResetTime();
							}
							else
							{
								characterFromGUID.m_seman.AddStatusEffect(val, false, 0, 0f);
							}
						}
						else
						{
							localPlayer.m_adrenaline = 0f;
						}
						_m_allCharmedCharacter.m_charmLevel++;
						Hud.instance.AdrenalineBarFlash();
					}
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Attack), "ModifyDamage")]
	public class Attack_ModifyDamage_Patch
	{
		public static bool Prefix(Attack __instance, HitData hitData, float damageFactor)
		{
			Character character = (Character)(object)__instance.m_character;
			if (IsPacifist() && IsCharmed(character) && character != null && character.m_seman.GetStatusEffects().Count == 0)
			{
				CharmedCharacter charmedCharacter = GetCharmedCharacter(character);
				if (charmedCharacter != null)
				{
					float adrenalineScalar = Player.m_localPlayer.GetAdrenaline() / ((Character)Player.m_localPlayer).GetMaxAdrenaline();
					ScaleThrallOutgoingDamage(ref hitData, charmedCharacter.m_charmLevel, adrenalineScalar, 1.1f);
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Character), "Damage")]
	public class Character_Damage_Patch
	{
		public static bool Prefix(Character __instance, HitData hit)
		{
			if (IsPacifist() && IsCharmed(__instance) && __instance != null && __instance.m_seman.GetStatusEffects().Count == 0)
			{
				CharmedCharacter charmedCharacter = GetCharmedCharacter(__instance);
				if (charmedCharacter != null)
				{
					float adrenalineScalar = Player.m_localPlayer.GetAdrenaline() / ((Character)Player.m_localPlayer).GetMaxAdrenaline();
					ScaleThrallIncomingDamage(__instance, ref hit, charmedCharacter.m_charmLevel, adrenalineScalar, 0.7f);
				}
			}
			return true;
		}
	}

	public class GandrSEData
	{
		public Type m_type;

		public float m_inflicted;

		public float m_received;

		public float m_typedDamage;

		public string m_name;

		public GandrSEData(Type type, float inflited, float received, float typedDamage, string name)
		{
			m_type = type;
			m_inflicted = inflited;
			m_received = received;
			m_typedDamage = typedDamage;
			m_name = name;
		}
	}

	public class SE_GandrEffect : SE_Stats
	{
		public float m_adrenalineScalar;

		public float m_baseDamageInflictedModifier = 1f;

		public float m_baseDamageReceivedModifier = 1.2f;

		public float m_baseTypedDamageModifier = 0.5f;

		public float m_charmLevel = 1f;

		public GandrSEData m_seData;

		public override void Setup(Character character)
		{
			((SE_Stats)this).Setup(character);
			((StatusEffect)this).m_ttl = 120f;
			((StatusEffect)this).m_name = "Base Gandr Effect";
			GandrArrowData gandrArrowData = __m_gandrArrowData.First((GandrArrowData a) => a.m_statusEffectType == ((object)this).GetType());
			if (gandrArrowData != null)
			{
				((StatusEffect)this).m_icon = __m_cachedPacifistSprites[(int)gandrArrowData.m_spriteIndex].m_sprite;
			}
			GandrSEData gandrSEData = __m_gandrSEData.First((GandrSEData s) => s.m_type == ((object)this).GetType());
			if (gandrSEData != null)
			{
				m_baseDamageInflictedModifier = gandrSEData.m_inflicted;
				m_baseDamageReceivedModifier = gandrSEData.m_received;
				m_baseTypedDamageModifier = gandrSEData.m_typedDamage;
				((StatusEffect)this).m_name = gandrSEData.m_name;
				((StatusEffect)this).m_nameHash = StringExtensionMethods.GetStableHashCode(((StatusEffect)this).m_name);
				m_seData = gandrSEData;
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			((SE_Stats)this).UpdateStatusEffect(dt);
			CharmedCharacter charmedCharacter = GetCharmedCharacter(((StatusEffect)this).m_character);
			if (charmedCharacter != null)
			{
				m_charmLevel = charmedCharacter.m_charmLevel;
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null && ((Character)localPlayer).GetMaxAdrenaline() > 0f)
			{
				m_adrenalineScalar = Player.m_localPlayer.GetAdrenaline() / ((Character)Player.m_localPlayer).GetMaxAdrenaline();
			}
			else
			{
				m_adrenalineScalar = 0f;
			}
		}

		public override void ModifyAttack(SkillType skill, ref HitData hitData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			DamageTypes percentigeDamageModifiers = base.m_percentigeDamageModifiers;
			float num = 0f;
			((DamageTypes)(ref hitData.m_damage)).GetMajorityDamageType(ref num);
			((DamageTypes)(ref percentigeDamageModifiers)).Modify(num * m_baseTypedDamageModifier);
			((DamageTypes)(ref hitData.m_damage)).Add(percentigeDamageModifiers, 1);
			ScaleThrallOutgoingDamage(ref hitData, m_charmLevel, base.m_adrenalineModifier, m_baseDamageInflictedModifier);
			((SE_Stats)this).ModifyAttack(skill, ref hitData);
		}

		public override void OnDamaged(HitData hit, Character attacker)
		{
			((StatusEffect)this).OnDamaged(hit, attacker);
			ScaleThrallIncomingDamage(((StatusEffect)this).m_character, ref hit, m_charmLevel, m_adrenalineScalar, m_baseDamageReceivedModifier);
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
		}
	}

	public class SE_GandrFlint : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_pierce = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrFire : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_fire = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrBronze : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_blunt = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrPoison : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_poison = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrIron : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_slash = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrFrost : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_frost = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrObsidian : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_slash = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrSilver : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_spirit = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrNeedle : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_pierce = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrCarapace : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_blunt = m_seData.m_typedDamage;
		}
	}

	public class SE_GandrCharred : SE_GandrEffect
	{
		public override void Setup(Character character)
		{
			base.Setup(character);
			((SE_Stats)this).m_percentigeDamageModifiers.m_lightning = m_seData.m_typedDamage;
		}
	}

	[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
	public class EnemyHud_UpdateHud_Patch
	{
		public static void Postfix(EnemyHud __instance, Player player, Sadle sadle, float dt)
		{
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPacifist())
			{
				return;
			}
			foreach (KeyValuePair<Character, HudData> hud in __instance.m_huds)
			{
				Character key = hud.Key;
				if ((Object)(object)key == (Object)null)
				{
					continue;
				}
				HudData value = hud.Value;
				Transform val = value.m_gui.transform.Find("Charm");
				List<GameObject> list = new List<GameObject>();
				for (int i = 0; i < MAX_NUM_CHARM_ICONS; i++)
				{
					object obj;
					if (value == null)
					{
						obj = null;
					}
					else
					{
						GameObject gui = value.m_gui;
						if (gui == null)
						{
							obj = null;
						}
						else
						{
							Transform obj2 = gui.transform.Find($"Charm/CharmIcon{i}");
							obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
						}
					}
					GameObject val2 = (GameObject)obj;
					if (Object.op_Implicit((Object)(object)val2))
					{
						val2.SetActive(false);
						list.Add(val2);
					}
				}
				CharmedCharacter charmedCharacter = GetCharmedCharacter(key);
				if (charmedCharacter == null)
				{
					if (Object.op_Implicit((Object)(object)val) && ((Component)val).gameObject.activeSelf)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
				else
				{
					if (!IsCharmed(key))
					{
						continue;
					}
					if (Object.op_Implicit((Object)(object)val) && !((Component)val).gameObject.activeSelf)
					{
						((Component)val).gameObject.SetActive(true);
					}
					int num = 0;
					List<StatusEffect> statusEffects = key.m_seman.m_statusEffects;
					foreach (StatusEffect item in statusEffects)
					{
						if (!((Object)(object)item.m_icon == (Object)null))
						{
							GameObject obj3 = list[num];
							obj3.gameObject.SetActive(true);
							obj3.GetComponent<Image>().sprite = item.m_icon;
							RectTransform component = obj3.GetComponent<RectTransform>();
							int num2 = 28;
							component.sizeDelta = new Vector2((float)num2, (float)num2);
							((Transform)component).localScale = Vector3.one;
							float num3 = 1f;
							float num4 = ((float)num2 + num3) * (float)(statusEffects.Count - 1) / 2f;
							float num5 = ((float)num2 + num3) * (float)num;
							component.anchoredPosition = new Vector2(0f - num4 + num5, (float)(-num2 / 2 - 1));
							num++;
						}
					}
					GuiBar component2 = ((Component)value.m_gui.transform.Find("Charm/CharmBar")).GetComponent<GuiBar>();
					float num6 = charmedCharacter.m_charmExpireTime - __m_charmTimerSeconds;
					component2.SetWidth(100f);
					component2.SetValue(num6 / GetCharmDuration());
					component2.SetColor(__m_pinkColor);
					((TMP_Text)((Component)value.m_gui.transform.Find("Charm/CharmLevelText")).gameObject.GetComponent<TextMeshProUGUI>()).text = $"{charmedCharacter.m_charmLevel}";
				}
			}
		}
	}

	[HarmonyPatch(typeof(EnemyHud), "Awake")]
	public class EnemyHud_Awake_Patch
	{
		public static void Postfix(EnemyHud __instance)
		{
			//IL_0042: 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)
			//IL_005b: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			Transform val = __instance.m_baseHud.transform.Find("Health");
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, val.parent);
			((Object)val2).name = "Charm";
			val2.SetActive(false);
			Transform transform = val2.transform;
			transform.localPosition += new Vector3(0f, -10f, 0f);
			Transform val3 = transform.Find("health_fast");
			if ((Object)(object)val3 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val3).gameObject);
			}
			Transform val4 = transform.Find("health_slow");
			if ((Object)(object)val4 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val4).gameObject);
			}
			Transform obj = transform.Find("health_fast_friendly");
			((Object)obj).name = "CharmBar";
			if (obj != null)
			{
				GameObject gameObject = ((Component)obj).gameObject;
				if (gameObject != null)
				{
					gameObject.GetComponent<GuiBar>();
				}
			}
			CreateCharmIconsInMasterHud(val2.transform);
			GameObject val5 = new GameObject("CharmLevelText");
			val5.transform.SetParent(val2.transform);
			RectTransform obj2 = val5.AddComponent<RectTransform>();
			obj2.sizeDelta = new Vector2(20f, 20f);
			((Transform)obj2).localScale = Vector3.one;
			((Transform)obj2).localPosition = Vector2.op_Implicit(Vector2.zero);
			TextMeshProUGUI obj3 = AddTextMeshProComponent(val5);
			((TMP_Text)obj3).text = "X";
			((TMP_Text)obj3).fontSize = 13f;
			((TMP_Text)obj3).fontStyle = (FontStyles)1;
			((Graphic)obj3).color = Color.white;
			((Graphic)obj3).raycastTarget = false;
			((TMP_Text)obj3).fontMaterial.EnableKeyword("OUTLINE_ON");
			((TMP_Text)obj3).outlineColor = Color32.op_Implicit(Color.black);
			((TMP_Text)obj3).outlineWidth = 0.125f;
			((TMP_Text)obj3).verticalAlignment = (VerticalAlignmentOptions)512;
			((TMP_Text)obj3).horizontalAlignment = (HorizontalAlignmentOptions)2;
		}
	}

	public class CachedSprite
	{
		public GandrTypeIndex m_index;

		public string m_name;

		public Sprite m_sprite;

		public CachedSprite(GandrTypeIndex index, string name, Sprite sprite)
		{
			m_index = index;
			m_name = name;
			m_sprite = sprite;
		}
	}

	public enum GandrTypeIndex
	{
		Wood,
		Flint,
		Fire,
		Bronze,
		Poison,
		Iron,
		Frost,
		Obsidian,
		Silver,
		Needle,
		Carapace,
		Charred
	}

	public enum Biome
	{
		Meadows,
		Forest,
		Swamp,
		Mountains,
		Plains,
		Mistlands,
		Ashlands,
		Ocean,
		Hildir,
		Bogwitch
	}

	public struct TrophyHuntDataScoreOverride
	{
		public TrophyGameMode m_gameMode;

		public string m_trophyName;

		public int m_score;

		public TrophyHuntDataScoreOverride(TrophyGameMode gameMode, string trophyName, int score)
		{
			m_gameMode = gameMode;
			m_trophyName = trophyName;
			m_score = score;
		}
	}

	public struct TrophyHuntData
	{
		public string m_name;

		public string m_prettyName;

		public Biome m_biome;

		private int m_value;

		public float m_dropPercent;

		public List<string> m_enemies;

		public TrophyHuntData(string name, string prettyName, Biome biome, int value, float dropPercent, List<string> enemies)
		{
			m_name = name;
			m_prettyName = prettyName;
			m_biome = biome;
			m_value = value;
			m_dropPercent = dropPercent;
			m_enemies = enemies;
		}

		public int GetCurGameModeTrophyScoreValue()
		{
			int result = m_value;
			TrophyHuntDataScoreOverride[] _m_trophyHuntScoreOverrides = __m_trophyHuntScoreOverrides;
			for (int i = 0; i < _m_trophyHuntScoreOverrides.Length; i++)
			{
				TrophyHuntDataScoreOverride trophyHuntDataScoreOverride = _m_trophyHuntScoreOverrides[i];
				if (trophyHuntDataScoreOverride.m_gameMode == GetGameMode() && trophyHuntDataScoreOverride.m_trophyName == m_name)
				{
					result = trophyHuntDataScoreOverride.m_score;
					break;
				}
			}
			return result;
		}
	}

	public struct BiomeBonus
	{
		public Biome m_biome;

		public string m_biomeName;

		public int m_bonus;

		public List<string> m_trophies;

		public BiomeBonus(Biome biome, string biomeName, int bonus, List<string> trophies)
		{
			m_biome = biome;
			m_biomeName = biomeName;
			m_bonus = bonus;
			m_trophies = trophies;
		}
	}

	public class TrophyPin
	{
		public Vector3 m_pos;

		public string m_trophyName;
	}

	public enum TrophyGameMode
	{
		TrophyHunt,
		TrophyRush,
		TrophySaga,
		TrophyBlitz,
		TrophyTrailblazer,
		TrophyPacifist,
		CulinarySaga,
		CasualSaga,
		TrophyFiesta,
		Max
	}

	public struct DropInfo
	{
		public int m_numKilled;

		public int m_trophies;

		public DropInfo()
		{
			m_numKilled = 0;
			m_trophies = 0;
			m_numKilled = 0;
			m_trophies = 0;
		}
	}

	[HarmonyPatch(typeof(Game), "SavePlayerProfile")]
	public class Game_SavePlayerProfile_Patch
	{
		private static void Prefix(PlayerProfile __instance, bool setLogoutPoint)
		{
			SavePersistentData();
		}
	}

	public class THMSaveData
	{
		public class THMSaveDataDropInfo
		{
			public string m_name;

			public DropInfo m_dropInfo;
		}

		public class THMSaveDataSpecialSagaDropCount
		{
			public string m_name;

			public int m_dropCount;

			public int m_numPickedUp;
		}

		public class THMSaveDataCharmedCharacter
		{
			public Vector3 m_pos;

			public PinType m_pinType;

			public long m_charmTimeRemaining;

			public Guid m_charmGUID;

			public Faction m_originalFaction;

			public float m_swimSpeed;

			public int m_charmLevel;
		}

		public List<THMSaveDataDropInfo> m_playerTrophyDropInfos;

		public List<THMSaveDataDropInfo> m_allTrophyDropInfos;

		public List<Vector3> m_playerPathData;

		public List<TrophyPin> m_trophyPins;

		public long m_gameTimerElapsedSeconds;

		public long m_internalTimerElapsedSeconds;

		public bool m_gameTimerActive;

		public bool m_gameTimerVisible;

		public bool m_gameTimerCountdown;

		public long m_charmTimerSeconds;

		public List<THMSaveDataCharmedCharacter> m_charmedCharacters;

		public int m_slashDieCount;

		public int m_logoutCount;

		public List<THMSaveDataSpecialSagaDropCount> m_specialSagaDropCounts;

		public long m_storedPlayerID;

		public TrophyGameMode m_storedGameMode;

		public string m_storedWorldSeed;

		public List<string> m_cookedFoods;

		public List<PlayerEventLog> m_playerEventLog;
	}

	[HarmonyPatch(typeof(Player), "OnSpawned")]
	public class Player_OnSpawned_Patch
	{
		private static void Postfix(Player __instance)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Array.Sort(__m_trophyHuntData, (TrophyHuntData x, TrophyHuntData y) => x.m_biome.CompareTo(y.m_biome) * 100000 + x.GetCurGameModeTrophyScoreValue().CompareTo(y.GetCurGameModeTrophyScoreValue()) * 10000 + x.m_name.CompareTo(y.m_name));
			__m_trophyCache = Player.m_localPlayer.GetTrophies();
			if (__m_storedPlayerID != Player.m_localPlayer.GetPlayerID() || __m_storedGameMode != __m_trophyGameMode || __m_storedWorldSeed != WorldGenerator.instance.m_world.m_seedName)
			{
				InitializeTrackedDataForNewPlayer();
			}
			if (__m_showAllTrophyStats || __m_ignoreLogouts || GetGameMode() == TrophyGameMode.TrophyFiesta || GetGameMode() == TrophyGameMode.CulinarySaga || GetGameMode() == TrophyGameMode.CasualSaga || Game.instance.GetPlayerProfile().m_usedCheats || Game.instance.GetPlayerProfile().m_playerStats[(PlayerStatType)4] > 0f)
			{
				__m_invalidForTournamentPlay = true;
			}
			__m_fiestaFlashing = false;
			BuildUIElements();
			if (GetTotalOnFootDistance(Game.instance) < 10f)
			{
				__m_logoutCount = 0;
			}
			Directory.GetCurrentDirectory();
			__m_storedPlayerID = Player.m_localPlayer.GetPlayerID();
			__m_storedGameMode = __m_trophyGameMode;
			__m_storedWorldSeed = WorldGenerator.instance.m_world.m_seedName;
			LoadPersistentData();
			UpdateModUI(Player.m_localPlayer);
			ShowPlayerPath(showPlayerPath: false);
			StopCollectingPlayerPath();
			StartCollectingPlayerPath();
			if (GetGameMode() != TrophyGameMode.TrophyFiesta)
			{
				if (GetGameMode() == TrophyGameMode.TrophyBlitz)
				{
					UnlockEverythingBlitz(Player.m_localPlayer);
				}
				else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
				{
					UnlockEverythingTrailblazer(Player.m_localPlayer);
				}
			}
			__m_refreshLogsAndStandings = true;
			PostStandingsRequest();
			StartPeriodicTimer();
			if (IsPacifist())
			{
				StartCharmTimer();
			}
			foreach (PinData pin in Minimap.instance.m_pins)
			{
				if (pin.m_name.StartsWith("Trophy"))
				{
					pin.m_icon = GetTrophySprite(pin.m_name);
				}
			}
			FixTrophyPins();
			Debug.LogWarning((object)("Loading into Game Mode: " + GetGameModeString(GetGameMode())));
			if (IsPacifist())
			{
				CacheSprites();
				if (!__m_introMessageDisplayed)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, "<color=#F387C5>Trophy Pacifist</color>\nUse Wood Arrows to charm enemies!", 0, (Sprite)null);
					__m_introMessageDisplayed = true;
				}
				DoPacifistPostPlayerSpawnTasks();
			}
		}
	}

	[HarmonyPatch(typeof(Skills), "GetSkill")]
	public class Skills_Learn_Patch
	{
		private static void Postfix(Skill __instance, SkillType skillType, ref Skill __result)
		{
			if (IsSagaMode())
			{
				if (__result.m_level < 20f)
				{
					__result.m_level = 20f;
					__result.m_accumulator = 0f;
				}
			}
			else if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				if (__result.m_level < 100f)
				{
					__result.m_level = 100f;
					__result.m_accumulator = 0f;
				}
			}
			else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer && __result.m_level < 1f)
			{
				__result.m_level = 1f;
				__result.m_accumulator = 0f;
			}
		}
	}

	[HarmonyPatch(typeof(Skill), "Raise")]
	public class Skills_RaiseSkill_Patch
	{
		private static bool Prefix(Skill __instance, ref float factor, bool __result)
		{
			if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				factor *= 6f;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Player), "AddTrophy", new Type[] { typeof(ItemData) })]
	public static class Player_AddTrophy_Patch
	{
		public static void Postfix(Player __instance, ItemData item)
		{
			//IL_007a: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)null) || item == null)
			{
				return;
			}
			string name = ((Object)item.m_dropPrefab).name;
			if (!(__m_trophyCache.Find((string trophyName) => trophyName == name) != name))
			{
				return;
			}
			FlashTrophy(name);
			__m_trophyCache = __instance.GetTrophies();
			UpdateModUI(__instance);
			AddPlayerEvent(PlayerEventType.Trophy, name, ((Component)__instance).transform.position);
			AddTrophyPin(((Component)__instance).transform.position, name);
			if (GetGameMode() == TrophyGameMode.TrophyRush || GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer || GetGameMode() == TrophyGameMode.TrophyPacifist)
			{
				Biome biome = Biome.Meadows;
				if (UpdateBiomeBonusTrophies(name, ref biome))
				{
					MessageHud.instance.ShowBiomeFoundMsg("Biome Bonus", true);
					string text = "Bonus" + biome;
					UpdateModUI(Player.m_localPlayer);
					AddPlayerEvent(PlayerEventType.Misc, text, ((Component)__instance).transform.position);
					Debug.LogError((object)("BIOME BONUS: " + text));
					((Character)__instance).Message((MessageType)1, "Biome Bonus: " + biome, 0, (Sprite)null);
					FlashBiomeTrophies(name);
				}
			}
			if ((IsSagaMode() || GetGameMode() == TrophyGameMode.TrophyRush || GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer) && __m_trophyCache.Count == __m_trophyHuntData.Length && !__m_completedAllBiomeBonuses)
			{
				MessageHud.instance.ShowBiomeFoundMsg("Odin is Pleased", true);
				string eventName = "BonusAll";
				if (GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer)
				{
					CalculateExtraTimeScore();
				}
				__m_completedAllBiomeBonuses = true;
				UpdateModUI(Player.m_localPlayer);
				AddPlayerEvent(PlayerEventType.Misc, eventName, ((Component)__instance).transform.position);
			}
			if (Object.op_Implicit((Object)(object)MessageHud.instance) && (Object)(object)GetTrophySprite(name) != (Object)null)
			{
				Array.Find(__m_trophyHuntData, (TrophyHuntData element) => element.m_name == name);
			}
		}
	}

	[Serializable]
	public class LeaderboardDataEx
	{
		public string event_name;

		public string event_data;
	}

	[Serializable]
	public class LeaderboardData
	{
		public string player_name;

		public int current_score;

		public string session_id;

		public string player_location;

		public string trophies;

		public int deaths;

		public int logouts;

		public string gamemode;
	}

	[HarmonyPatch(typeof(Game), "Logout", new Type[]
	{
		typeof(bool),
		typeof(bool)
	})]
	public static class Game_Logout_Patch
	{
		public static void Postfix(Game __instance, bool save, bool changeToStartScene)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			float totalOnFootDistance = GetTotalOnFootDistance(__instance);
			if (__m_logoutCount < 1 && totalOnFootDistance < 50f)
			{
				return;
			}
			if (!__m_ignoreLogouts)
			{
				__m_logoutCount++;
				AddPlayerEvent(PlayerEventType.Misc, "PenaltyLogout", ((Component)Player.m_localPlayer).transform.position);
				if ((Object)(object)Game.instance != (Object)null)
				{
					Game.instance.SavePlayerProfile(GetGameMode() != TrophyGameMode.TrophyHunt);
				}
			}
			StopPeriodicTimer();
			if (IsPacifist())
			{
				StopCharmTimer();
			}
		}
	}

	public struct LuckRating
	{
		public float m_percent;

		public string m_luckString;

		public string m_colorString;

		public LuckRating(float percent, string luckString, string colorStr)
		{
			m_percent = 0f;
			m_luckString = "<n/a>";
			m_colorString = "white";
			m_percent = percent;
			m_luckString = luckString;
			m_colorString = colorStr;
		}
	}

	public struct SpecialSagaDrop
	{
		public string m_itemName;

		public float m_dropPercent;

		public int m_dropAmountMin;

		public int m_dropAmountMax;

		public bool m_dropOnlyOne;

		public bool m_stopDroppingOnPickup;

		public TrophyGameMode m_onlyInMode;

		public int m_numDropped;

		public int m_numPickedUp;

		public SpecialSagaDrop(string itemName, float dropPercent, int dropAmountMin, int dropAmountMax, bool dropOnlyOne = false, bool stopDroppingOnPickup = false, TrophyGameMode onlyInMode = TrophyGameMode.Max)
		{
			m_itemName = itemName;
			m_dropPercent = dropPercent;
			m_dropAmountMin = dropAmountMin;
			m_dropAmountMax = dropAmountMax;
			m_dropOnlyOne = dropOnlyOne;
			m_stopDroppingOnPickup = stopDroppingOnPickup;
			m_numDropped = 0;
			m_numPickedUp = 0;
			m_onlyInMode = onlyInMode;
		}
	}

	[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
	private class CharacterDrop_GenerateDropList_Patch
	{
		private static void Postfix(CharacterDrop __instance, ref List<KeyValuePair<GameObject, int>> __result)
		{
			if (!((Object)(object)__instance != (Object)null))
			{
				return;
			}
			string name = ((Component)__instance).GetComponent<Character>().m_name;
			if (CharacterCanDropTrophies(name))
			{
				RecordTrophyCapableKill(name, killedByPlayer: false);
				bool flag = false;
				if (__result != null)
				{
					foreach (KeyValuePair<GameObject, int> item3 in __result)
					{
						string name2 = ((Object)item3.Key).name;
						if (name2.Contains("Trophy"))
						{
							RecordDroppedTrophy(name, name2);
							flag = true;
							break;
						}
					}
				}
				else
				{
					Debug.Log((object)("Trophy-capable character " + name + " had null drop list"));
				}
				if (!flag)
				{
					float num = 0f;
					if (GetGameMode() == TrophyGameMode.TrophyRush || GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer || GetGameMode() == TrophyGameMode.TrophyPacifist || (IsSagaMode() && GetGameMode() != TrophyGameMode.CasualSaga))
					{
						string text = EnemyNameToTrophyName(name);
						if (!__m_trophyCache.Contains(text) || text == "TrophyDeer")
						{
							num = 100f;
						}
					}
					if ((float)new Random().NextDouble() * 100f < num)
					{
						string trophyName = EnemyNameToTrophyName(name);
						Drop val = __instance.m_drops.Find((Drop theDrop) => ((Object)theDrop.m_prefab).name == trophyName);
						if (val != null)
						{
							KeyValuePair<GameObject, int> item = new KeyValuePair<GameObject, int>(val.m_prefab, 1);
							if (__result == null)
							{
								__result = new List<KeyValuePair<GameObject, int>>();
							}
							__result.Add(item);
							RecordDroppedTrophy(name, trophyName);
						}
					}
				}
			}
			if (!IsSagaMode() || !__m_specialSagaDrops.ContainsKey(name))
			{
				return;
			}
			List<SpecialSagaDrop> list = __m_specialSagaDrops[name];
			Random random = new Random(Guid.NewGuid().GetHashCode());
			for (int i = 0; i < list.Count; i++)
			{
				SpecialSagaDrop value = list[i];
				if (value.m_onlyInMode != TrophyGameMode.Max && GetGameMode() != value.m_onlyInMode)
				{
					continue;
				}
				bool flag2 = false;
				if (value.m_dropOnlyOne)
				{
					flag2 = HasAnyoneDropped(value.m_itemName);
				}
				if (value.m_stopDroppingOnPickup)
				{
					flag2 = HasBeenPickedUp(value.m_itemName);
				}
				if (flag2 || !((float)random.NextDouble() * 100f < value.m_dropPercent))
				{
					continue;
				}
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(value.m_itemName);
				if ((Object)(object)itemPrefab != (Object)null)
				{
					int num2 = random.Next(value.m_dropAmountMin, value.m_dropAmountMax);
					KeyValuePair<GameObject, int> item2 = new KeyValuePair<GameObject, int>(itemPrefab, num2);
					if (__result != null)
					{
						__result.Add(item2);
						value.m_numDropped += num2;
						list[i] = value;
					}
				}
			}
		}
	}

	[HarmonyPatch(typeof(Character), "OnDeath")]
	public class Character_OnDeath_Patch
	{
		private static bool Prefix(Character __instance)
		{
			if (IsPacifist() && IsCharmed(__instance))
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, "Your thrall " + __instance.m_name + " has fallen!", 0, (Sprite)null);
				}
				RemoveFromCharmedList(__instance);
			}
			return true;
		}

		private static void Postfix(Character __instance)
		{
			if (GetGameMode() == TrophyGameMode.CulinarySaga)
			{
				return;
			}
			bool flag = false;
			if ((Object)(object)Player.m_localPlayer != (Object)null && __instance.m_lastHit != null && (Object)(object)__instance.m_lastHit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				flag = true;
			}
			if (flag)
			{
				string name = __instance.m_name;
				if (CharacterCanDropTrophies(name))
				{
					RecordTrophyCapableKill(name, killedByPlayer: true);
				}
			}
			if (GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				RevealNextBoss(__instance.m_name);
			}
		}
	}

	[HarmonyPatch(typeof(ItemData), "GetWeight")]
	public class Humanoid_ItemDrop_ItemData_GetWeight_Patch
	{
		private static bool Prefix(ItemData __instance, ref float __result)
		{
			if (!IsSagaMode())
			{
				return true;
			}
			if (__instance == null)
			{
				return true;
			}
			if ((Object)(object)__instance.m_dropPrefab == (Object)null)
			{
				return true;
			}
			if (__m_oreNameToBarPrefabName.TryGetValue(((Object)__instance.m_dropPrefab).name, out var value))
			{
				ItemData itemData = ZNetScene.instance.GetPrefab(value).GetComponent<ItemDrop>().m_itemData;
				if (itemData != null)
				{
					__result = itemData.m_shared.m_weight * (float)__instance.m_stack;
				}
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(ItemData), "GetNonStackedWeight")]
	public class Humanoid_ItemDrop_ItemData_GetNonStackedWeight_Patch
	{
		private static bool Prefix(ItemData __instance, ref float __result)
		{
			if (!IsSagaMode())
			{
				return true;
			}
			if (__instance == null)
			{
				return true;
			}
			if ((Object)(object)__instance.m_dropPrefab == (Object)null)
			{
				return true;
			}
			if (__m_oreNameToBarPrefabName.TryGetValue(((Object)__instance.m_dropPrefab).name, out var value))
			{
				ItemData itemData = ZNetScene.instance.GetPrefab(value).GetComponent<ItemDrop>().m_itemData;
				if (itemData != null)
				{
					__result = itemData.m_shared.m_weight;
				}
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
	public static class Inventory_AddItem_Patch
	{
		private static void Prefix(Inventory __instance, ref ItemData item, bool __result)
		{
			if (IsSagaMode() && __m_instaSmelt && __instance != null && (Object)(object)Player.m_localPlayer != (Object)null && __instance == ((Humanoid)Player.m_localPlayer).GetInventory())
			{
				ConvertMetalOresIfNecessary(ref item);
			}
		}
	}

	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	public class Inventory_AddItem_4_Patch
	{
		private static void Postfix(Inventory __instance, ItemData item, int amount, int x, int y, bool __result)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (__instance != null && (Object)(object)Player.m_localPlayer != (Object)null && __instance == ((Humanoid)Player.m_localPlayer).GetInventory() && item != null && (Object)(object)item.m_dropPrefab != (Object)null)
			{
				string text = ((Object)item.m_dropPrefab).name;
				if (item.m_quality > 1)
				{
					text += item.m_quality;
				}
				AddPlayerEvent(PlayerEventType.Item, text, ((Component)Player.m_localPlayer).transform.position);
			}
		}

		private static bool Prefix(Inventory __instance, ItemData item, int amount, int x, int y, ref bool __result)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSagaMode())
			{
				return true;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			if (__instance != ((Humanoid)Player.m_localPlayer).GetInventory())
			{
				return true;
			}
			amount = Mathf.Min(amount, item.m_stack);
			if (x < 0 || y < 0 || x >= __instance.m_width || y >= __instance.m_height)
			{
				__result = false;
				return false;
			}
			bool flag = false;
			ItemData itemAt = __instance.GetItemAt(x, y);
			if (itemAt != null)
			{
				if (itemAt.m_shared.m_name != item.m_shared.m_name || itemAt.m_worldLevel != item.m_worldLevel || (itemAt.m_shared.m_maxQuality > 1 && itemAt.m_quality != item.m_quality))
				{
					__result = false;
					return false;
				}
				int num = itemAt.m_shared.m_maxStackSize - itemAt.m_stack;
				if (num <= 0)
				{
					__result = false;
					return false;
				}
				int num2 = Mathf.Min(num, amount);
				itemAt.m_stack += num2;
				item.m_stack -= num2;
				flag = num2 == amount;
				ZLog.Log((object)("Added to stack" + itemAt.m_stack + " " + item.m_stack));
			}
			else
			{
				ItemData item2 = item.Clone();
				ConvertMetalOresIfNecessary(ref item2);
				item2.m_stack = amount;
				item2.m_gridPos = new Vector2i(x, y);
				__instance.m_inventory.Add(item2);
				item.m_stack -= amount;
				flag = true;
			}
			__instance.Changed();
			__result = flag;
			return false;
		}
	}

	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(string),
		typeof(int),
		typeof(int),
		typeof(int),
		typeof(long),
		typeof(string),
		typeof(Vector2i),
		typeof(bool)
	})]
	public class Inventory_AddItem_2_Patch
	{
		private static void Postfix(Inventory __instance, string name, int stack, int quality, int variant, long crafterID, string crafterName, Vector2i position, bool pickedUp)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (__instance != null)
			{
				string text = name;
				if (quality > 1)
				{
					text += quality;
				}
				AddPlayerEvent(PlayerEventType.Item, text, ((Component)Player.m_localPlayer).transform.position);
			}
		}
	}

	[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
	{
		typeof(ItemData),
		typeof(int)
	})]
	public static class Inventory_CanAddItem_Patch
	{
		private static bool Prefix(Inventory __instance, ref ItemData item, int stack, ref bool __result)
		{
			if (__instance != null && (Object)(object)Player.m_localPlayer != (Object)null && __instance == ((Humanoid)Player.m_localPlayer).GetInventory() && IsSagaMode() && __m_instaSmelt && item != null && (Object)(object)item.m_dropPrefab != (Object)null)
			{
				string name = ((Object)item.m_dropPrefab).name;
				if (__m_oreNameToBarItemName.TryGetValue(name, out var value))
				{
					if (stack <= 0)
					{
						stack = item.m_stack;
					}
					__result = __instance.FindFreeStackSpace(value, 0f) + (__instance.m_width * __instance.m_height - __instance.m_inventory.Count) * item.m_shared.m_maxStackSize >= stack;
					return false;
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	public class Humanoid_Pickup_Patch
	{
		private static void Prefix(Humanoid __instance, GameObject go, bool autoequip, bool autoPickupDelay, bool __result)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			ItemDrop component = go.GetComponent<ItemDrop>();
			if (!((Object)(object)component != (Object)null) || !IsSagaMode())
			{
				return;
			}
			if (__m_instaSmelt)
			{
				ConvertMetal(ref component.m_itemData);
			}
			if (component.m_itemData == null || !((Object)(object)component.m_itemData.m_dropPrefab != (Object)null))
			{
				return;
			}
			string name = ((Object)component.m_itemData.m_dropPrefab).name;
			foreach (KeyValuePair<string, List<SpecialSagaDrop>> _m_specialSagaDrop in __m_specialSagaDrops)
			{
				string key = _m_specialSagaDrop.Key;
				List<SpecialSagaDrop> list = __m_specialSagaDrops[key];
				for (int i = 0; i < list.Count; i++)
				{
					SpecialSagaDrop value = list[i];
					if (value.m_itemName == name && value.m_stopDroppingOnPickup)
					{
						value.m_numPickedUp++;
					}
					list[i] = value;
				}
				foreach (SpecialSagaDrop item in __m_specialSagaDrops[key])
				{
					if (item.m_itemName == name)
					{
						_ = item.m_stopDroppingOnPickup;
					}
				}
			}
		}

		private static void Postfix(Humanoid __instance, GameObject go, bool autoequip, bool autoPickupDelay, bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)go == (Object)null) && GetGameMode() != TrophyGameMode.CulinarySaga)
			{
				ItemData itemData = go.GetComponent<ItemDrop>().m_itemData;
				if (__result && itemData != null && (Object)(object)itemData.m_dropPrefab != (Object)null)
				{
					RecordPlayerPickedUpTrophy(((Object)itemData.m_dropPrefab).name);
				}
			}
		}
	}

	[HarmonyPatch(typeof(Player), "PlacePiece")]
	public class PlacePiecePatch
	{
		private static bool Prefix(Player __instance, Piece piece)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null)
			{
				return true;
			}
			if (GetGameMode() == TrophyGameMode.TrophyBlitz && piece.m_name.ToLower().Contains("bed"))
			{
				((Character)__instance).Message((MessageType)2, "Beds are not allowed in Trophy Blitz!", 0, (Sprite)null);
				return false;
			}
			return true;
		}

		private static void Postfix(Player __instance, Piece piece)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null) && (Object)(object)piece != (Object)null)
			{
				AddPlayerEvent(PlayerEventType.Build, piece.m_name, ((Component)__instance).transform.position);
			}
		}
	}

	public class BossDetails
	{
		public string m_bossCharacterId;

		public string m_bossLocationName;

		public string m_bossName;

		public BossDetails(string bossCharacterId, string bossLocationName, string bossName)
		{
			m_bossCharacterId = bossCharacterId;
			m_bossLocationName = bossLocationName;
			m_bossName = bossName;
		}
	}

	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Recipe),
		typeof(bool),
		typeof(int),
		typeof(int)
	})]
	public static class Player_HaveRequirements_Patch
	{
		private static bool Prefix(Player __instance, Recipe recipe, bool discover, int qualityLevel, int amount, ref bool __result)
		{
			if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				__result = true;
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "CanRepair", new Type[] { typeof(ItemData) })]
	public static class InventoryGui_CanRepair_Patch
	{
		private static bool Prefix(InventoryGui __instance, ItemData item, ref bool __result)
		{
			if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if ((Object)(object)currentCraftingStation == (Object)null)
				{
					return true;
				}
				Recipe recipe = ObjectDB.instance.GetRecipe(item);
				if (((Object)(object)recipe.m_repairStation != (Object)null && recipe.m_repairStation.m_name == currentCraftingStation.m_name) || ((Object)(object)recipe.m_craftingStation != (Object)null && recipe.m_craftingStation.m_name == currentCraftingStation.m_name) || item.m_worldLevel < Game.m_worldLevel)
				{
					__result = true;
					return false;
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(ItemDrop), "SetQuality", new Type[] { typeof(int) })]
	public static class ItemDrop_SetQuality_Patch
	{
		private static void Postfix(ItemDrop __instance, int quality)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected I4, but got Unknown
			if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				bool flag = false;
				ItemType itemType = __instance.m_itemData.m_shared.m_itemType;
				switch (itemType - 1)
				{
				case 0:
				case 1:
				case 8:
				case 9:
				case 12:
				case 14:
				case 15:
				case 17:
				case 19:
				case 20:
				case 22:
				case 23:
					flag = false;
					break;
				case 2:
				case 3:
				case 4:
				case 5:
				case 6:
				case 10:
				case 11:
				case 13:
				case 16:
				case 18:
				case 21:
					flag = true;
					break;
				}
				if (flag)
				{
					__instance.m_itemData.m_quality = __instance.m_itemData.m_shared.m_maxQuality;
				}
			}
		}
	}

	[HarmonyPatch(typeof(SE_Cozy), "Setup", new Type[] { typeof(Character) })]
	public static class SE_Cozy_Setup_Patch
	{
		private static void Postfix(SE_Cozy __instance, Character character)
		{
			if (GetGameMode() == TrophyGameMode.TrophyTrailblazer && (Object)(object)__instance != (Object)null)
			{
				__instance.m_delay = 9f;
			}
		}
	}

	[HarmonyPatch(typeof(SE_Puke), "Setup", new Type[] { typeof(Character) })]
	public static class SE_Puke_Setup_Patch
	{
		private static void Postfix(SE_Puke __instance, Character character)
		{
			if (GetGameMode() == TrophyGameMode.TrophyTrailblazer && (Object)(object)__instance != (Object)null && (Object)(object)character != (Object)null)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode("Rested");
				character.GetSEMan().AddStatusEffect(stableHashCode, true, 0, 0f);
			}
		}
	}

	[HarmonyPatch(typeof(Piece), "FreeBuildKey")]
	public static class Piece_FreeBuildKey_Patch
	{
		private static bool Prefix(ref GlobalKeys __result)
		{
			if (GetGameMode() == TrophyGameMode.TrophyTrailblazer && __m_overrideGlobalKeysForPieceDrops)
			{
				__result = (GlobalKeys)27;
				return false;
			}
			return true;
		}
	}

	public enum PlayerEventType
	{
		None,
		Trophy,
		Build,
		Item,
		Misc,
		Max
	}

	[Serializable]
	public class PlayerEventLog
	{
		public PlayerEventType eventType;

		public string eventName = "";

		public Vector3 eventPos = Vector3.zero;

		public DateTime eventTime = DateTime.MinValue;

		public PlayerEventLog()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			eventType = PlayerEventType.None;
			eventName = "";
			eventPos = Vector3.zero;
			eventTime = DateTime.MinValue;
		}

		public PlayerEventLog(PlayerEventType _eventType, string _eventName, Vector3 _eventPos, DateTime _eventTime)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			eventType = _eventType;
			eventName = _eventName;
			eventPos = _eventPos;
			eventTime = _eventTime;
		}
	}

	public struct EventDescription
	{
		public PlayerEventType eventType;

		public List<string> legalEvents;

		public EventDescription(PlayerEventType _eventType, List<string> _legalEvents)
		{
			eventType = _eventType;
			legalEvents = _legalEvents;
		}
	}

	[Serializable]
	public class TrackLogEntry
	{
		public string id;

		public string seed;

		public int score;

		public string code;
	}

	[Serializable]
	public class TrackLogs
	{
		public string id;

		public string user;

		public string seed;

		public string mode;

		public int score;

		public List<TrackLogsElement> logs;
	}

	[Serializable]
	public class TrackLogsElement
	{
		public string code;

		public string at;
	}

	[Serializable]
	public class TrackHunt
	{
		public string id;

		public string user;

		public string seed;

		public string mode;

		public int score;

		public int deaths;

		public int relogs;

		public int slashdies;

		public List<string> trophies;
	}

	public enum TournamentStatus
	{
		NotRunning = 0,
		Live = 20,
		Over = 30
	}

	public class TournamentPlayerInfo
	{
		public string name;

		public int score;

		public string id;

		public TournamentPlayerInfo(string _name, int _score, string _id)
		{
			name = _name;
			score = _score;
			id = _id;
		}
	}

	[Serializable]
	public class TrackStandingsPlayer
	{
		public string name = "";

		public string id = "";

		public string avatarUrl = "";

		public int score;
	}

	[Serializable]
	public class TrackStandings
	{
		public string name = "";

		public string mode = "";

		public string startAt = "";

		public string endAt = "";

		public int status;

		public List<TrackStandingsPlayer> players = new List<TrackStandingsPlayer>();
	}

	[HarmonyPatch(typeof(FejdStartup), "Start")]
	public class FejdStartup_Start_Patch
	{
		private static void Postfix()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("Menu");
			if ((Object)(object)val != (Object)null)
			{
				GameObject obj = GameObject.Find("Topic");
				__m_globalFontObject = ((TMP_Text)((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null)).font;
				Transform val2 = val.transform.Find("Logo");
				if ((Object)(object)val2 != (Object)null)
				{
					GameObject val3 = new GameObject("TrophyHuntModLogoText");
					val3.transform.SetParent(val2.parent);
					RectTransform obj2 = val3.AddComponent<RectTransform>();
					((Transform)obj2).localScale = Vector3.one;
					obj2.anchorMin = new Vector2(0.5f, 0.6f);
					obj2.anchorMax = new Vector2(1f, 0.6f);
					obj2.pivot = new Vector2(1f, 1f);
					obj2.anchoredPosition = new Vector2(-20f, 20f);
					obj2.sizeDelta = new Vector2(-650f, 185f);
					__m_trophyHuntMainMenuText = AddTextMeshProComponent(val3);
					((TMP_Text)__m_trophyHuntMainMenuText).font = __m_globalFontObject;
					((TMP_Text)__m_trophyHuntMainMenuText).fontMaterial = ((TMP_Asset)__m_globalFontObject).material;
					((TMP_Text)__m_trophyHuntMainMenuText).fontStyle = (FontStyles)1;
					((TMP_Text)__m_trophyHuntMainMenuText).text = GetTrophyHuntMainMenuText();
					((TMP_Text)__m_trophyHuntMainMenuText).alignment = (TextAlignmentOptions)513;
					((TMP_Text)__m_trophyHuntMainMenuText).lineSpacingAdjustment = -5f;
					AddToggleGameModeButton(val3.transform);
					AddTogglePacifistButton(val3.transform);
					GameObject val4 = new GameObject("AvatarObject");
					val4.transform.SetParent(val3.transform);
					RectTransform obj3 = val4.AddComponent<RectTransform>();
					obj3.sizeDelta = new Vector2(320f, 78f);
					obj3.anchoredPosition = new Vector2(30f, -335f);
					((Transform)obj3).localScale = Vector3.one;
					__m_discordBackgroundImage = val4.AddComponent<Image>();
					((Graphic)__m_discordBackgroundImage).raycastTarget = false;
					((Graphic)__m_discordBackgroundImage).color = Color.black;
					((Graphic)__m_discordBackgroundImage).CrossFadeAlpha(1f, 20f, false);
					AddLoginWithDiscordButton(val3.transform);
				}
				else
				{
					Debug.LogWarning((object)"Valheim logo not found!");
				}
			}
			else
			{
				Debug.LogWarning((object)"Main menu not found!");
			}
		}
	}

	[HarmonyPatch(typeof(FejdStartup), "OnNewWorldDone", new Type[] { typeof(bool) })]
	public class FejdStartup_OnNewWorldDone_Patch
	{
		private static void Postfix(FejdStartup __instance, bool forceLocal)
		{
			if (FejdStartup.m_instance.m_world != null)
			{
				if (GetGameMode() == TrophyGameMode.TrophyRush)
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Clear();
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("playerdamage 70");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("enemydamage 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("enemyspeedsize 120");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("enemyleveluprate 140");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("resourcerate 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("preset combat_veryhard:deathpenalty_default: resources_muchmore: raids_default: portals_default");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
				else if (IsSagaMode())
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Clear();
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("resourcerate 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("eventrate 0");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("teleportall");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("preset combat_default:deathpenalty_default:resources_muchmore:raids_none:portals_casual");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
				else if (GetGameMode() == TrophyGameMode.TrophyFiesta)
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Clear();
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("enemyspeedsize 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("enemyleveluprate 300");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
				else if (GetGameMode() == TrophyGameMode.TrophyBlitz)
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Clear();
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("deathkeepequip");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("skillreductionrate 15");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("resourcerate 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("eventrate 0");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("teleportall");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("nobuildcost");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("preset combat_default:deathpenalty_casual: resources_muchmore: raids_none: portals_casual");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
				else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Clear();
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("deathkeepequip");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("skillreductionrate 15");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("resourcerate 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("eventrate 0");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("teleportall");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("nobuildcost");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("preset combat_default:deathpenalty_casual: resources_muchmore: raids_none: portals_casual");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
				else if (GetGameMode() == TrophyGameMode.TrophyPacifist)
				{
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("resourcerate 200");
					FejdStartup.m_instance.m_world.m_startingGlobalKeys.Add("preset combat_default:deathpenalty_default:resources_muchmore:raids_none:portals_default");
					FejdStartup.m_instance.m_world.SaveWorldMetaData(DateTime.Now);
					__instance.UpdateWorldList(true);
				}
			}
		}
	}

	[HarmonyPatch(typeof(ConsoleCommand), "RunAction", new Type[] { typeof(ConsoleEventArgs) })]
	public static class ConsoleCommand_RunAction_Patch
	{
		private static void Postfix(ConsoleEventArgs args)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				if (args.Length > 0 && args[0] == "die")
				{
					__m_slashDieCount++;
					AddPlayerEvent(PlayerEventType.Misc, "PenaltySlashDie", ((Component)Player.m_localPlayer).transform.position);
				}
				if (args.Length > 0 && args[0] == "devcommands")
				{
					Debug.LogError((object)"INVALID FOR TOURNAMENT PLAY!: devcommands USED");
					__m_invalidForTournamentPlay = true;
					SetScoreTextElementColor(Color.green);
					UpdateModUI(Player.m_localPlayer);
				}
				if (Game.instance.GetPlayerProfile().m_usedCheats || Game.instance.GetPlayerProfile().m_playerStats[(PlayerStatType)4] > 0f)
				{
					Debug.LogError((object)"INVALID FOR TOURNAMENT PLAY!: cheats USED");
					__m_invalidForTournamentPlay = true;
					SetScoreTextElementColor(Color.green);
					UpdateModUI(Player.m_localPlayer);
				}
			}
		}
	}

	[HarmonyPatch(typeof(Player), "OnDeath")]
	public static class Patch_Player_OnDeath
	{
		private static void Prefix(Player __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)null)
			{
				AddPlayerEvent(PlayerEventType.Misc, "PenaltyDeath", ((Component)__instance).transform.position);
			}
		}
	}

	[HarmonyPatch(typeof(Ship), "GetSailForce")]
	public class Ship_GetSailForce_Patch
	{
		private static void Postfix(ref Vector3 __result)
		{
			//IL_0009: 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_0018: 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_0032: 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_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)
			if (IsSagaMode())
			{
				__result *= __m_sagaSailingSpeedMultiplier;
			}
			else if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				__result *= __m_blitzSailingSpeedMultiplier;
			}
			else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				__result *= __m_trailblazerSailingSpeedMultiplier;
			}
		}
	}

	[HarmonyPatch(typeof(Ship), "Awake")]
	public class Ship_Awake_Patch
	{
		private static void Postfix(Ship __instance)
		{
			if (IsSagaMode())
			{
				__instance.m_backwardForce *= __m_sagaPaddlingSpeedMultiplier;
			}
			else if (GetGameMode() == TrophyGameMode.TrophyBlitz)
			{
				__instance.m_backwardForce *= __m_blitzPaddlingSpeedMultiplier;
			}
			else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				__instance.m_backwardForce *= __m_trailblazerPaddlingSpeedMultiplier;
			}
		}
	}

	[HarmonyPatch(typeof(TreeBase), "Damage")]
	public static class TreeBase_Damage_Patch
	{
		private static void Prefix(TreeBase __instance, ref HitData hit)
		{
			if (__m_elderPowerCutsAllTrees)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && localPlayer.GetGuardianPowerName() == "GP_TheElder" && localPlayer.m_guardianPowerCooldown > 0f)
				{
					hit.m_toolTier = (short)__instance.m_minToolTier;
				}
			}
		}
	}

	[HarmonyPatch(typeof(TreeLog), "Damage")]
	public static class TreeLog_Damage_Patch
	{
		private static void Prefix(TreeLog __instance, ref HitData hit)
		{
			if (__m_elderPowerCutsAllTrees)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && localPlayer.GetGuardianPowerName() == "GP_TheElder" && localPlayer.m_guardianPowerCooldown > 0f)
				{
					hit.m_toolTier = (short)__instance.m_minToolTier;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Fermenter), "Awake")]
	public static class Fermenter_AddItem_Patch
	{
		private static void Postfix(Fermenter __instance)
		{
			if (((Object)(object)__instance != (Object)null && (IsSagaMode() || GetGameMode() == TrophyGameMode.TrophyBlitz)) || GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				__instance.m_fermentationDuration = 10f;
			}
		}
	}

	[HarmonyPatch(typeof(Fermenter), "DelayedTap")]
	public static class Fermenter_DelayedTap_Patch
	{
		private static void Prefix(Fermenter __instance)
		{
			if (((Object)(object)__instance != (Object)null && (IsSagaMode() || GetGameMode() == TrophyGameMode.TrophyBlitz)) || GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				ItemConversion itemConversion = __instance.GetItemConversion(__instance.m_delayedTapItem);
				if (itemConversion != null)
				{
					itemConversion.m_producedItems = 9;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Plant), "TimeSincePlanted")]
	public static class Plant_GetGrowTime_Patch
	{
		private static void Postfix(Plant __instance, ref double __result)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				if (IsSagaMode())
				{
					__result = (double)__instance.m_growTimeMax + 1.0;
				}
				else if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
				{
					__result = (double)__instance.m_growTimeMax + 1.0;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Smelter), "Awake")]
	public static class Smelter_Awake_Patch
	{
		private static void Postfix(Smelter __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				if (__instance.m_name.Contains("eitr"))
				{
					__instance.m_secPerProduct = 1f;
				}
				else if (!__instance.m_name.Contains("bathtub") && !__instance.m_name.Contains("batteringram"))
				{
					__instance.m_secPerProduct = 0.03f;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Smelter), "OnAddFuel")]
	public static class Smelter_OnAddFuel_Patch
	{
		private static void Postfix(Smelter __instance, Switch sw, Humanoid user, ItemData item, bool __result)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode() && __instance.m_name.Contains("eitr") && __instance.GetQueueSize() < __instance.m_maxOre)
			{
				__instance.m_nview.InvokeRPC("RPC_AddOre", new object[1] { "Softtissue" });
			}
		}
	}

	[HarmonyPatch(typeof(SapCollector), "Awake")]
	public static class SapCollector_Awake_Patch
	{
		private static void Postfix(SapCollector __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				__instance.m_secPerUnit = 0.1f;
			}
		}
	}

	[HarmonyPatch(typeof(Beehive), "Awake")]
	public static class Beehive_Awake_Patch
	{
		private static void Postfix(Beehive __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				__instance.m_secPerUnit = 5f;
				__instance.m_maxHoney = 4;
			}
		}
	}

	[HarmonyPatch(typeof(MineRock5), "Awake")]
	public static class MineRock5_Awake_Patch
	{
		private static void Postfix(MineRock5 __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				DropTable dropItems = __instance.m_dropItems;
				dropItems.m_dropMin *= 2;
				DropTable dropItems2 = __instance.m_dropItems;
				dropItems2.m_dropMax *= 3;
			}
		}
	}

	[HarmonyPatch(typeof(LoadingIndicator), "Awake")]
	public static class LoadingIndicator_Awake_Patch
	{
		private static void Postfix(LoadingIndicator __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)null))
			{
				return;
			}
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				string text = "Assets/UI/textures/small/trophies.png";
				if (allLoadedAssetBundle.Contains(text))
				{
					Object obj = allLoadedAssetBundle.LoadAsset(text);
					Texture2D val = (Texture2D)(object)((obj is Texture2D) ? obj : null);
					if (val != null)
					{
						Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
						__instance.m_spinner.sprite = val2;
						((Graphic)__instance.m_spinner).color = new Color(1f, 43f / 51f, 0f, 1f);
						__instance.m_spinnerOriginalColor = ((Graphic)__instance.m_spinner).color;
						__m_trophySprite = val2;
					}
					break;
				}
				text = "Assets/UI/textures/small/health.png";
				if (allLoadedAssetBundle.Contains(text))
				{
					Debug.LogError((object)"Found Health Sprite");
					Object obj2 = allLoadedAssetBundle.LoadAsset(text);
					Texture2D val3 = (Texture2D)(object)((obj2 is Texture2D) ? obj2 : null);
					if (val3 != null)
					{
						__m_healthSprite = Sprite.Create(val3, new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), new Vector2(0.5f, 0.5f));
					}
					break;
				}
			}
		}
	}

	[HarmonyPatch(typeof(EggGrow), "Start")]
	public static class EggGrow_Start_Patch
	{
		private static void Postfix(EggGrow __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				__instance.m_growTime = 2f;
			}
		}
	}

	[HarmonyPatch(typeof(Growup), "Start")]
	public static class Growup_Start_Patch
	{
		private static void Postfix(Growup __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode())
			{
				__instance.m_growTime = 1f;
			}
		}
	}

	[HarmonyPatch(typeof(Procreation), "Awake")]
	public static class Procreation_Awake_Patch
	{
		private static void Postfix(Procreation __instance)
		{
			if ((Object)(object)__instance != (Object)null && IsSagaMode() && ((Object)__instance).name.Contains("Hen"))
			{
				__instance.m_pregnancyDuration = 0.1f;
				__instance.m_pregnancyChance = 0f;
				__instance.m_updateInterval = 1f;
			}
		}
	}

	public class ConsumableData
	{
		public string m_prefabName;

		public string m_itemName;

		public string m_displayName;

		public Biome m_biome;

		public int m_points;

		public float m_health;

		public float m_stamina;

		public float m_eitr;

		public float m_regen;

		public ConsumableData(string prefab, string item, string display, Biome biome, int points, float health, float stamina, float eitr, float regen)
		{
			m_prefabName = prefab;
			m_itemName = item;
			m_displayName = display;
			m_biome = biome;
			m_points = points;
			m_health = health;
			m_stamina = stamina;
			m_eitr = eitr;
			m_regen = regen;
		}
	}

	[HarmonyPatch(typeof(Player), "PlacePiece", new Type[]
	{
		typeof(Piece),
		typeof(Vector3),
		typeof(Quaternion),
		typeof(bool)
	})]
	public static class Player_PlacePiece_Patch
	{
		public static void Postfix(Player __instance, Piece piece, Vector3 pos, Quaternion rot, bool doAttack)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer) && (Object)(object)piece != (Object)null && (((Object)piece).name == "portal_wood" || ((Object)piece).name == "portal_stone"))
			{
				AddPortalPin(pos);
			}
		}
	}

	[HarmonyPatch(typeof(Piece), "DropResources")]
	public static class Piece_DropResources_Patch
	{
		public static bool Prefix(Piece __instance, HitData hitData)
		{
			if (GetGameMode() == TrophyGameMode.TrophyTrailblazer && !__instance.IsPlacedByPlayer())
			{
				__m_overrideGlobalKeysForPieceDrops = true;
			}
			return true;
		}

		public static void Postfix(Piece __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer)
			{
				if (GetGameMode() == TrophyGameMode.TrophyTrailblazer)
				{
					__m_overrideGlobalKeysForPieceDrops = false;
				}
				Vector3 position = ((Component)__instance).transform.position;
				if ((Object)(object)((Component)__instance).GetComponent<TeleportWorld>() != (Object)null)
				{
					RemovePortalPin(position);
				}
			}
		}
	}

	[HarmonyPatch(typeof(TeleportWorld), "SetText")]
	public static class TeleportWorld_SetText_Patch
	{
		public static void Postfix(TeleportWorld __instance, string text)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if ((GetGameMode() == TrophyGameMode.TrophyBlitz || GetGameMode() == TrophyGameMode.TrophyTrailblazer) && (Object)(object)__instance != (Object)null)
			{
				RenamePortalPin(((Component)__instance).transform.position, text);
			}
		}
	}

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

		public static ConsoleEventFailable <>9__82_0;

		public static ConsoleEvent <>9__82_1;

		public static ConsoleEvent <>9__82_2;

		public static ConsoleEvent <>9__82_3;

		public static ConsoleEvent <>9__82_4;

		public static ConsoleEvent <>9__82_5;

		public static ConsoleEvent <>9__82_6;

		public static ConsoleEvent <>9__82_7;

		public static ConsoleEvent <>9__82_8;

		public static ConsoleEvent <>9__82_9;

		public static ConsoleEvent <>9__82_10;

		public static ConsoleEvent <>9__82_11;

		public static ConsoleEvent <>9__82_12;

		public static ConsoleEvent <>9__82_13;

		public static ConsoleEvent <>9__82_14;

		public static ConsoleEvent <>9__82_15;

		public static ConsoleEvent <>9__82_16;

		public static ConsoleEvent <>9__82_17;

		public static UnityAction<BaseEventData> <>9__315_1;

		public static UnityAction<BaseEventData> <>9__325_1;

		public static UnityAction<BaseEventData> <>9__339_1;

		public static Comparison<TournamentPlayerInfo> <>9__340_0;

		public static UnityAction<BaseEventData> <>9__351_1;

		public static Action <>9__385_0;

		internal object <AddConsoleCommands>b__82_0(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'trophyhunt' console command can only be used in-game.");
				return true;
			}
			PrintToConsole("[Trophy Hunt Scoring]");
			PrintToConsole("Trophies:");
			int num = CalculateTrophyPoints(displayToLog: true);
			PrintToConsole($"Trophy Score Total: {num}");
			int num2 = CalculateDeathPenalty();
			int num3 = CalculateLogoutPenalty();
			PrintToConsole("Penalties:");
			PrintToConsole($"  Deaths: {__m_deaths} Score: {num2}");
			PrintToConsole($"  Logouts: {__m_logoutCount} Score: {num3}");
			int num4 = 0;
			if (GetGameMode() == TrophyGameMode.TrophyRush)
			{
				CalculateBiomeBonusScore(Player.m_localPlayer);
				PrintToConsole($"Biome Bonus Total: {num4}");
			}
			num += num2;
			num += num3;
			num += num4;
			PrintToConsole($"Total Score: {num}");
			if (args.Length > 1)
			{
				_ = args[1];
			}
			return true;
		}

		internal void <AddConsoleCommands>b__82_1(ConsoleEventArgs args)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Debug.LogError((object)"ObjectDB is not initialized yet.");
				return;
			}
			foreach (Recipe recipe in instance.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null) && (Object)(object)recipe.m_item != (Object)null)
				{
					CraftingStation craftingStation = recipe.m_craftingStation;
					string text = "n/a";
					if (Object.op_Implicit((Object)(object)craftingStation))
					{
						text = ((Object)craftingStation).name;
					}
					int minStationLevel = recipe.m_minStationLevel;
					Debug.LogWarning((object)$"{((Object)recipe).name} {recipe.m_item.m_itemData.m_shared.m_itemType}: {text} {minStationLevel}");
					Requirement[] resources = recipe.m_resources;
					foreach (Requirement val in resources)
					{
						Debug.LogWarning((object)$"  req: {((Object)val.m_resItem).name} {val.m_amount}");
					}
				}
			}
		}

		internal void <AddConsoleCommands>b__82_2(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'showpath' console command can only be used in-game.");
			}
			ShowPlayerPath(Object.op_Implicit((Object)(object)Player.m_localPlayer));
		}

		internal void <AddConsoleCommands>b__82_3(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'showbosses' console command can only be used in-game.");
			}
			RevealAllBosses(Player.m_localPlayer);
		}

		internal void <AddConsoleCommands>b__82_4(ConsoleEventArgs args)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'/ignorelogouts' can only be used in gameplay.");
				return;
			}
			__m_ignoreLogouts = !__m_ignoreLogouts;
			__m_invalidForTournamentPlay = true;
			if ((Object)(object)__m_scoreTextElement != (Object)null && __m_ignoreLogouts)
			{
				((Graphic)__m_scoreTextElement.GetComponent<TextMeshProUGUI>()).color = Color.green;
			}
			if ((Object)(object)__m_relogsTextElement != (Object)null && __m_ignoreLogouts)
			{
				((Graphic)__m_relogsTextElement.GetComponent<TextMeshProUGUI>()).color = Color.gray;
			}
		}

		internal void <AddConsoleCommands>b__82_5(ConsoleEventArgs args)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'/showalltrophystats' can only be used in gameplay.");
				return;
			}
			ToggleShowAllTrophyStats();
			__m_invalidForTournamentPlay = true;
			if ((Object)(object)__m_scoreTextElement != (Object)null && __m_showAllTrophyStats)
			{
				((Graphic)__m_scoreTextElement.GetComponent<TextMeshProUGUI>()).color = Color.green;
			}
			InitializeSagaDrops();
		}

		internal void <AddConsoleCommands>b__82_6(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'togglescorebackground' console command can only be used in-game.");
			}
			__m_scoreBGElement.GetComponent<RectTransform>();
			__m_scoreBGElement.SetActive(!__m_scoreBGElement.activeSelf);
		}

		internal void <AddConsoleCommands>b__82_7(ConsoleEventArgs args)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'scorescale' console command can only be used in-game.");
			}
			if (args.Length > 1)
			{
				float num = float.Parse(args[1]);
				if (num == 0f)
				{
					num = 1f;
				}
				__m_userTextScale = num;
			}
			else
			{
				__m_userTextScale = 1f;
			}
			((Transform)__m_scoreTextElement.GetComponent<RectTransform>()).localScale = new Vector3(__m_userTextScale, __m_userTextScale, __m_userTextScale);
		}

		internal void <AddConsoleCommands>b__82_8(ConsoleEventArgs args)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'trophyscale' console command can only be used in-game.");
			}
			if (args.Length > 1)
			{
				float num = float.Parse(args[1]);
				if (num == 0f)
				{
					num = 1f;
				}
				__m_userIconScale = num;
				if (args.Length > 2)
				{
					float num2 = float.Parse(args[2]);
					if (num2 == 0f)
					{
						num2 = 1f;
					}
					__m_baseTrophyScale = num2;
				}
			}
			else
			{
				__m_userIconScale = 1f;
				__m_baseTrophyScale = 1f;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer != (Object)null))
			{
				return;
			}
			localPlayer.GetTrophies();
			TrophyHuntData[] _m_trophyHuntData = __m_trophyHuntData;
			for (int i = 0; i < _m_trophyHuntData.Length; i++)
			{
				TrophyHuntData trophyHuntData = _m_trophyHuntData[i];
				<>c__DisplayClass82_0 CS$<>8__locals0 = new <>c__DisplayClass82_0
				{
					trophyName = trophyHuntData.m_name
				};
				GameObject val = __m_iconList.Find((GameObject gameObject) => ((Object)gameObject).name == CS$<>8__locals0.trophyName);
				if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<Image>() != (Object)null)
				{
					RectTransform component = val.GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						((Transform)component).localScale = new Vector3(__m_baseTrophyScale, __m_baseTrophyScale, __m_baseTrophyScale) * __m_userIconScale;
					}
				}
			}
		}

		internal void <AddConsoleCommands>b__82_9(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				PrintToConsole("'trophyspacing' console command can only be used in-game.");
			}
			else
			{
				if ((Object)(o