using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DelGryphon.PieGuy.CobOvenS1
{
	[BepInPlugin("delgryphon.pieguy.coboven.s1", "PieGuy Cob Oven S11", "0.1.11")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class CobOvenS11Plugin : BaseUnityPlugin
	{
		private const string OvenPrefab = "Piece_CobOven";

		private bool registered;

		private float nextAttempt;

		private void Awake()
		{
			PrefabManager.OnVanillaPrefabsAvailable += Register;
			ItemManager.OnItemsRegistered += RefreshRegisteredPrefab;
			PieceManager.OnPiecesRegistered += RefreshRegisteredPrefab;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Cob Oven S11] No-smoke textured oven, narrow colliders and interactions, workbench gating, original-game fire particles, forward 80%-size pie slot, plus native physical chimney smoke only.");
		}

		private void OnDestroy()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= Register;
			ItemManager.OnItemsRegistered -= RefreshRegisteredPrefab;
			PieceManager.OnPiecesRegistered -= RefreshRegisteredPrefab;
		}

		private void Start()
		{
			if (!registered)
			{
				Register();
			}
		}

		private void Update()
		{
			if (!registered && !(Time.time < nextAttempt))
			{
				nextAttempt = Time.time + 4f;
				Register();
			}
		}

		private void Register()
		{
			//IL_0099: 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_00a9: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			if (registered)
			{
				return;
			}
			try
			{
				if ((Object)(object)PrefabManager.Instance.GetPrefab("piece_oven") == (Object)null)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"[Cob Oven S11] Native stone oven not yet available");
					return;
				}
				Sprite icon = null;
				try
				{
					icon = S1Visuals.LoadIcon();
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("[Cob Oven S11] Icon unavailable; using vanilla oven icon: " + ex.Message));
					GameObject prefab = PrefabManager.Instance.GetPrefab("piece_oven");
					Piece val = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<Piece>() : null);
					if ((Object)(object)val != (Object)null)
					{
						icon = val.m_icon;
					}
				}
				PieceConfig val2 = new PieceConfig
				{
					Name = "Cob Oven",
					Description = "A rustic wood-fired oven for baking pies and other oven foods. Add wood, then bake one item at a time.",
					PieceTable = "Hammer",
					Category = "Crafting",
					CraftingStation = "piece_workbench",
					Icon = icon
				};
				val2.AddRequirement("Wood", 3, true);
				val2.AddRequirement("Stone", 10, true);
				val2.AddRequirement("Flint", 2, true);
				CustomPiece val3 = new CustomPiece("Piece_CobOven", "piece_oven", val2);
				GameObject piecePrefab = val3.PiecePrefab;
				if ((Object)(object)piecePrefab == (Object)null)
				{
					throw new InvalidOperationException("Stone Oven cloning failed");
				}
				GameObject prefab2 = PrefabManager.Instance.GetPrefab("piece_workbench");
				Piece component = piecePrefab.GetComponent<Piece>();
				CraftingStation val4 = (((Object)(object)prefab2 != (Object)null) ? prefab2.GetComponent<CraftingStation>() : null);
				if ((Object)(object)component == (Object)null || (Object)(object)val4 == (Object)null)
				{
					throw new InvalidOperationException("Missing Piece or workbench prefab; refusing to register Artisan-locked oven");
				}
				component.m_craftingStation = val4;
				if (!PieceManager.Instance.AddPiece(val3))
				{
					throw new InvalidOperationException("Jotunn rejected Piece_CobOven");
				}
				registered = true;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Cob Oven S11] Piece_CobOven REGISTERED in Hammer. Applying native cooking, appearance, and no-smoke changes separately.");
				try
				{
					ConfigureNativeCooking(piecePrefab, piecePrefab.GetComponent<CookingStation>() ?? piecePrefab.GetComponentInChildren<CookingStation>(true));
				}
				catch (Exception ex2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("[Cob Oven S11] Cooking config failed; registered native oven remains: " + ex2));
				}
				try
				{
					int num = S1Visuals.InstallAppearance(piecePrefab);
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[Cob Oven S11] Recovered cob appearance; replaced surface materials=" + num));
				}
				catch (Exception ex3)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("[Cob Oven S11] Visual asset loading failed; registered oven remains (vanilla look): " + ex3));
				}
				try
				{
					if ((Object)(object)piecePrefab.GetComponent<S1OvenConversionBinder>() == (Object)null)
					{
						piecePrefab.AddComponent<S1OvenConversionBinder>();
					}
				}
				catch (Exception ex4)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("[Cob Oven S11] Pie conversion binder failed: " + ex4));
				}
				try
				{
					if ((Object)(object)piecePrefab.GetComponent<S11HearthFlame>() == (Object)null)
					{
						piecePrefab.AddComponent<S11HearthFlame>();
					}
				}
				catch (Exception ex5)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("[Cob Oven S11] Campfire animation unavailable: " + ex5.Message));
				}
				try
				{
					if ((Object)(object)piecePrefab.GetComponent<S11PhysicalChimneySmoke>() == (Object)null)
					{
						piecePrefab.AddComponent<S11PhysicalChimneySmoke>();
					}
				}
				catch (Exception ex6)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("[Cob Oven S11] Native physical smoke unavailable: " + ex6.Message));
				}
				try
				{
					if ((Object)(object)piecePrefab.GetComponent<S11PieDisplay>() == (Object)null)
					{
						piecePrefab.AddComponent<S11PieDisplay>();
					}
				}
				catch (Exception ex7)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("[Cob Oven S11] Pie display unavailable: " + ex7.Message));
				}
				RefreshRegisteredPrefab();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Cob Oven S11] Oven registration complete. Core inventory/food items untouched. No scene-wide smoke scanning.");
			}
			catch (Exception ex8)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[Cob Oven S11] Registration: " + ex8));
			}
		}

		private static void ConfigureNativeCooking(GameObject root, CookingStation oven)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)oven == (Object)null)
			{
				throw new InvalidOperationException("Registered native oven has no CookingStation");
			}
			oven.m_name = "Cob Oven";
			oven.m_useFuel = true;
			oven.m_requireFire = false;
			oven.m_maxFuel = 10;
			oven.m_secPerFuel = 2000;
			if (oven.m_slots == null || oven.m_slots.Length < 1 || (Object)(object)oven.m_slots[0] == (Object)null)
			{
				throw new InvalidOperationException("Vanilla oven cooking slot missing");
			}
			Transform val = oven.m_slots[0];
			val.SetParent(root.transform, false);
			val.localPosition = new Vector3(0f, 0.99f, -0.37f);
			val.localRotation = Quaternion.identity;
			val.localScale = Vector3.one;
			((Component)val).gameObject.SetActive(true);
			oven.m_slots = (Transform[])(object)new Transform[1] { val };
			Logger.CreateLogSource("PieGuy RC2 Slots").LogInfo((object)("Preserved native cooking slot '" + ((Object)val).name + "' with " + val.childCount + " children; custom pie meshes remain independent"));
			GameObject val2 = new GameObject("S1_FrontPieOutput");
			val2.transform.SetParent(root.transform, false);
			val2.transform.localPosition = new Vector3(0f, 1.0430456f, -0.7265461f);
			val2.transform.localRotation = Quaternion.LookRotation(Vector3.back, Vector3.up);
			oven.m_spawnPoint = val2.transform;
			oven.m_spawnForce = 3.3f;
			Switch addFoodSwitch = oven.m_addFoodSwitch;
			Switch addFuelSwitch = oven.m_addFuelSwitch;
			if ((Object)(object)addFoodSwitch == (Object)null || (Object)(object)addFuelSwitch == (Object)null)
			{
				throw new InvalidOperationException("Native stone oven missing the independent food/fuel switches");
			}
			PlaceSwitch(root.transform, addFoodSwitch, 1.25f, -0.7f);
			PlaceSwitch(root.transform, addFuelSwitch, 0.7f, -0.7f);
			BoxCollider val3 = root.GetComponent<BoxCollider>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = root.AddComponent<BoxCollider>();
			}
			val3.center = new Vector3(0f, 0.54f, 0.06f);
			val3.size = new Vector3(0.94f, 1.08f, 1.05f);
			((Collider)val3).isTrigger = false;
			((Collider)val3).enabled = true;
			int num = 0;
			Collider[] componentsInChildren = root.GetComponentsInChildren<Collider>(true);
			foreach (Collider val4 in componentsInChildren)
			{
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4 == (Object)(object)val3))
				{
					bool num2 = (Object)(object)((Component)val4).transform == (Object)(object)((Component)addFoodSwitch).transform;
					bool flag = (Object)(object)((Component)val4).transform == (Object)(object)((Component)addFuelSwitch).transform;
					if (!(num2 || flag))
					{
						val4.enabled = false;
						num++;
					}
				}
			}
			Logger.CreateLogSource("PieGuy S11 Colliders").LogInfo((object)("Narrow oven: extra native colliders disabled=" + num + "; separate front food and wood targets retained"));
			SmokeSpawner[] componentsInChildren2 = root.GetComponentsInChildren<SmokeSpawner>(true);
			foreach (SmokeSpawner val5 in componentsInChildren2)
			{
				if ((Object)(object)val5 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val5);
				}
			}
			Fireplace[] componentsInChildren3 = root.GetComponentsInChildren<Fireplace>(true);
			foreach (Fireplace val6 in componentsInChildren3)
			{
				if ((Object)(object)val6 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val6);
				}
			}
			int num3 = 0;
			ParticleSystem[] componentsInChildren4 = root.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val7 in componentsInChildren4)
			{
				if (!((Object)(object)val7 == (Object)null))
				{
					val7.Stop(true, (ParticleSystemStopBehavior)0);
					EmissionModule emission = val7.emission;
					((EmissionModule)(ref emission)).enabled = false;
					ParticleSystemRenderer component = ((Component)val7).GetComponent<ParticleSystemRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						((Renderer)component).enabled = false;
					}
					num3++;
				}
			}
			oven.m_haveFireObject = MakeInertState(root, "S11_HasFire_SmokeIsolation");
			oven.m_haveFuelObject = MakeInertState(root, "S11_HasFuel_SmokeIsolation");
			Logger.CreateLogSource("PieGuy S11 Smoke").LogInfo((object)("Native oven effects silenced: spawners/fireplaces removed, " + num3 + " inherited particle systems muted; inert native FX states"));
		}

		private static void PlaceSwitch(Transform root, Switch target, float height, float front)
		{
			//IL_001a: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			((Component)target).transform.SetParent(root, false);
			((Component)target).transform.localPosition = new Vector3(0f, height, front);
			((Component)target).transform.localRotation = Quaternion.identity;
			((Component)target).transform.localScale = Vector3.one;
			((Component)target).gameObject.SetActive(true);
			BoxCollider val = ((Component)target).GetComponent<BoxCollider>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)target).gameObject.AddComponent<BoxCollider>();
			}
			val.center = Vector3.zero;
			val.size = new Vector3(0.55f, 0.2f, 0.18f);
			((Collider)val).isTrigger = false;
			((Collider)val).enabled = true;
			Collider[] componentsInChildren = ((Component)target).GetComponentsInChildren<Collider>(true);
			foreach (Collider val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)(object)val)
				{
					val2.enabled = false;
				}
			}
		}

		private static GameObject MakeInertState(GameObject root, string name)
		{
			//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_0019: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(root.transform, false);
			return val;
		}

		private void RefreshRegisteredPrefab()
		{
			if (!registered)
			{
				return;
			}
			try
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("Piece_CobOven");
				if (!((Object)(object)prefab == (Object)null))
				{
					S1OvenConversionBinder component = prefab.GetComponent<S1OvenConversionBinder>();
					if ((Object)(object)component != (Object)null)
					{
						component.Refresh();
					}
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[Cob Oven S11] Conversion refresh: " + ex.Message));
			}
		}
	}
	public sealed class S1OvenConversionBinder : MonoBehaviour
	{
		private static readonly string[,] Pies = new string[12, 2]
		{
			{ "UncookedPorkHandPie", "PorkHandPie" },
			{ "UncookedMixedBerryPie", "MixedBerryPie" },
			{ "UncookedVegetablePie", "VegetablePie" },
			{ "UncookedWolfMeatPie", "WolfMeatPie" },
			{ "UncookedSweetChutneyPie", "SweetChutneyPie" },
			{ "UncookedMushroomPie", "MushroomPie" },
			{ "UncookedSavoryQuiche", "SavoryQuiche" },
			{ "UncookedSeekerMeatPie", "SeekerMeatPie" },
			{ "UncookedChickenPotPie", "ChickenPotPie" },
			{ "UncookedVenisonPie", "VenisonPie" },
			{ "UncookedFourBerryGalette", "FourBerryGalette" },
			{ "UncookedNordicFishPie", "NordicFishPie" }
		};

		private bool complete;

		private void Start()
		{
			Refresh();
		}

		private void OnEnable()
		{
			if (!complete)
			{
				Refresh();
			}
		}

		private static ItemDrop Find(string key)
		{
			GameObject val = null;
			try
			{
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					val = ObjectDB.instance.GetItemPrefab(key);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)val == (Object)null)
				{
					val = PrefabManager.Instance.GetPrefab(key);
				}
			}
			catch
			{
			}
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return val.GetComponent<ItemDrop>();
		}

		public void Refresh()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			if (complete)
			{
				return;
			}
			CookingStation val = ((Component)this).GetComponent<CookingStation>() ?? ((Component)this).GetComponentInChildren<CookingStation>(true);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (val.m_conversion == null)
			{
				val.m_conversion = new List<ItemConversion>();
			}
			int num = 0;
			for (int i = 0; i < Pies.GetLength(0); i++)
			{
				ItemDrop val2 = Find(Pies[i, 0]);
				ItemDrop val3 = Find(Pies[i, 1]);
				if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
				{
					continue;
				}
				num++;
				ItemConversion val4 = null;
				foreach (ItemConversion item in val.m_conversion)
				{
					if (item != null && (Object)(object)item.m_from != (Object)null && ((Object)item.m_from).name == ((Object)val2).name)
					{
						val4 = item;
						break;
					}
				}
				if (val4 == null)
				{
					val.m_conversion.Add(new ItemConversion
					{
						m_from = val2,
						m_to = val3,
						m_cookTime = 50f
					});
				}
				else
				{
					val4.m_from = val2;
					val4.m_to = val3;
					val4.m_cookTime = 50f;
				}
			}
			if (num == Pies.GetLength(0))
			{
				complete = true;
				((MonoBehaviour)this).CancelInvoke("Refresh");
			}
			else if (Application.isPlaying && ((Component)this).gameObject.activeInHierarchy && !((MonoBehaviour)this).IsInvoking("Refresh"))
			{
				((MonoBehaviour)this).InvokeRepeating("Refresh", 2f, 5f);
			}
		}
	}
	public sealed class S11HearthFlame : MonoBehaviour
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("PieGuy S11 Hearth");

		private CookingStation station;

		private ZNetView view;

		private GameObject fx;

		private Light hearthLight;

		private readonly List<ParticleSystem> emitters = new List<ParticleSystem>();

		private bool installed;

		private bool lit;

		private float nextCheck;

		private static readonly MethodInfo GetFuelMethod = typeof(CookingStation).GetMethod("GetFuel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);

		private void Start()
		{
			Install();
		}

		private void OnEnable()
		{
			if (!installed)
			{
				Install();
			}
		}

		private static bool SmokeFX(ParticleSystem ps)
		{
			if ((Object)(object)ps == (Object)null)
			{
				return true;
			}
			Transform val = ((Component)ps).transform;
			while ((Object)(object)val != (Object)null)
			{
				string text = (((Object)val).name ?? "").ToLowerInvariant();
				if (text.Contains("smoke") || text.Contains("steam") || text.Contains("soot") || text.Contains("smokeball"))
				{
					return true;
				}
				val = val.parent;
			}
			ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
			string text2 = (((Object)(object)component != (Object)null && (Object)(object)((Renderer)component).sharedMaterial != (Object)null) ? ((Object)((Renderer)component).sharedMaterial).name : "").ToLowerInvariant();
			if (!text2.Contains("smoke") && !text2.Contains("steam"))
			{
				return text2.Contains("soot");
			}
			return true;
		}

		private static int FlameScore(ParticleSystem ps)
		{
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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)
			if (SmokeFX(ps))
			{
				return -1000;
			}
			string text = (((Object)ps).name ?? "").ToLowerInvariant();
			ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
			if ((Object)(object)component == (Object)null || (Object)(object)((Renderer)component).sharedMaterial == (Object)null)
			{
				return -1000;
			}
			string text2 = ((Object)((Renderer)component).sharedMaterial).name.ToLowerInvariant();
			if (text.Contains("burst") || text.Contains("explos") || text.Contains("cinder") || text.Contains("spark") || text.Contains("ember") || text.Contains("firework") || text2.Contains("burst") || text2.Contains("explos") || text2.Contains("spark") || text2.Contains("ember") || text2.Contains("cinder"))
			{
				return -1000;
			}
			int num = 0;
			if (text2.Contains("flame"))
			{
				num += 30;
			}
			if (text2.Contains("fire"))
			{
				num += 15;
			}
			if (text.Contains("flame"))
			{
				num += 25;
			}
			if (text.Contains("fire") || text.Contains("burn"))
			{
				num += 8;
			}
			MainModule main = ps.main;
			if (((MainModule)(ref main)).loop)
			{
				num += 8;
			}
			EmissionModule emission = ps.emission;
			MinMaxCurve rateOverTime;
			if (((EmissionModule)(ref emission)).enabled)
			{
				rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
				if (((MinMaxCurve)(ref rateOverTime)).constantMax > 0.02f)
				{
					num += 10;
				}
			}
			rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
			if (((MinMaxCurve)(ref rateOverTime)).constantMax <= 0.02f)
			{
				num -= 100;
			}
			return num;
		}

		private void EnsureLight()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)hearthLight != (Object)null))
			{
				GameObject val = new GameObject("S11_WarmHearthLight");
				val.transform.SetParent(((Component)this).transform, false);
				val.transform.localPosition = new Vector3(0f, 0.86f, -0.48f);
				hearthLight = val.AddComponent<Light>();
				hearthLight.type = (LightType)2;
				hearthLight.color = new Color(1f, 0.5f, 0.23f);
				hearthLight.range = 5f;
				hearthLight.intensity = 0f;
				hearthLight.shadows = (LightShadows)0;
			}
		}

		private void Install()
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			if (installed)
			{
				return;
			}
			station = ((Component)this).GetComponent<CookingStation>() ?? ((Component)this).GetComponentInChildren<CookingStation>(true);
			view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
			if ((Object)(object)station == (Object)null)
			{
				return;
			}
			EnsureLight();
			try
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("fire_pit");
				if ((Object)(object)prefab == (Object)null)
				{
					Log.LogWarning((object)"fire_pit missing: retrying");
					return;
				}
				ParticleSystem[] componentsInChildren = prefab.GetComponentsInChildren<ParticleSystem>(true);
				List<ParticleSystem> list = new List<ParticleSystem>();
				ParticleSystem[] array = componentsInChildren;
				foreach (ParticleSystem val in array)
				{
					if (FlameScore(val) >= 30)
					{
						list.Add(val);
					}
				}
				list.Sort((ParticleSystem a, ParticleSystem b) => FlameScore(b).CompareTo(FlameScore(a)));
				if (list.Count == 0)
				{
					Log.LogError((object)("Campfire has no continuous flame emitter. Found " + componentsInChildren.Length + " particle systems. See S8 diagnostics; no unrelated FX will be substituted."));
					nextCheck = Time.time + 5f;
					return;
				}
				fx = new GameObject("S11_HalfScale_CampfireContinuousFlames");
				fx.transform.SetParent(((Component)this).transform, false);
				fx.transform.localPosition = new Vector3(0f, 0.72f, -0.43f);
				fx.transform.localRotation = Quaternion.identity;
				fx.transform.localScale = new Vector3(0.5f, 0.25f, 0.5f);
				int num = Math.Min(list.Count, 3);
				for (int num2 = 0; num2 < num; num2++)
				{
					ParticleSystem val2 = list[num2];
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
					((Object)val3).name = "S11_CampfireNativeFlame_" + num2;
					for (int num3 = val3.transform.childCount - 1; num3 >= 0; num3--)
					{
						Object.DestroyImmediate((Object)(object)((Component)val3.transform.GetChild(num3)).gameObject);
					}
					MonoBehaviour[] components = val3.GetComponents<MonoBehaviour>();
					foreach (MonoBehaviour val4 in components)
					{
						if ((Object)(object)val4 != (Object)null)
						{
							Object.DestroyImmediate((Object)(object)val4);
						}
					}
					SmokeSpawner[] components2 = val3.GetComponents<SmokeSpawner>();
					foreach (SmokeSpawner val5 in components2)
					{
						if ((Object)(object)val5 != (Object)null)
						{
							Object.DestroyImmediate((Object)(object)val5);
						}
					}
					Collider[] components3 = val3.GetComponents<Collider>();
					foreach (Collider val6 in components3)
					{
						if ((Object)(object)val6 != (Object)null)
						{
							val6.enabled = false;
						}
					}
					Light[] components4 = val3.GetComponents<Light>();
					foreach (Light val7 in components4)
					{
						if ((Object)(object)val7 != (Object)null)
						{
							((Behaviour)val7).enabled = false;
						}
					}
					val3.transform.SetParent(fx.transform, false);
					Vector3 val8 = prefab.transform.InverseTransformPoint(((Component)val2).transform.position);
					val3.transform.localPosition = new Vector3(val8.x, val8.y, val8.z);
					val3.transform.localRotation = Quaternion.identity;
					val3.transform.localScale = Vector3.one;
					val3.SetActive(true);
					ParticleSystem component = val3.GetComponent<ParticleSystem>();
					if ((Object)(object)component == (Object)null)
					{
						Object.Destroy((Object)(object)val3);
						continue;
					}
					MainModule main = component.main;
					((MainModule)(ref main)).loop = true;
					((MainModule)(ref main)).playOnAwake = false;
					((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)0;
					EmissionModule emission = component.emission;
					((EmissionModule)(ref emission)).enabled = true;
					ParticleSystemRenderer component2 = val3.GetComponent<ParticleSystemRenderer>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Renderer)component2).enabled = true;
					}
					emitters.Add(component);
					ManualLogSource log = Log;
					string[] obj = new string[6]
					{
						"Native campfire flame selected: ",
						((Object)val2).name,
						", material=",
						((Object)(object)component2 != (Object)null && (Object)(object)((Renderer)component2).sharedMaterial != (Object)null) ? ((Object)((Renderer)component2).sharedMaterial).name : "none",
						", original emission=",
						null
					};
					MinMaxCurve rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
					obj[5] = ((MinMaxCurve)(ref rateOverTime)).constantMax.ToString();
					log.LogInfo((object)string.Concat(obj));
				}
				if (emitters.Count == 0)
				{
					Object.Destroy((Object)(object)fx);
					fx = null;
					Log.LogError((object)"No usable campfire flame components cloned");
				}
				else
				{
					fx.SetActive(false);
					installed = true;
					Log.LogInfo((object)("S11 ready: " + emitters.Count + " continuous original campfire flame emitter(s) at 50% scale; ZERO native smoke systems cloned"));
				}
			}
			catch (Exception ex)
			{
				if ((Object)(object)fx != (Object)null)
				{
					Object.Destroy((Object)(object)fx);
				}
				fx = null;
				emitters.Clear();
				Log.LogError((object)("Unable to install campfire flame: " + ex));
			}
		}

		private float Fuel()
		{
			float num = -1f;
			try
			{
				if (GetFuelMethod != null && (Object)(object)station != (Object)null)
				{
					num = Convert.ToSingle(GetFuelMethod.Invoke(station, null));
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if ((Object)(object)view == (Object)null)
				{
					view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
				}
				if ((Object)(object)view != (Object)null && view.GetZDO() != null)
				{
					num = Mathf.Max(num, view.GetZDO().GetFloat(ZDOVars.s_fuel, 0f));
				}
			}
			catch (Exception)
			{
			}
			return Mathf.Max(0f, num);
		}

		private void Update()
		{
			if ((Object)(object)hearthLight == (Object)null)
			{
				EnsureLight();
			}
			bool flag = Fuel() > 0.025f;
			if ((Object)(object)hearthLight != (Object)null)
			{
				hearthLight.intensity = (flag ? (2.2f + 0.16f * Mathf.Sin(Time.time * 8f)) : 0f);
			}
			if (!installed)
			{
				if (Time.time >= nextCheck)
				{
					nextCheck = Time.time + 3f;
					Install();
				}
			}
			else
			{
				if (flag == lit)
				{
					return;
				}
				lit = flag;
				fx.SetActive(lit);
				foreach (ParticleSystem emitter in emitters)
				{
					if (!((Object)(object)emitter == (Object)null))
					{
						if (lit)
						{
							((Component)emitter).gameObject.SetActive(true);
							emitter.Clear(true);
							emitter.Play(true);
						}
						else
						{
							emitter.Stop(true, (ParticleSystemStopBehavior)0);
						}
					}
				}
				Log.LogInfo((object)("S11 campfire flames " + (lit ? "ON" : "OFF") + ", fuel=" + Fuel()));
			}
		}
	}
	public sealed class S11PhysicalChimneySmoke : MonoBehaviour
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("PieGuy S11 PhysicalSmoke");

		private static readonly MethodInfo GetFuelMethod = typeof(CookingStation).GetMethod("GetFuel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);

		private CookingStation station;

		private ZNetView view;

		private SmokeSpawner spawner;

		private GameObject source;

		private float retryAt;

		private bool active;

		private int attempts;

		private void Start()
		{
			Install();
		}

		private void OnEnable()
		{
			if ((Object)(object)spawner == (Object)null)
			{
				Install();
			}
		}

		private float Fuel()
		{
			float num = -1f;
			try
			{
				if (GetFuelMethod != null && (Object)(object)station != (Object)null)
				{
					num = Convert.ToSingle(GetFuelMethod.Invoke(station, null));
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if ((Object)(object)view == (Object)null)
				{
					view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
				}
				if ((Object)(object)view != (Object)null && view.GetZDO() != null)
				{
					num = Mathf.Max(num, view.GetZDO().GetFloat(ZDOVars.s_fuel, 0f));
				}
			}
			catch (Exception)
			{
			}
			return Mathf.Max(num, 0f);
		}

		private void Install()
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawner != (Object)null)
			{
				return;
			}
			station = ((Component)this).GetComponent<CookingStation>() ?? ((Component)this).GetComponentInChildren<CookingStation>(true);
			view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
			if ((Object)(object)station == (Object)null)
			{
				return;
			}
			GameObject val = null;
			try
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("fire_pit");
				if ((Object)(object)prefab == (Object)null)
				{
					retryAt = Time.time + 5f;
					return;
				}
				SmokeSpawner val2 = null;
				SmokeSpawner[] componentsInChildren = prefab.GetComponentsInChildren<SmokeSpawner>(true);
				foreach (SmokeSpawner val3 in componentsInChildren)
				{
					if ((Object)(object)val3 != (Object)null && (Object)(object)val3.m_smokePrefab != (Object)null)
					{
						val2 = val3;
						break;
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					retryAt = Time.time + 5f;
					if (++attempts <= 3)
					{
						Log.LogWarning((object)"Campfire physical SmokeSpawner not yet available; retrying");
					}
					return;
				}
				val = new GameObject("S11_RealSmokeBallSpawner_AtChimney");
				val.SetActive(false);
				val.transform.SetParent(((Component)this).transform, false);
				val.transform.localPosition = new Vector3(0f, 1.9f, 0.2f);
				val.transform.localRotation = Quaternion.identity;
				val.transform.localScale = Vector3.one;
				SmokeSpawner val4 = val.AddComponent<SmokeSpawner>();
				((Behaviour)val4).enabled = false;
				val4.m_smokePrefab = val2.m_smokePrefab;
				val4.m_interval = val2.m_interval * 2f;
				val4.m_testRadius = val2.m_testRadius;
				val4.m_spawnRadius = 0f;
				val4.m_stopFireOnStart = false;
				val.SetActive(true);
				source = val;
				spawner = val4;
				active = false;
				Log.LogInfo((object)("Physical SmokeSpawner installed at chimney: SmokeBall=" + (((Object)(object)val4.m_smokePrefab != (Object)null) ? ((Object)val4.m_smokePrefab).name : "MISSING") + ", interval=" + val4.m_interval + ", test radius=" + val4.m_testRadius + ", local point=(0,1.90,0.20); no cosmetic plume; hearth fire unchanged"));
			}
			catch (Exception ex)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				source = null;
				spawner = null;
				retryAt = Time.time + 5f;
				Log.LogError((object)("Could not install physical chimney smoke: " + ex));
			}
		}

		private void Update()
		{
			if ((Object)(object)spawner == (Object)null)
			{
				if (Time.time >= retryAt)
				{
					retryAt = Time.time + 5f;
					Install();
				}
				return;
			}
			bool flag = Fuel() > 0.025f;
			if (flag != active)
			{
				active = flag;
				((Behaviour)spawner).enabled = flag;
				Log.LogInfo((object)("Physical chimney smoke " + (active ? "ON" : "OFF") + "; fuel=" + Fuel() + "; SmokeBall spawner=" + ((Behaviour)spawner).enabled));
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)spawner != (Object)null)
			{
				((Behaviour)spawner).enabled = false;
			}
			if ((Object)(object)source != (Object)null)
			{
				Object.Destroy((Object)(object)source);
			}
		}
	}
	public sealed class S11PieDisplay : MonoBehaviour
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("PieGuy S11 PieDisplay");

		private static readonly HashSet<string> PieNames = new HashSet<string>(StringComparer.Ordinal)
		{
			"UncookedPorkHandPie", "PorkHandPie", "UncookedMixedBerryPie", "MixedBerryPie", "UncookedVegetablePie", "VegetablePie", "UncookedWolfMeatPie", "WolfMeatPie", "UncookedSweetChutneyPie", "SweetChutneyPie",
			"UncookedMushroomPie", "MushroomPie", "UncookedSavoryQuiche", "SavoryQuiche", "UncookedSeekerMeatPie", "SeekerMeatPie", "UncookedChickenPotPie", "ChickenPotPie", "UncookedVenisonPie", "VenisonPie",
			"UncookedFourBerryGalette", "FourBerryGalette", "UncookedNordicFishPie", "NordicFishPie"
		};

		private ZNetView view;

		private CookingStation station;

		private Transform anchor;

		private GameObject visible;

		private string shownName = "";

		private float nextCheck;

		private float retryPie;

		private int diagnostics;

		private void Start()
		{
			Setup();
		}

		private void Setup()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_007b: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)anchor != (Object)null))
			{
				station = ((Component)this).GetComponent<CookingStation>() ?? ((Component)this).GetComponentInChildren<CookingStation>(true);
				view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
				GameObject val = new GameObject("S11_TrueSizePieDisplay_IndependentOfVanillaAttach");
				anchor = val.transform;
				anchor.SetParent(((Component)this).transform, false);
				anchor.localPosition = new Vector3(0f, 0.99f, -0.37f);
				anchor.localRotation = Quaternion.identity;
				anchor.localScale = Vector3.one;
			}
		}

		private static Transform PieHolder(Transform root)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name.StartsWith("PieGuy_R34_", StringComparison.Ordinal))
				{
					return val;
				}
			}
			return null;
		}

		private static GameObject Resolve(string name)
		{
			GameObject val = null;
			try
			{
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					val = ObjectDB.instance.GetItemPrefab(name);
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if ((Object)(object)val == (Object)null)
				{
					val = PrefabManager.Instance.GetPrefab(name);
				}
			}
			catch (Exception)
			{
			}
			return val;
		}

		private void HideVanillaSlotPie()
		{
			if ((Object)(object)station == (Object)null || station.m_slots == null)
			{
				return;
			}
			Transform[] slots = station.m_slots;
			foreach (Transform val in slots)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MeshRenderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<MeshRenderer>(true);
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						((Renderer)val2).enabled = false;
					}
				}
				SkinnedMeshRenderer[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<SkinnedMeshRenderer>(true);
				foreach (SkinnedMeshRenderer val3 in componentsInChildren2)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						((Renderer)val3).enabled = false;
					}
				}
			}
		}

		private void Draw(string name)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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)
			if ((Object)(object)visible != (Object)null)
			{
				Object.Destroy((Object)(object)visible);
			}
			visible = null;
			shownName = name;
			if (string.IsNullOrEmpty(name) || !PieNames.Contains(name))
			{
				return;
			}
			GameObject val = Resolve(name);
			if ((Object)(object)val == (Object)null)
			{
				Log.LogWarning((object)("No item prefab for oven slot: " + name));
				return;
			}
			Transform val2 = PieHolder(val.transform);
			if ((Object)(object)val2 == (Object)null)
			{
				Log.LogWarning((object)("R41 3D holder missing on " + name + "; cannot show oven model"));
				return;
			}
			visible = Object.Instantiate<GameObject>(((Component)val2).gameObject);
			((Object)visible).name = "S11_Visible_" + name;
			visible.transform.SetParent(anchor, false);
			visible.transform.localPosition = Vector3.zero;
			visible.transform.localRotation = Quaternion.identity;
			visible.transform.localScale = Vector3.one * 0.8f;
			visible.SetActive(true);
			int num = 0;
			MeshRenderer[] componentsInChildren = visible.GetComponentsInChildren<MeshRenderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Renderer)componentsInChildren[i]).enabled = true;
				num++;
			}
			HideVanillaSlotPie();
			Log.LogInfo((object)("Showing " + name + " using " + num + " existing R41 mesh renderers at 80% scale, internal shelf y=0.99 z=-0.37"));
		}

		private void Update()
		{
			if (Time.time < nextCheck)
			{
				return;
			}
			nextCheck = Time.time + 0.25f;
			if ((Object)(object)anchor == (Object)null)
			{
				Setup();
			}
			if ((Object)(object)view == (Object)null)
			{
				view = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInChildren<ZNetView>(true);
			}
			if ((Object)(object)view == (Object)null || view.GetZDO() == null)
			{
				return;
			}
			string text = "";
			try
			{
				text = view.GetZDO().GetString("slot0", "");
			}
			catch (Exception ex)
			{
				if (diagnostics++ < 2)
				{
					Log.LogWarning((object)("Unable to read slot0: " + ex.Message));
				}
				return;
			}
			int num = 0;
			try
			{
				num = view.GetZDO().GetInt("slotstatus0", 0);
			}
			catch (Exception)
			{
			}
			string text2 = text;
			if (num == 1 && text.StartsWith("Uncooked", StringComparison.Ordinal))
			{
				text2 = text.Substring("Uncooked".Length);
			}
			if (text2 != shownName)
			{
				Draw(text2);
			}
			else if (PieNames.Contains(text2) && (Object)(object)visible == (Object)null && Time.time > retryPie)
			{
				retryPie = Time.time + 3f;
				Draw(text2);
			}
			if (PieNames.Contains(text))
			{
				HideVanillaSlotPie();
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)visible != (Object)null)
			{
				Object.Destroy((Object)(object)visible);
			}
		}
	}
	internal static class S1Visuals
	{
		private static readonly Dictionary<string, Texture2D> TextureCache = new Dictionary<string, Texture2D>();

		private static Texture2D Load(string label)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			if (TextureCache.TryGetValue(label, out var value))
			{
				return value;
			}
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("PGS1_" + label);
			if (stream == null)
			{
				throw new InvalidOperationException("Missing Cob Oven S1 texture: " + label);
			}
			using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			gZipStream.CopyTo(memoryStream);
			byte[] array = memoryStream.ToArray();
			if (array.Length != 1048576)
			{
				throw new InvalidOperationException("Cob Oven S1 texture dimensions invalid: " + label);
			}
			Texture2D val = new Texture2D(512, 512, (TextureFormat)4, false);
			((Object)val).name = "S1_" + label;
			((Texture)val).wrapMode = (TextureWrapMode)0;
			((Texture)val).filterMode = (FilterMode)1;
			val.LoadRawTextureData(array);
			val.Apply(false, false);
			TextureCache[label] = val;
			return val;
		}

		public static Sprite LoadIcon()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			return Sprite.Create(Load("OvenIcon"), new Rect(0f, 0f, 512f, 512f), new Vector2(0.5f, 0.5f), 100f);
		}

		public static int InstallAppearance(GameObject oven)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			GetOriginalAppearance(out var mesh, out var materials);
			Mesh val = Object.Instantiate<Mesh>(mesh);
			((Object)val).name = "S11_CobOven_ApprovedGeometry_NaturalUV";
			Material[] array = (Material[])(object)new Material[materials.Length];
			bool[] array2 = new bool[materials.Length];
			int num = 0;
			for (int i = 0; i < materials.Length; i++)
			{
				Material val2 = materials[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Material val3 = new Material(val2);
				Texture mainTexture = val2.mainTexture;
				Texture2D val4 = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
				string text = FinishFor(val4);
				bool flag = ((Object)(object)val4 != (Object)null && ((Object)val4).name.IndexOf("CobOven_tex4", StringComparison.OrdinalIgnoreCase) >= 0) || (((Object)val2).name != null && ((Object)val2).name.IndexOf("fire", StringComparison.OrdinalIgnoreCase) >= 0);
				if (text == null && !flag && materials.Length == 5)
				{
					switch (i)
					{
					case 0:
						text = "OvenClay";
						break;
					case 1:
					case 2:
						text = "OvenStone";
						break;
					case 3:
						text = "OvenArch";
						break;
					}
				}
				if (text != null)
				{
					Texture2D val5 = (Texture2D)(object)(val3.mainTexture = (Texture)(object)Load(text));
					if (val3.HasProperty("_MainTex"))
					{
						val3.SetTexture("_MainTex", (Texture)(object)val5);
					}
					if (val3.HasProperty("_Color"))
					{
						val3.SetColor("_Color", Color.white);
					}
					if (val3.HasProperty("_Glossiness"))
					{
						val3.SetFloat("_Glossiness", 0.07f);
					}
					if (val3.HasProperty("_Metallic"))
					{
						val3.SetFloat("_Metallic", 0f);
					}
					array2[i] = true;
					num++;
				}
				array[i] = val3;
			}
			if (num == 0)
			{
				throw new InvalidOperationException("Cob Oven surface atlas was not resolved; refusing to hide original masonry");
			}
			ApplyNaturalUVSelective(val, array2);
			if (materials.Length == 5 && val.subMeshCount >= 5)
			{
				val.SetTriangles(new int[0], 4);
			}
			GameObject val7 = new GameObject("S11_CobOven_ApprovedGeometry");
			val7.transform.SetParent(oven.transform, false);
			val7.AddComponent<MeshFilter>().sharedMesh = val;
			MeshRenderer val8 = val7.AddComponent<MeshRenderer>();
			((Renderer)val8).sharedMaterials = array;
			((Renderer)val8).enabled = true;
			MeshRenderer[] componentsInChildren = oven.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val9 in componentsInChildren)
			{
				if (!((Object)(object)val9 == (Object)null) && !((Object)(object)val9 == (Object)(object)val8) && !IsFireVisual(val9))
				{
					((Renderer)val9).enabled = false;
				}
			}
			return num;
		}

		private static bool IsFireVisual(MeshRenderer renderer)
		{
			string text = (((Object)((Component)renderer).gameObject).name ?? "").ToLowerInvariant();
			if (text.Contains("fire") || text.Contains("flame") || text.Contains("ember") || text.Contains("spark") || text.Contains("glow"))
			{
				return true;
			}
			Material[] sharedMaterials = ((Renderer)renderer).sharedMaterials;
			foreach (Material val in sharedMaterials)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text2 = (((Object)val).name ?? "").ToLowerInvariant();
					if (text2.Contains("flame") || text2.Contains("fire") || text2.Contains("ember") || text2.Contains("spark"))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static string FinishFor(Texture2D texture)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_0090: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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)
			//IL_00f8: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			string text = ((Object)texture).name ?? "";
			if (text.IndexOf("CobOven_tex0", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "OvenClay";
			}
			if (text.IndexOf("CobOven_tex1", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "OvenStone";
			}
			if (text.IndexOf("CobOven_tex2", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "OvenStone";
			}
			if (text.IndexOf("CobOven_tex3", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "OvenArch";
			}
			if (text.IndexOf("CobOven_tex4", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return null;
			}
			try
			{
				Color pixel = texture.GetPixel(0, 0);
				if (Mathf.Abs(pixel.r - pixel.g) < 0.045f && Mathf.Abs(pixel.g - pixel.b) < 0.045f && pixel.r > 0.5f && pixel.r < 0.69f)
				{
					return "OvenStone";
				}
				if (pixel.r > 0.76f && pixel.g > 0.61f && pixel.g < 0.75f && pixel.b > 0.36f && pixel.b < 0.58f)
				{
					return "OvenClay";
				}
			}
			catch
			{
			}
			return null;
		}

		private static void ApplyNaturalUVSelective(Mesh mesh, bool[] surfaceMaterial)
		{
			//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_00ae: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] vertices = mesh.vertices;
			Vector3[] normals = mesh.normals;
			Vector2[] array = mesh.uv;
			if (array == null || array.Length != vertices.Length)
			{
				array = (Vector2[])(object)new Vector2[vertices.Length];
			}
			bool[] array2 = new bool[vertices.Length];
			for (int i = 0; i < mesh.subMeshCount; i++)
			{
				if (i < surfaceMaterial.Length && surfaceMaterial[i])
				{
					continue;
				}
				int[] triangles = mesh.GetTriangles(i);
				foreach (int num in triangles)
				{
					if (num >= 0 && num < array2.Length)
					{
						array2[num] = true;
					}
				}
			}
			for (int k = 0; k < vertices.Length; k++)
			{
				if (!array2[k])
				{
					Vector3 val = vertices[k];
					Vector3 val2 = ((normals != null && k < normals.Length) ? normals[k] : Vector3.up);
					if (Mathf.Abs(val2.y) > 0.66f)
					{
						array[k] = new Vector2(val.x * 2.4f, val.z * 2.4f);
					}
					else if (Mathf.Abs(val2.x) > Mathf.Abs(val2.z))
					{
						array[k] = new Vector2(val.z * 2.4f, val.y * 2.4f);
					}
					else
					{
						array[k] = new Vector2(val.x * 2.4f, val.y * 2.4f);
					}
				}
			}
			mesh.uv = array;
		}

		private static void GetOriginalAppearance(out Mesh mesh, out Material[] materials)
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("DelGryphon.PieGuy.PieGuyPlugin", throwOnError: false);
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				throw new InvalidOperationException("R41 PieGuy core resource provider missing");
			}
			Object[] array = Resources.FindObjectsOfTypeAll(type);
			if (array == null || array.Length == 0)
			{
				throw new InvalidOperationException("R41 PieGuy core plugin instance unavailable");
			}
			object obj = array[0];
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			MethodInfo method = type.GetMethod("LoadMesh", bindingAttr);
			MethodInfo method2 = type.GetMethod("LoadMaterials", bindingAttr);
			if (method == null || method2 == null)
			{
				throw new InvalidOperationException("Original cob mesh/material loaders not found");
			}
			object? obj2 = method.Invoke(obj, new object[1] { "CobOven" });
			mesh = (Mesh)((obj2 is Mesh) ? obj2 : null);
			materials = method2.Invoke(obj, new object[1] { "CobOven" }) as Material[];
			if ((Object)(object)mesh == (Object)null || materials == null || materials.Length == 0)
			{
				throw new InvalidOperationException("Approved cob oven mesh or materials not available");
			}
		}
	}
}