using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace AltDyrnwyn;

[BepInPlugin("local.altdyrnwyn", "Alt Dyrnwyn", "0.1.1")]
public sealed class Plugin : BaseUnityPlugin
{
	private sealed class CraftContext
	{
		internal Inventory Inventory;

		internal bool Repeat;
	}

	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	private static class DatabaseReady
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(ObjectDB __instance)
		{
			Register(__instance);
		}
	}

	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	private static class DatabaseCopied
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(ObjectDB __instance)
		{
			Register(__instance);
		}
	}

	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	private static class WorldReady
	{
		[HarmonyPriority(0)]
		[HarmonyPostfix]
		private static void Postfix()
		{
			Register(ObjectDB.instance);
		}
	}

	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Recipe),
		typeof(bool),
		typeof(int),
		typeof(int)
	})]
	private static class UnlockCheck
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance, Recipe __0, int __2, ref bool __result)
		{
			if (!IsRepeat(__0) || (Discovered(__instance) && __2 <= 1))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}

	[HarmonyPatch(typeof(Player), "GetAvailableRecipes")]
	private static class HideLockedRecipe
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance, ref List<Recipe> __0)
		{
			if (!Discovered(__instance))
			{
				__0.RemoveAll(IsRepeat);
			}
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "AddRecipeToList")]
	private static class NoDuplicateUpgrade
	{
		[HarmonyPrefix]
		private static bool Prefix(Recipe __1, ItemData __2)
		{
			if (IsRepeat(__1))
			{
				return __2 == null;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	private static class CraftingOrigin
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __0, Recipe ___m_craftRecipe, ItemData ___m_craftUpgradeItem, out CraftContext __state)
		{
			__state = crafting;
			crafting = null;
			if (IsRepeat(___m_craftRecipe) && (!Discovered(__0) || ___m_craftUpgradeItem != null))
			{
				return false;
			}
			if ((Object)(object)___m_craftRecipe != (Object)null && (Object)(object)___m_craftRecipe.m_item != (Object)null && ((Object)((Component)___m_craftRecipe.m_item).gameObject).name == "SwordDyrnwyn")
			{
				CraftContext craftContext = new CraftContext();
				craftContext.Inventory = ((Humanoid)__0).GetInventory();
				craftContext.Repeat = ((___m_craftUpgradeItem == null) ? IsRepeat(___m_craftRecipe) : FromRepeat(___m_craftUpgradeItem));
				crafting = craftContext;
			}
			return true;
		}

		[HarmonyFinalizer]
		private static void Finalizer(CraftContext __state)
		{
			crafting = __state;
		}
	}

	[HarmonyPatch]
	private static class StampCraftedItem
	{
		private static MethodBase TargetMethod()
		{
			foreach (MethodInfo declaredMethod in AccessTools.GetDeclaredMethods(typeof(Inventory)))
			{
				ParameterInfo[] parameters = declaredMethod.GetParameters();
				if (declaredMethod.Name == "AddItem" && declaredMethod.ReturnType == typeof(ItemData) && parameters.Length == 8 && parameters[0].ParameterType == typeof(string))
				{
					return declaredMethod;
				}
			}
			throw new MissingMethodException("Inventory.AddItem(string, ..., Vector2i, bool)");
		}

		[HarmonyPostfix]
		private static void Postfix(Inventory __instance, string __0, ItemData __result)
		{
			if (crafting != null && crafting.Inventory == __instance && !(__0 != "SwordDyrnwyn") && __result != null)
			{
				if (crafting.Repeat)
				{
					__result.m_customData["local.altdyrnwyn.repeat"] = "1";
				}
				else
				{
					__result.m_customData.Remove("local.altdyrnwyn.repeat");
				}
			}
		}
	}

	[HarmonyPatch(typeof(ObjectDB), "GetRecipe")]
	private static class MatchRefundRecipe
	{
		[HarmonyPostfix]
		private static void Postfix(ItemData __0, ref Recipe __result)
		{
			if ((Object)(object)repeatRecipe != (Object)null && FromRepeat(__0) && __0.m_shared.m_name == repeatRecipe.m_item.m_itemData.m_shared.m_name)
			{
				__result = repeatRecipe;
			}
		}
	}

	public const string PluginId = "local.altdyrnwyn";

	private const string RepeatName = "Recipe_AltDyrnwyn_Repeat";

	private const string OriginKey = "local.altdyrnwyn.repeat";

	private static Plugin instance;

	private static Recipe repeatRecipe;

	[ThreadStatic]
	private static CraftContext crafting;

	private void Awake()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		instance = this;
		new Harmony("local.altdyrnwyn").PatchAll(typeof(Plugin).Assembly);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Alt Dyrnwyn loaded.");
	}

	private static ItemDrop Item(ObjectDB db, string id)
	{
		GameObject itemPrefab = db.GetItemPrefab(id);
		ItemDrop val = (((Object)(object)itemPrefab == (Object)null) ? null : itemPrefab.GetComponent<ItemDrop>());
		if ((Object)(object)val == (Object)null)
		{
			throw new InvalidOperationException("Missing item: " + id);
		}
		return val;
	}

	private static Requirement Copy(Requirement source)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		Requirement val = new Requirement();
		FieldInfo[] fields = typeof(Requirement).GetFields(BindingFlags.Instance | BindingFlags.Public);
		foreach (FieldInfo fieldInfo in fields)
		{
			fieldInfo.SetValue(val, fieldInfo.GetValue(source));
		}
		return val;
	}

	private static void Register(ObjectDB db)
	{
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Expected O, but got Unknown
		if ((Object)(object)instance == (Object)null || (Object)(object)db == (Object)null || (Object)(object)db.GetItemPrefab("SwordDyrnwyn") == (Object)null)
		{
			return;
		}
		try
		{
			Recipe val = db.m_recipes.Find((Recipe r) => (Object)(object)r != (Object)null && ((Object)r).name == "Recipe_AltDyrnwyn_Repeat");
			if ((Object)(object)val != (Object)null)
			{
				repeatRecipe = val;
				return;
			}
			ItemDrop sword = Item(db, "SwordDyrnwyn");
			ItemDrop resItem = Item(db, "MoltenCore");
			ItemDrop resItem2 = Item(db, "FlametalNew");
			Recipe val2 = db.m_recipes.Find((Recipe r) => (Object)(object)r != (Object)null && ((Object)r).name == "Recipe_SwordFire" && (Object)(object)r.m_item == (Object)(object)sword);
			if ((Object)(object)val2 == (Object)null)
			{
				throw new InvalidOperationException("Vanilla Recipe_SwordFire was not found.");
			}
			List<Requirement> list = new List<Requirement>();
			Requirement val3 = null;
			Requirement[] resources = val2.m_resources;
			foreach (Requirement val4 in resources)
			{
				string name = ((Object)((Component)val4.m_resItem).gameObject).name;
				if (!(name == "FlametalNew") && !(name == "Flametal"))
				{
					Requirement val5 = Copy(val4);
					if (name == "GemstoneRed" || name == "MoltenCore")
					{
						val5.m_resItem = resItem;
						val3 = val5;
					}
					list.Add(val5);
				}
			}
			if (val3 == null)
			{
				throw new InvalidOperationException("Dyrnwyn's Bloodstone requirement was not found.");
			}
			Recipe val6 = Object.Instantiate<Recipe>(val2);
			((Object)val6).name = "Recipe_AltDyrnwyn_Repeat";
			val6.m_enabled = true;
			val6.m_amount = 1;
			val6.m_requireOnlyOneIngredient = false;
			Requirement val7 = Copy(val3);
			val7.m_amount = 1;
			Requirement[] array = (Requirement[])(object)new Requirement[2];
			Requirement val8 = new Requirement();
			val8.m_resItem = resItem2;
			val8.m_amount = 40;
			val8.m_amountPerLevel = 0;
			val8.m_recover = true;
			array[0] = val8;
			array[1] = val7;
			val6.m_resources = array;
			val2.m_resources = list.ToArray();
			db.m_recipes.Add(val6);
			repeatRecipe = val6;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)instance).Logger.LogError((object)("Dyrnwyn recipes were not registered: " + ex));
		}
	}

	private static bool IsRepeat(Recipe recipe)
	{
		if ((Object)(object)recipe != (Object)null)
		{
			return ((Object)recipe).name == "Recipe_AltDyrnwyn_Repeat";
		}
		return false;
	}

	private static bool Discovered(Player player)
	{
		if ((Object)(object)player != (Object)null && (Object)(object)repeatRecipe != (Object)null)
		{
			return player.IsMaterialKnown(repeatRecipe.m_item.m_itemData.m_shared.m_name);
		}
		return false;
	}

	private static bool FromRepeat(ItemData item)
	{
		if (item != null && item.m_customData != null && item.m_customData.TryGetValue("local.altdyrnwyn.repeat", out var value))
		{
			return value == "1";
		}
		return false;
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace AltStonePortal;

[BepInPlugin("local.altstoneportal", "Alt Stone Portal", "0.1.6")]
public sealed class Plugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(TeleportWorld), "Awake")]
	private static class PortalReady
	{
		[HarmonyPostfix]
		private static void Postfix(TeleportWorld __instance)
		{
			string name = ((Object)((Component)__instance).gameObject).name;
			if ((!(name != "portal_stone") || !(name != "portal_stone(Clone)")) && (Object)(object)((Component)__instance).GetComponent<PortalRecolor>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<PortalRecolor>();
			}
		}
	}

	[HarmonyPatch(typeof(EffectList), "Create")]
	private static class ConnectionEffectReady
	{
		[HarmonyPostfix]
		private static void Postfix(GameObject[] __result)
		{
			if (__result == null)
			{
				return;
			}
			foreach (GameObject val in __result)
			{
				if (!((Object)(object)val != (Object)null) || !(((Object)val).name == "fx_portal_stone_connected(Clone)"))
				{
					continue;
				}
				try
				{
					PortalRecolor.TintEffects(val);
				}
				catch (Exception ex)
				{
					if ((Object)(object)instance != (Object)null)
					{
						((BaseUnityPlugin)instance).Logger.LogError((object)("Connection recolor failed: " + ex));
					}
				}
			}
		}
	}

	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	private static class SceneReady
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(ZNetScene __instance)
		{
			if ((Object)(object)instance != (Object)null)
			{
				instance.Configure(__instance);
			}
		}
	}

	[HarmonyPatch(typeof(Piece), "Awake")]
	private static class PieceReady
	{
		[HarmonyPrefix]
		private static void Prefix(Piece __instance)
		{
			if (!((Object)(object)instance == (Object)null) && instance.requirements != null)
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				if (name == "portal_stone" || name == "portal_stone(Clone)")
				{
					instance.Apply(__instance);
				}
			}
		}
	}

	[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
	private static class SceneClosed
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!((Object)(object)instance == (Object)null))
			{
				instance.requirements = null;
				instance.craftingStation = null;
			}
		}
	}

	public const string PluginId = "local.altstoneportal";

	private static Plugin instance;

	private const string StationPrefab = "piece_stonecutter";

	private Requirement[] requirements;

	private CraftingStation craftingStation;

	private void Awake()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		instance = this;
		new Harmony("local.altstoneportal").PatchAll(typeof(Plugin).Assembly);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Alt Stone Portal loaded; waiting for world prefabs.");
	}

	private void Configure(ZNetScene scene)
	{
		requirements = null;
		craftingStation = null;
		try
		{
			GameObject prefab = scene.GetPrefab("portal_stone");
			Piece val = ((!((Object)(object)prefab == (Object)null)) ? prefab.GetComponent<Piece>() : null);
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("portal_stone Piece was not found.");
			}
			GameObject prefab2 = scene.GetPrefab("piece_stonecutter");
			CraftingStation val2 = ((!((Object)(object)prefab2 == (Object)null)) ? prefab2.GetComponent<CraftingStation>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				throw new InvalidOperationException("Unknown crafting station: piece_stonecutter");
			}
			Requirement[] array = (Requirement[])(object)new Requirement[3]
			{
				Resource(scene, "Stone", 30),
				Resource(scene, "GreydwarfEye", 10),
				Resource(scene, "Wishbone", 1)
			};
			requirements = array;
			craftingStation = val2;
			Apply(val);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Applied portal_stone recipe: Stone:30,GreydwarfEye:10,Wishbone:1; station: piece_stonecutter");
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Stone Portal recipe was not applied. " + ex.Message));
		}
	}

	private static Requirement Resource(ZNetScene scene, string id, int amount)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		GameObject prefab = scene.GetPrefab(id);
		ItemDrop val = ((!((Object)(object)prefab == (Object)null)) ? prefab.GetComponent<ItemDrop>() : null);
		if ((Object)(object)val == (Object)null)
		{
			throw new InvalidOperationException("Unknown item prefab: " + id);
		}
		Requirement val2 = new Requirement();
		val2.m_resItem = val;
		val2.m_amount = amount;
		val2.m_amountPerLevel = 0;
		val2.m_recover = true;
		return val2;
	}

	private void Apply(Piece piece)
	{
		piece.m_resources = requirements;
		piece.m_craftingStation = craftingStation;
	}
}
public sealed class PortalRecolor : MonoBehaviour
{
	private static readonly Color Hue = new Color(0.07352942f, 1f, 0.73164296f, 1f);

	private Material ownedMaterial;

	private Texture2D ownedMask;

	private void Start()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Invalid comparison between Unknown and I4
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Expected O, but got Unknown
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		if ((int)SystemInfo.graphicsDeviceType == 4)
		{
			return;
		}
		try
		{
			TeleportWorld component = ((Component)this).GetComponent<TeleportWorld>();
			component.m_colorTargetfound = Tint(component.m_colorTargetfound);
			component.m_colorUnconnected = Tint(component.m_colorUnconnected);
			Transform val = ((Component)this).transform.Find("_target_found_red");
			if ((Object)(object)val != (Object)null)
			{
				TintEffects(((Component)val).gameObject);
			}
			Renderer model = (Renderer)(object)component.m_model;
			if ((Object)(object)model == (Object)null)
			{
				throw new InvalidOperationException("Missing portal model.");
			}
			Material sharedMaterial = model.sharedMaterial;
			if ((Object)(object)sharedMaterial == (Object)null || !sharedMaterial.HasProperty("_EmissiveTex"))
			{
				throw new InvalidOperationException("Missing portal emission material.");
			}
			Texture texture = sharedMaterial.GetTexture("_EmissiveTex");
			if ((Object)(object)texture == (Object)null)
			{
				throw new InvalidOperationException("Missing portal emission texture.");
			}
			ownedMask = MakeMask(texture);
			ownedMaterial = new Material(sharedMaterial);
			((Object)ownedMaterial).name = "AltStonePortal_Wishbone_Test";
			ownedMaterial.SetTexture("_EmissiveTex", (Texture)(object)ownedMask);
			ownedMaterial.SetColor("_EmissionColor", Tint(sharedMaterial.GetColor("_EmissionColor")));
			model.sharedMaterial = ownedMaterial;
			Debug.Log((object)"AltStonePortal: Applied wishbone recolor to stone portal.");
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("AltStonePortal recolor failed: " + ex));
		}
	}

	private static Color Tint(Color color)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		float num = Mathf.Max(color.r, Mathf.Max(color.g, color.b));
		Color hue = Hue;
		float num2 = hue.r * num;
		Color hue2 = Hue;
		float num3 = hue2.g * num;
		Color hue3 = Hue;
		return new Color(num2, num3, hue3.b * num, color.a);
	}

	private static Gradient TintGradient(Gradient original)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Expected O, but got Unknown
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		if (original == null)
		{
			return null;
		}
		GradientColorKey[] colorKeys = original.colorKeys;
		for (int i = 0; i < colorKeys.Length; i++)
		{
			colorKeys[i].color = Tint(colorKeys[i].color);
		}
		Gradient val = new Gradient();
		val.SetKeys(colorKeys, original.alphaKeys);
		val.mode = original.mode;
		return val;
	}

	private static MinMaxGradient TintGradient(MinMaxGradient original)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected I4, but got Unknown
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: 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)
		ParticleSystemGradientMode mode = ((MinMaxGradient)(ref original)).mode;
		switch ((int)mode)
		{
		case 0:
			((MinMaxGradient)(ref original)).color = Tint(((MinMaxGradient)(ref original)).color);
			break;
		case 2:
			((MinMaxGradient)(ref original)).colorMin = Tint(((MinMaxGradient)(ref original)).colorMin);
			((MinMaxGradient)(ref original)).colorMax = Tint(((MinMaxGradient)(ref original)).colorMax);
			break;
		case 3:
			((MinMaxGradient)(ref original)).gradientMin = TintGradient(((MinMaxGradient)(ref original)).gradientMin);
			((MinMaxGradient)(ref original)).gradientMax = TintGradient(((MinMaxGradient)(ref original)).gradientMax);
			break;
		default:
			((MinMaxGradient)(ref original)).gradient = TintGradient(((MinMaxGradient)(ref original)).gradient);
			break;
		}
		return original;
	}

	public static void TintEffects(GameObject root)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Invalid comparison between Unknown and I4
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Invalid comparison between Unknown and I4
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: 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_0127: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Invalid comparison between Unknown and I4
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		Light[] componentsInChildren = root.GetComponentsInChildren<Light>(true);
		foreach (Light val in componentsInChildren)
		{
			val.color = Hue;
		}
		ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
		foreach (ParticleSystem val2 in componentsInChildren2)
		{
			if (((Object)val2).name == "Black_suck")
			{
				continue;
			}
			MainModule main = val2.main;
			CustomDataModule customData = val2.customData;
			bool flag = ((CustomDataModule)(ref customData)).enabled && ((int)((CustomDataModule)(ref customData)).GetMode((ParticleSystemCustomData)0) == 2 || (int)((CustomDataModule)(ref customData)).GetMode((ParticleSystemCustomData)1) == 2);
			if (flag)
			{
				ParticleSystemCustomData[] array = (ParticleSystemCustomData[])(object)new ParticleSystemCustomData[2]
				{
					default(ParticleSystemCustomData),
					(ParticleSystemCustomData)1
				};
				foreach (ParticleSystemCustomData val3 in array)
				{
					if ((int)((CustomDataModule)(ref customData)).GetMode(val3) == 2)
					{
						((CustomDataModule)(ref customData)).SetColor(val3, TintGradient(((CustomDataModule)(ref customData)).GetColor(val3)));
					}
				}
			}
			else
			{
				((MainModule)(ref main)).startColor = TintGradient(((MainModule)(ref main)).startColor);
			}
			TrailModule trails = val2.trails;
			if (((TrailModule)(ref trails)).enabled)
			{
				((TrailModule)(ref trails)).colorOverTrail = TintGradient(((TrailModule)(ref trails)).colorOverTrail);
			}
			Particle[] array2 = (Particle[])(object)new Particle[val2.particleCount];
			int particles = val2.GetParticles(array2);
			if (!flag)
			{
				for (int l = 0; l < particles; l++)
				{
					((Particle)(ref array2[l])).startColor = Color32.op_Implicit(Tint(Color32.op_Implicit(((Particle)(ref array2[l])).startColor)));
				}
			}
			val2.SetParticles(array2, particles);
		}
	}

	private static Texture2D MakeMask(Texture source)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		RenderTexture active = RenderTexture.active;
		bool sRGBWrite = GL.sRGBWrite;
		RenderTexture val = null;
		Texture2D val2 = null;
		try
		{
			val = RenderTexture.GetTemporary(source.width, source.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			GL.sRGBWrite = false;
			Graphics.Blit(source, val);
			RenderTexture.active = val;
			val2 = new Texture2D(source.width, source.height, (TextureFormat)4, true, true);
			val2.ReadPixels(new Rect(0f, 0f, (float)source.width, (float)source.height), 0, 0);
			Color[] pixels = val2.GetPixels();
			for (int i = 0; i < pixels.Length; i++)
			{
				Color val3 = pixels[i];
				float num = Mathf.Max(val3.r, Mathf.Max(val3.g, val3.b));
				ref Color reference = ref pixels[i];
				reference = new Color(num, num, num, val3.a);
			}
			val2.SetPixels(pixels);
			((Object)val2).name = "AltStonePortal_EmissionMask";
			((Texture)val2).wrapMode = source.wrapMode;
			((Texture)val2).filterMode = source.filterMode;
			val2.Apply(true, true);
			return val2;
		}
		catch
		{
			if ((Object)(object)val2 != (Object)null)
			{
				Object.Destroy((Object)(object)val2);
			}
			throw;
		}
		finally
		{
			RenderTexture.active = active;
			GL.sRGBWrite = sRGBWrite;
			if ((Object)(object)val != (Object)null)
			{
				RenderTexture.ReleaseTemporary(val);
			}
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)ownedMaterial != (Object)null)
		{
			Object.Destroy((Object)(object)ownedMaterial);
		}
		if ((Object)(object)ownedMask != (Object)null)
		{
			Object.Destroy((Object)(object)ownedMask);
		}
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace AltStonecutter;

[BepInPlugin("local.altstonecutter", "Alt Stonecutter", "0.1.0")]
public sealed class Plugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	private static class SceneReady
	{
		[HarmonyPriority(0)]
		[HarmonyPostfix]
		private static void Postfix(ZNetScene __instance)
		{
			if ((Object)(object)instance != (Object)null)
			{
				instance.Configure(__instance);
			}
		}
	}

	[HarmonyPatch(typeof(Piece), "Awake")]
	private static class PieceReady
	{
		[HarmonyPrefix]
		private static void Prefix(Piece __instance)
		{
			if (!((Object)(object)instance == (Object)null))
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				if (name == "piece_stonecutter" || name == "piece_stonecutter(Clone)")
				{
					instance.ReplaceIron(__instance);
				}
			}
		}
	}

	[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
	private static class SceneClosed
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if ((Object)(object)instance != (Object)null)
			{
				instance.bronze = null;
			}
		}
	}

	public const string PluginId = "local.altstonecutter";

	private static Plugin instance;

	private ItemDrop bronze;

	private void Awake()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		instance = this;
		new Harmony("local.altstonecutter").PatchAll(typeof(Plugin).Assembly);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Alt Stonecutter loaded.");
	}

	private void Configure(ZNetScene scene)
	{
		bronze = null;
		try
		{
			GameObject prefab = scene.GetPrefab("piece_stonecutter");
			Piece val = (((Object)(object)prefab == (Object)null) ? null : prefab.GetComponent<Piece>());
			GameObject prefab2 = scene.GetPrefab("Bronze");
			ItemDrop val2 = (((Object)(object)prefab2 == (Object)null) ? null : prefab2.GetComponent<ItemDrop>());
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				throw new InvalidOperationException("Stonecutter or Bronze prefab was not found.");
			}
			bronze = val2;
			ReplaceIron(val);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Stonecutter recipe configured to use bronze instead of iron.");
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Stonecutter recipe was not applied: " + ex));
		}
	}

	private void ReplaceIron(Piece piece)
	{
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		if ((Object)(object)bronze == (Object)null || piece.m_resources == null)
		{
			return;
		}
		Requirement[] array = (Requirement[])piece.m_resources.Clone();
		bool flag = false;
		for (int i = 0; i < array.Length; i++)
		{
			Requirement val = array[i];
			if (val != null && !((Object)(object)val.m_resItem == (Object)null) && !(((Object)((Component)val.m_resItem).gameObject).name != "Iron"))
			{
				Requirement val2 = new Requirement();
				FieldInfo[] fields = typeof(Requirement).GetFields(BindingFlags.Instance | BindingFlags.Public);
				foreach (FieldInfo fieldInfo in fields)
				{
					fieldInfo.SetValue(val2, fieldInfo.GetValue(val));
				}
				val2.m_resItem = bronze;
				array[i] = val2;
				flag = true;
			}
		}
		if (flag)
		{
			piece.m_resources = array;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace BetterChestStatus;

[BepInPlugin("local.bettercheststatus", "Better Chest Status", "0.1.0")]
public sealed class Plugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	private static class HoverText
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			foreach (CodeInstruction instruction in instructions)
			{
				list.Add(new CodeInstruction(instruction));
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(Container), "m_name");
			MethodInfo methodInfo = AccessTools.Method(typeof(Plugin), "AddStatus", (Type[])null, (Type[])null);
			int num = -1;
			int num2 = 0;
			int num3 = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldstr && object.Equals(list[i].operand, " ( $piece_container_empty )"))
				{
					num3++;
				}
				if (i > 0 && i + 1 < list.Count && list[i - 1].opcode == OpCodes.Ldarg_0 && CodeInstructionExtensions.LoadsField(list[i], fieldInfo, false) && list[i + 1].opcode == OpCodes.Stloc_0)
				{
					num = i;
					num2++;
				}
			}
			if (num2 != 1 || num3 != 1)
			{
				throw new InvalidOperationException("Expected one nonempty name assignment and one vanilla EMPTY marker.");
			}
			list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)methodInfo)
			});
			return list;
		}
	}

	public const string PluginId = "local.bettercheststatus";

	private Harmony harmony;

	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		harmony = new Harmony("local.bettercheststatus");
		try
		{
			harmony.PatchAll(typeof(Plugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Better Chest Status loaded.");
		}
		catch (Exception ex)
		{
			harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogError((object)("Better Chest Status disabled: incompatible hover text IL. " + ex));
		}
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}

	private static string AddStatus(string name, Container container)
	{
		Inventory inventory = container.GetInventory();
		if (inventory == null || inventory.HaveEmptySlot())
		{
			return name;
		}
		List<ItemData> allItems = inventory.GetAllItems();
		if (allItems.Count == 0)
		{
			return name;
		}
		foreach (ItemData item in allItems)
		{
			if (item.m_stack < item.m_shared.m_maxStackSize)
			{
				return name + " ( NO SLOTS )";
			}
		}
		return name + " ( FULL )";
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace BetterCraftingList;

[BepInPlugin("local.bettercraftinglist", "Better Crafting List", "0.1.2")]
public sealed class Plugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(InventoryGui), "AddRecipeToList")]
	private static class FilterRecipes
	{
		[HarmonyPriority(0)]
		private static bool Prefix(InventoryGui __instance, Recipe __1, ItemData __2, bool __3)
		{
			if (!Matches(__1))
			{
				return false;
			}
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.gui != (Object)(object)__instance || (Object)(object)instance.scroll == (Object)null)
			{
				return true;
			}
			return !RecipeRows.Add(__instance, __1, __2, __3);
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
	private static class KeepScrollPosition
	{
		private static void Prefix(InventoryGui __instance, ref List<Recipe> __0, out float __state)
		{
			ScrollRect componentInParent = ((Component)__instance.m_recipeListRoot).GetComponentInParent<ScrollRect>();
			__state = (IsCraftingScroll(componentInParent) ? ((1f - Mathf.Clamp01(componentInParent.verticalNormalizedPosition)) * Travel(componentInParent)) : 0f);
			RecipeRows.Begin(__instance);
			if ((Object)(object)instance != (Object)null && instance.query.Length > 0)
			{
				__0 = __0.FindAll(Matches);
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo destroy = AccessTools.Method(typeof(Object), "Destroy", new Type[1] { typeof(Object) }, (Type[])null);
			int replaced = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, destroy))
				{
					instruction.operand = AccessTools.Method(typeof(RecipeRows), "Release", (Type[])null, (Type[])null);
					replaced++;
				}
				yield return instruction;
			}
			if (replaced != 1)
			{
				throw new InvalidOperationException("Recipe row release call changed.");
			}
		}

		private static void Postfix(InventoryGui __instance, float __state)
		{
			ScrollRect componentInParent = ((Component)__instance.m_recipeListRoot).GetComponentInParent<ScrollRect>();
			if (IsCraftingScroll(componentInParent))
			{
				componentInParent.StopMovement();
				float num = Travel(componentInParent);
				componentInParent.verticalNormalizedPosition = ((num > 0f) ? Mathf.Clamp01(1f - __state / num) : 1f);
				__instance.m_recipeListScroll.numberOfSteps = 0;
			}
		}
	}

	[HarmonyPatch(typeof(ScrollRect), "OnScroll")]
	private static class ScrollOneRow
	{
		private static bool Prefix(ScrollRect __instance, PointerEventData __0)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsCraftingScroll(__instance))
			{
				return true;
			}
			if (!((UIBehaviour)__instance).IsActive() || __0 == null)
			{
				return false;
			}
			float y = __0.scrollDelta.y;
			float num = ((y == 0f) ? 0f : Mathf.Sign(y));
			float num2 = Travel(__instance);
			__instance.StopMovement();
			if (num2 > 0f && num != 0f)
			{
				RectTransform val = (RectTransform)(((Object)(object)__instance.viewport != (Object)null) ? ((object)__instance.viewport) : ((object)/*isinst with value type is only supported in some contexts*/));
				Vector3 val2 = ((Transform)__instance.content).TransformVector(Vector3.up * InventoryGui.instance.m_recipeListSpace);
				float num3 = Mathf.Abs(((Transform)val).InverseTransformVector(val2).y);
				__instance.verticalNormalizedPosition = Mathf.Clamp01(__instance.verticalNormalizedPosition + num * num3 / num2);
			}
			((AbstractEventData)__0).Use();
			return false;
		}
	}

	[HarmonyPatch(typeof(ScrollRectEnsureVisible), "CenterOnItem")]
	private static class CenterRecipe
	{
		private static bool Prefix(ScrollRectEnsureVisible __instance, RectTransform __0)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_recipeEnsureVisible != (Object)(object)__instance || (Object)(object)__0 == (Object)null)
			{
				return true;
			}
			ScrollRect componentInParent = ((Component)instance.m_recipeListRoot).GetComponentInParent<ScrollRect>();
			if (!IsCraftingScroll(componentInParent))
			{
				return true;
			}
			RectTransform val = (RectTransform)(((Object)(object)componentInParent.viewport != (Object)null) ? ((object)componentInParent.viewport) : ((object)/*isinst with value type is only supported in some contexts*/));
			float num = Travel(componentInParent);
			componentInParent.StopMovement();
			if (num <= 0f)
			{
				componentInParent.verticalNormalizedPosition = 1f;
				return false;
			}
			Rect rect = __0.rect;
			Vector3 val2 = ((Transform)val).InverseTransformPoint(((Transform)__0).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center)));
			float verticalNormalizedPosition = componentInParent.verticalNormalizedPosition;
			float y = val2.y;
			Rect rect2 = val.rect;
			componentInParent.verticalNormalizedPosition = Mathf.Clamp01(verticalNormalizedPosition + (y - ((Rect)(ref rect2)).center.y) / num);
			return false;
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "Update")]
	private static class TypingKeys
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo button = AccessTools.Method(typeof(ZInput), "GetButtonDown", new Type[1] { typeof(string) }, (Type[])null);
			MethodInfo key = AccessTools.Method(typeof(ZInput), "GetKeyDown", new Type[2]
			{
				typeof(KeyCode),
				typeof(bool)
			}, (Type[])null);
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, button))
				{
					instruction.operand = AccessTools.Method(typeof(Plugin), "InventoryButtonDown", (Type[])null, (Type[])null);
				}
				if (CodeInstructionExtensions.Calls(instruction, key))
				{
					instruction.operand = AccessTools.Method(typeof(Plugin), "InventoryKeyDown", (Type[])null, (Type[])null);
				}
				yield return instruction;
			}
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "UpdateGamepad")]
	private static class TypingGamepad
	{
		private static bool Prefix()
		{
			return !Editing();
		}
	}

	[HarmonyPatch(typeof(Player), "TakeInput")]
	private static class TypingPlayerInput
	{
		private static void Postfix(Player __instance, ref bool __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && Editing())
			{
				__result = false;
			}
		}
	}

	[HarmonyPatch(typeof(Player), "SetControls")]
	private static class TypingPlayerControls
	{
		[HarmonyPriority(0)]
		private static void Prefix(Player __instance, ref Vector3 movedir, ref bool attack, ref bool attackHold, ref bool secondaryAttack, ref bool secondaryAttackHold, ref bool block, ref bool blockHold, ref bool jump, ref bool crouch, ref bool run, ref bool autoRun, ref bool dodge, ref bool ___m_autoRun)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && Editing())
			{
				movedir = Vector3.zero;
				attack = (attackHold = (secondaryAttack = (secondaryAttackHold = (block = (blockHold = false)))));
				jump = (crouch = (run = (autoRun = (dodge = false))));
				___m_autoRun = false;
			}
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	private static class ClearSearch
	{
		private static void Postfix()
		{
			if (!((Object)(object)instance == (Object)null))
			{
				instance.query = "";
				instance.pendingQuery = "";
				instance.searchPending = false;
				instance.localizedNames.Clear();
				if ((Object)(object)instance.search != (Object)null)
				{
					instance.search.DeactivateInputField(false);
					instance.search.SetTextWithoutNotify("");
				}
			}
		}
	}

	public const string Id = "local.bettercraftinglist";

	private static Plugin instance;

	private static readonly Action<InventoryGui, bool> Refresh = AccessTools.MethodDelegate<Action<InventoryGui, bool>>(AccessTools.Method(typeof(InventoryGui), "UpdateCraftingPanel", (Type[])null, (Type[])null), (object)null, true);

	private Harmony harmony;

	private InventoryGui gui;

	private ScrollRect scroll;

	private RectTransform viewport;

	private RectTransform originalViewport;

	private TMP_InputField search;

	private Vector2 originalMax;

	private int originalSteps;

	private bool originalInertia;

	private MovementType originalMovement;

	private string query = "";

	private string pendingQuery = "";

	private bool searchPending;

	private float searchAfter;

	private readonly Dictionary<string, string> localizedNames = new Dictionary<string, string>();

	private int suppressFrame = -1;

	private void Awake()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		instance = this;
		harmony = new Harmony("local.bettercraftinglist");
		harmony.PatchAll(typeof(Plugin).Assembly);
	}

	private void LateUpdate()
	{
		if ((Object)(object)InventoryGui.instance == (Object)null || !InventoryGui.IsVisible())
		{
			return;
		}
		if ((Object)(object)gui != (Object)(object)InventoryGui.instance || (Object)(object)search == (Object)null)
		{
			Attach(InventoryGui.instance);
		}
		if (searchPending && Time.unscaledTime >= searchAfter && (Object)(object)gui != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null)
		{
			query = pendingQuery;
			searchPending = false;
			Refresh(gui, arg2: false);
			if ((Object)(object)scroll != (Object)null)
			{
				scroll.StopMovement();
				scroll.verticalNormalizedPosition = 1f;
			}
		}
		RecipeRows.Render(scroll);
	}

	private void Attach(InventoryGui source)
	{
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: 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_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0389: Unknown result type (might be due to invalid IL or missing references)
		Detach();
		ScrollRect componentInParent = ((Component)source.m_recipeListRoot).GetComponentInParent<ScrollRect>();
		if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent.content != (Object)(object)source.m_recipeListRoot)
		{
			return;
		}
		RectTransform val = componentInParent.viewport;
		if ((Object)(object)val == (Object)null)
		{
			Mask componentInParent2 = ((Component)source.m_recipeListRoot).GetComponentInParent<Mask>();
			RectMask2D componentInParent3 = ((Component)source.m_recipeListRoot).GetComponentInParent<RectMask2D>();
			val = (((Object)(object)componentInParent2 != (Object)null) ? componentInParent2.rectTransform : (((Object)(object)componentInParent3 != (Object)null) ? componentInParent3.rectTransform : null));
		}
		if ((Object)(object)val == (Object)null || (Object)(object)((Transform)val).parent == (Object)null)
		{
			return;
		}
		gui = source;
		scroll = componentInParent;
		viewport = val;
		originalViewport = componentInParent.viewport;
		componentInParent.viewport = val;
		originalMax = val.offsetMax;
		originalSteps = gui.m_recipeListScroll.numberOfSteps;
		originalInertia = scroll.inertia;
		originalMovement = scroll.movementType;
		scroll.inertia = false;
		scroll.movementType = (MovementType)2;
		scroll.StopMovement();
		gui.m_recipeListScroll.numberOfSteps = 0;
		RectTransform val2 = NewRect("CraftingSearch", ((Transform)val).parent);
		val2.anchorMin = new Vector2(val.anchorMin.x, val.anchorMax.y);
		val2.anchorMax = val.anchorMax;
		val2.pivot = new Vector2(0.5f, 1f);
		val2.offsetMin = new Vector2(val.offsetMin.x, originalMax.y - 34f);
		val2.offsetMax = originalMax;
		Image val3 = ((Component)val2).gameObject.AddComponent<Image>();
		((Graphic)val3).color = new Color(0.08f, 0.08f, 0.08f, 1f);
		RectTransform val4 = NewRect("TextArea", (Transform)(object)val2);
		Stretch(val4, 8f, 4f);
		((Component)val4).gameObject.AddComponent<RectMask2D>();
		TMP_Text textComponent = NewText("Text", (Transform)(object)val4);
		TMP_Text val5 = NewText("Search", (Transform)(object)val4);
		val5.text = "Search";
		((Graphic)val5).color = new Color(0.7f, 0.7f, 0.7f, 1f);
		search = ((Component)val2).gameObject.AddComponent<TMP_InputField>();
		search.textViewport = val4;
		search.textComponent = textComponent;
		search.placeholder = (Graphic)(object)val5;
		((Selectable)search).targetGraphic = (Graphic)(object)val3;
		search.lineType = (LineType)0;
		search.characterLimit = 100;
		search.richText = false;
		((Selectable)search).transition = (Transition)0;
		TMP_InputField obj = search;
		Navigation navigation = default(Navigation);
		((Navigation)(ref navigation)).mode = (Mode)0;
		((Selectable)obj).navigation = navigation;
		((UnityEvent<string>)(object)search.onValueChanged).AddListener((UnityAction<string>)OnSearch);
		((UnityEvent<string>)(object)search.onSelect).AddListener((UnityAction<string>)delegate
		{
			suppressFrame = Time.frameCount;
		});
		((UnityEvent<string>)(object)search.onDeselect).AddListener((UnityAction<string>)delegate
		{
			suppressFrame = Time.frameCount;
		});
		((UnityEvent<string>)(object)search.onSubmit).AddListener((UnityAction<string>)delegate
		{
			search.DeactivateInputField(false);
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
			suppressFrame = Time.frameCount;
		});
		viewport.offsetMax = new Vector2(originalMax.x, originalMax.y - 40f);
		((Transform)val2).SetAsLastSibling();
	}

	private TMP_Text NewText(string name, Transform parent)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = NewRect(name, parent);
		Stretch(val, 0f, 0f);
		TextMeshProUGUI val2 = ((Component)val).gameObject.AddComponent<TextMeshProUGUI>();
		((TMP_Text)val2).font = gui.m_recipeName.font;
		((TMP_Text)val2).fontSize = 18f;
		((Graphic)val2).color = Color.white;
		((TMP_Text)val2).alignment = (TextAlignmentOptions)4097;
		((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
		((TMP_Text)val2).richText = false;
		((Graphic)val2).raycastTarget = false;
		return (TMP_Text)(object)val2;
	}

	private static RectTransform NewRect(string name, Transform parent)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
		((Transform)component).SetParent(parent, false);
		return component;
	}

	private static void Stretch(RectTransform rect, float x, float y)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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)
		rect.anchorMin = Vector2.zero;
		rect.anchorMax = Vector2.one;
		rect.offsetMin = new Vector2(x, y);
		rect.offsetMax = new Vector2(0f - x, 0f - y);
	}

	private void OnSearch(string value)
	{
		pendingQuery = value.Trim();
		searchPending = query != pendingQuery;
		searchAfter = Time.unscaledTime + 0.075f;
	}

	private static bool Matches(Recipe recipe)
	{
		if ((Object)(object)instance == (Object)null || instance.query.Length == 0 || (Object)(object)recipe == (Object)null || (Object)(object)recipe.m_item == (Object)null)
		{
			return true;
		}
		string name = recipe.m_item.m_itemData.m_shared.m_name;
		if (!instance.localizedNames.TryGetValue(name, out var value))
		{
			value = ((Localization.instance != null) ? Localization.instance.Localize(name) : name);
			instance.localizedNames[name] = value;
		}
		name = value;
		return name.IndexOf(instance.query, StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static bool Editing()
	{
		if ((Object)(object)instance != (Object)null && (Object)(object)instance.search != (Object)null)
		{
			if (!instance.search.isFocused)
			{
				return instance.suppressFrame >= Time.frameCount;
			}
			return true;
		}
		return false;
	}

	private static bool InventoryButtonDown(string name)
	{
		if (!Editing())
		{
			return ZInput.GetButtonDown(name);
		}
		return false;
	}

	private static bool InventoryKeyDown(KeyCode key, bool logWarning)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		if (!Editing())
		{
			return ZInput.GetKeyDown(key, logWarning);
		}
		return false;
	}

	private static bool IsCraftingScroll(ScrollRect target)
	{
		if ((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)target != (Object)null)
		{
			return (Object)(object)target.content == (Object)(object)InventoryGui.instance.m_recipeListRoot;
		}
		return false;
	}

	private static float Travel(ScrollRect target)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: 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)
		RectTransform val = target.viewport;
		if ((Object)(object)val == (Object)null)
		{
			Transform transform = ((Component)target).transform;
			val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		target.content.GetWorldCorners(array);
		float num = Mathf.Abs(((Transform)val).InverseTransformPoint(array[1]).y - ((Transform)val).InverseTransformPoint(array[0]).y);
		Rect rect = val.rect;
		return Mathf.Max(0f, num - ((Rect)(ref rect)).height);
	}

	private void Detach()
	{
		//IL_0015: 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 ((Object)(object)viewport != (Object)null)
		{
			viewport.offsetMax = originalMax;
		}
		if ((Object)(object)scroll != (Object)null)
		{
			scroll.viewport = originalViewport;
			scroll.inertia = originalInertia;
			scroll.movementType = originalMovement;
		}
		if ((Object)(object)gui != (Object)null && (Object)(object)gui.m_recipeListScroll != (Object)null)
		{
			gui.m_recipeListScroll.numberOfSteps = originalSteps;
		}
		if ((Object)(object)search != (Object)null)
		{
			((Component)search).gameObject.SetActive(false);
			Object.Destroy((Object)(object)((Component)search).gameObject);
		}
		search = null;
		viewport = null;
		scroll = null;
		gui = null;
		query = "";
		pendingQuery = "";
		searchPending = false;
		localizedNames.Clear();
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		Detach();
		RecipeRows.Clear();
		instance = null;
	}
}
internal static class RecipeRows
{
	private sealed class Row
	{
		internal RectTransform rect;

		internal GameObject selected;

		internal Recipe recipe;

		internal ItemData item;

		internal bool canCraft;

		internal bool dirty;

		internal View view;
	}

	private sealed class View
	{
		internal GameObject go;

		internal Image icon;

		internal TMP_Text name;

		internal TMP_Text quality;

		internal GuiBar durability;

		internal GameObject selected;

		internal Row row;
	}

	private static readonly FieldInfo Available = AccessTools.Field(typeof(InventoryGui), "m_availableRecipes");

	private static readonly Action<InventoryGui, GameObject> Select = AccessTools.MethodDelegate<Action<InventoryGui, GameObject>>(AccessTools.Method(typeof(InventoryGui), "OnSelectedRecipe", (Type[])null, (Type[])null), (object)null, true);

	private static readonly Func<Recipe, ItemData, GameObject, bool, object> Pair = CreatePairFactory();

	private static readonly Dictionary<GameObject, Row> rows = new Dictionary<GameObject, Row>();

	private static readonly Stack<Row> spareRows = new Stack<Row>();

	private static readonly Stack<View> spareViews = new Stack<View>();

	private static readonly List<Row> active = new List<Row>();

	private static readonly Vector3[] corners = (Vector3[])(object)new Vector3[4];

	private static InventoryGui owner;

	private static RectTransform pool;

	private static Func<Recipe, ItemData, GameObject, bool, object> CreatePairFactory()
	{
		Type type = AccessTools.Inner(typeof(InventoryGui), "RecipeDataPair");
		Type[] array = new Type[4]
		{
			typeof(Recipe),
			typeof(ItemData),
			typeof(GameObject),
			typeof(bool)
		};
		ConstructorInfo con = AccessTools.Constructor(type, array, false);
		DynamicMethod dynamicMethod = new DynamicMethod("CreateRecipePair", typeof(object), array, typeof(RecipeRows), skipVisibility: true);
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		for (int i = 0; i < array.Length; i++)
		{
			iLGenerator.Emit(OpCodes.Ldarg, (short)i);
		}
		iLGenerator.Emit(OpCodes.Newobj, con);
		iLGenerator.Emit(OpCodes.Box, type);
		iLGenerator.Emit(OpCodes.Ret);
		return (Func<Recipe, ItemData, GameObject, bool, object>)dynamicMethod.CreateDelegate(typeof(Func<Recipe, ItemData, GameObject, bool, object>));
	}

	internal static void Begin(InventoryGui gui)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)owner != (Object)(object)gui)
		{
			Clear();
			owner = gui;
			pool = new GameObject("CraftingRowPool", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)pool).SetParent(((Transform)gui.m_recipeListRoot).parent, false);
			((Component)pool).gameObject.SetActive(false);
		}
		active.Clear();
	}

	internal static bool Add(InventoryGui gui, Recipe recipe, ItemData item, bool canCraft)
	{
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Expected O, but got Unknown
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Expected O, but got Unknown
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)owner != (Object)(object)gui || (Object)(object)pool == (Object)null)
		{
			return false;
		}
		IList list = (IList)Available.GetValue(gui);
		Row row;
		if (spareRows.Count > 0)
		{
			row = spareRows.Pop();
		}
		else
		{
			RectTransform val = (RectTransform)gui.m_recipeElementPrefab.transform;
			RectTransform component = new GameObject("RecipeRow", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)gui.m_recipeListRoot, false);
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.sizeDelta = val.sizeDelta;
			GameObject val2 = new GameObject("selected", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)component, false);
			Row row2 = new Row();
			row2.rect = component;
			row2.selected = val2;
			row = row2;
			rows.Add(((Component)component).gameObject, row);
		}
		row.recipe = recipe;
		row.item = item;
		row.canCraft = canCraft;
		row.dirty = true;
		row.selected.SetActive(false);
		row.rect.anchoredPosition = new Vector2(0f, (float)(-list.Count) * gui.m_recipeListSpace);
		((Component)row.rect).gameObject.SetActive(true);
		active.Add(row);
		list.Add(Pair(recipe, item, ((Component)row.rect).gameObject, canCraft));
		return true;
	}

	internal static void Release(Object value)
	{
		GameObject val = (GameObject)(object)((value is GameObject) ? value : null);
		if ((Object)(object)val == (Object)null || !rows.TryGetValue(val, out var value2))
		{
			Object.Destroy(value);
			return;
		}
		ReturnView(value2);
		val.SetActive(false);
		spareRows.Push(value2);
	}

	private static void ReturnView(Row row)
	{
		if (row.view != null)
		{
			row.view.go.SetActive(false);
			row.view.go.transform.SetParent((Transform)(object)pool, false);
			row.view.row = null;
			spareViews.Push(row.view);
			row.view = null;
		}
	}

	private static View CreateView()
	{
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Expected O, but got Unknown
		GameObject val = Object.Instantiate<GameObject>(owner.m_recipeElementPrefab, (Transform)(object)pool);
		val.SetActive(false);
		View view = new View
		{
			go = val,
			icon = ((Component)val.transform.Find("icon")).GetComponent<Image>(),
			name = ((Component)val.transform.Find("name")).GetComponent<TMP_Text>(),
			quality = ((Component)val.transform.Find("QualityLevel")).GetComponent<TMP_Text>(),
			durability = ((Component)val.transform.Find("Durability")).GetComponent<GuiBar>(),
			selected = ((Component)val.transform.Find("selected")).gameObject
		};
		Button component = val.GetComponent<Button>();
		((UnityEventBase)component.onClick).RemoveAllListeners();
		((UnityEvent)component.onClick).AddListener((UnityAction)delegate
		{
			if ((Object)(object)owner != (Object)null && view.row != null)
			{
				Select(owner, ((Component)view.row.rect).gameObject);
			}
		});
		RecipeRowClicks recipeRowClicks = val.AddComponent<RecipeRowClicks>();
		recipeRowClicks.Target = () => (view.row != null) ? ((Component)view.row.rect).gameObject : null;
		return view;
	}

	private static void Bind(Row row)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		View view = row.view;
		view.icon.sprite = row.recipe.m_item.m_itemData.GetIcon();
		((Graphic)view.icon).color = (Color)(row.canCraft ? Color.white : new Color(1f, 0f, 1f, 0f));
		string text = Localization.instance.Localize(row.recipe.m_item.m_itemData.m_shared.m_name);
		if (row.recipe.m_amount > 1)
		{
			text = text + " x" + row.recipe.m_amount;
		}
		view.name.text = text;
		((Graphic)view.name).color = (Color)(row.canCraft ? Color.white : new Color(0.66f, 0.66f, 0.66f, 1f));
		bool flag = row.item != null && row.item.m_shared.m_useDurability && row.item.m_durability < row.item.GetMaxDurability();
		((Component)view.durability).gameObject.SetActive(flag);
		if (flag)
		{
			view.durability.SetValue(row.item.GetDurabilityPercentage());
		}
		((Component)view.quality).gameObject.SetActive(row.item != null);
		if (row.item != null)
		{
			view.quality.text = row.item.m_quality.ToString();
		}
		row.dirty = false;
	}

	internal static void Render(ScrollRect scroll)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Expected O, but got Unknown
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)owner == (Object)null || (Object)(object)pool == (Object)null || (Object)(object)scroll == (Object)null || !InventoryGui.IsVisible())
		{
			return;
		}
		_ = owner.m_recipeListRoot;
		RectTransform val = (RectTransform)(((Object)(object)scroll.viewport != (Object)null) ? ((object)scroll.viewport) : ((object)(RectTransform)((Component)scroll).transform));
		Rect rect = val.rect;
		float bottom = ((Rect)(ref rect)).yMin - owner.m_recipeListSpace;
		Rect rect2 = val.rect;
		float top = ((Rect)(ref rect2)).yMax + owner.m_recipeListSpace;
		foreach (Row item in active)
		{
			if (!IsVisible(item.rect, val, bottom, top))
			{
				ReturnView(item);
			}
		}
		int num = 4;
		foreach (Row item2 in active)
		{
			if (!IsVisible(item2.rect, val, bottom, top))
			{
				continue;
			}
			if (item2.view == null)
			{
				if (spareViews.Count > 0)
				{
					item2.view = spareViews.Pop();
				}
				else
				{
					if (num == 0)
					{
						continue;
					}
					num--;
					item2.view = CreateView();
				}
				item2.view.row = item2;
				item2.view.go.transform.SetParent((Transform)(object)item2.rect, false);
				RectTransform val2 = (RectTransform)item2.view.go.transform;
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				Vector2 offsetMin = (val2.offsetMax = Vector2.zero);
				val2.offsetMin = offsetMin;
				item2.dirty = true;
			}
			if (item2.dirty)
			{
				Bind(item2);
			}
			item2.view.selected.SetActive(item2.selected.activeSelf);
			item2.view.go.SetActive(true);
		}
	}

	private static bool IsVisible(RectTransform row, RectTransform viewport, float bottom, float top)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		row.GetWorldCorners(corners);
		float num = float.PositiveInfinity;
		float num2 = float.NegativeInfinity;
		for (int i = 0; i < corners.Length; i++)
		{
			float y = ((Transform)viewport).InverseTransformPoint(corners[i]).y;
			num = Mathf.Min(num, y);
			num2 = Mathf.Max(num2, y);
		}
		if (num2 >= bottom)
		{
			return num <= top;
		}
		return false;
	}

	internal static void Clear()
	{
		foreach (Row value in rows.Values)
		{
			if ((Object)(object)value.rect != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)value.rect).gameObject);
			}
		}
		if ((Object)(object)pool != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)pool).gameObject);
		}
		rows.Clear();
		spareRows.Clear();
		spareViews.Clear();
		active.Clear();
		owner = null;
		pool = null;
	}
}
public sealed class RecipeRowClicks : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
{
	internal Func<GameObject> Target;

	public void OnPointerClick(PointerEventData eventData)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Invalid comparison between Unknown and I4
		if ((int)eventData.button == 2 && Target != null)
		{
			GameObject val = Target();
			if ((Object)(object)val != (Object)null)
			{
				ExecuteEvents.Execute<IPointerClickHandler>(val, (BaseEventData)(object)eventData, ExecuteEvents.pointerClickHandler);
			}
		}
	}
}