using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using PEAKLib.Core.Extensions;
using PEAKLib.Items;
using PEAKLib.Items.UnityEditor;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using PiggyBank.Behaviours;
using PiggyBank.Behaviours.GUI;
using Sirenix.Utilities;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore;
using UnityEngine.UI;
using UnityEngine.UI.Extensions;
using UnnamedProducts.Behaviours;
using UnnamedProducts.Behaviours.Item;
using UnnamedProducts.Behaviours.Item.GarbageBag;
using UnnamedProducts.Behaviours.Item.GarbageBag.GUI;
using UnnamedProducts.Compatibility;
using UnnamedProducts.Extensions;
using UnnamedProducts.Patchers;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Core.Serizalization;
using Zorro.Settings;
using pworld.Scripts.Extensions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.MiiMii1205.UnnamedProducts")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+b46d04ef22b9a76380cdb3f0a764e68486b9e90c")]
[assembly: AssemblyProduct("com.github.MiiMii1205.UnnamedProducts")]
[assembly: AssemblyTitle("UnnamedProducts")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace UnnamedProducts
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.github.MiiMii1205.UnnamedProducts", "UnnamedProducts", "1.3.0")]
	public class UnnamedPlugin : BaseUnityPlugin
	{
		public const float UnnamedModifier = 0.5f;

		public const float UnnamedChance = 0.25f;

		public const float UnnamedLuggageChance = 0.125f;

		public const byte UnnamedTotalBaseDataEntryKey = 15;

		private static readonly Dictionary<string, GameObject> UnnamedDatabase = new Dictionary<string, GameObject>();

		private static TMP_FontAsset? _darumaFontAsset;

		private static Material? _darumaShadowMaterial;

		private static readonly string[] GlobalZombieSpawnModList = new string[5] { "com.EMOKaMi.Zombie", "com.emokami.mimic", "Heroes", "sinik.zombiespawner", "legocool.LuckyBlocks" };

		public static GameObject UnnamedGarbageBagPrefab = null;

		public static Texture2D GarbageBagIcon = null;

		private static readonly HashSet<string> UnnamedUniques = new HashSet<string>();

		private static readonly Dictionary<BiomeType, State> BiomeSeeds = new Dictionary<BiomeType, State>();

		private static readonly int UnderlayDilate = Shader.PropertyToID("_UnderlayDilate");

		private static readonly int UnderlayOffsetY = Shader.PropertyToID("_UnderlayOffsetY");

		private static readonly int UnderlaySoftness = Shader.PropertyToID("_UnderlaySoftness");

		private static readonly int UnderlayColor = Shader.PropertyToID("_UnderlayColor");

		private static bool _hasAnyGlobalSpawningZombies;

		private static string _unnamedPrefix = null;

		private static string _modInfoPrefix = null;

		public const string Id = "com.github.MiiMii1205.UnnamedProducts";

		internal static ManualLogSource Log { get; private set; } = null;


		internal static PluginInfo UnnamedInfo { get; private set; } = null;


		public static Material SmallLuggageMaterial { get; private set; } = null;


		public static Material SmallLuggageInteriorMaterial { get; private set; } = null;


		public static Material LargeLuggageMaterial { get; private set; } = null;


		public static Material EpicLuggageMaterial { get; private set; } = null;


		public static Material LargeLuggageInteriorMaterial { get; private set; } = null;


		public static Material AncientLuggageMaterial { get; private set; } = null;


		public static Material AncientLuggageMetalMaterial { get; private set; } = null;


		public static Material AncientLuggageCrystalMaterial { get; private set; } = null;


		public static Material RespawnStatueCalderaMaterial { get; private set; } = null;


		public static Material RespawnStatueAlpineMaterial { get; private set; } = null;


		public static Material RespawnStatueMesaMaterial { get; private set; } = null;


		public static Material RespawnStatueRockVFXMaterial { get; private set; } = null;


		public static Material RespawnStatueRootsMaterial { get; private set; } = null;


		public static Material RespawnStatueTropicsMaterial { get; private set; } = null;


		public static Material RespawnStatueShoreMaterial { get; private set; } = null;


		public static SpawnPool UnnamedSpawnPool { get; private set; } = (SpawnPool)0;


		public static GameObject BigUnnamedLuggagePrefab { get; private set; } = null;


		public static GameObject SmallUnnamedLuggagePrefab { get; private set; } = null;


		public static GameObject EpicUnnamedLuggagePrefab { get; private set; } = null;


		public static GameObject AncientUnnamedLuggagePrefab { get; private set; } = null;


		public static TMP_FontAsset DarumaDropOne
		{
			get
			{
				if ((Object)(object)_darumaFontAsset == (Object)null)
				{
					TMP_FontAsset[] source = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
					_darumaFontAsset = ((IEnumerable<TMP_FontAsset>)source).FirstOrDefault((Func<TMP_FontAsset, bool>)delegate(TMP_FontAsset fontAsset)
					{
						//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)
						FaceInfo faceInfo = ((TMP_Asset)fontAsset).faceInfo;
						return ((FaceInfo)(ref faceInfo)).familyName == "Daruma Drop One";
					});
					Log.LogInfo((object)"Daruma Drop One font found!");
				}
				return _darumaFontAsset;
			}
		}

		public static Material DarumaDropOneShadowMaterial
		{
			get
			{
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_darumaShadowMaterial == (Object)null)
				{
					_darumaShadowMaterial = ThrowHelper.ThrowIfArgumentNull<Material>(Object.Instantiate<Material>(((TMP_Asset)DarumaDropOne).material), "GameObject.Instantiate(DarumaDropOne.material)");
					_darumaShadowMaterial.EnableKeyword("UNDERLAY_ON");
					_darumaShadowMaterial.SetFloat(UnderlayDilate, 1f);
					_darumaShadowMaterial.SetFloat(UnderlayOffsetY, -0.7f);
					_darumaShadowMaterial.SetFloat(UnderlaySoftness, 1f);
					_darumaShadowMaterial.SetColor(UnderlayColor, new Color(0f, 0f, 0f, 0.1960784f));
					Log.LogInfo((object)"Shadow material for Critial Hit indicator was successfully generated!");
				}
				return _darumaShadowMaterial;
			}
		}

		public GameObject UnnamedKioskSetup { get; private set; }

		public GameObject UnnamedBrokenStandeeSetup { get; private set; }

		public Dictionary<string, Material> PlaneMaterials { get; set; }

		public Dictionary<string, Material> MirageMaterials { get; set; }

		public static bool ShouldBeUnnamed => Random.value <= 0.25f;

		public static bool LuggageShouldBeUnnamed => Random.value <= 0.125f;

		public static float RandomUnnamedModifier => RandomModifier();

		public static bool RandomUnnamedBool => IsUnnamedLucky();

		public static string Name => "UnnamedProducts";

		public static string Version => "1.3.0";

		private void Awake()
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			UnnamedInfo = ((BaseUnityPlugin)this).Info;
			_modInfoPrefix = ModDefinition.GetOrCreate(UnnamedInfo).Id + ":";
			_unnamedPrefix = _modInfoPrefix + "Unnamed";
			AddLocalizedTextCsv();
			int num = 0;
			foreach (int value in Enum.GetValues(typeof(SpawnPool)))
			{
				if (value > num)
				{
					num = value;
				}
			}
			UnnamedSpawnPool = (SpawnPool)(num * 2);
			Log.LogInfo((object)$"Highest spawn pool: {num}. Using {num * 2} as the unnamed pool");
			Log.LogInfo((object)("Plugin " + Name + " is loading..."));
			_hasAnyGlobalSpawningZombies = GlobalZombieSpawnModList.Any(Chainloader.PluginInfos.ContainsKey);
			GlobalEvents.OnItemRequested = (Action<Item, Character>)Delegate.Combine(GlobalEvents.OnItemRequested, new Action<Item, Character>(CheckForStickyFireballs));
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "unnamed.peakbundle", (Action<PeakBundle>)delegate(PeakBundle peakBundle)
			{
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0261: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0290: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02df: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0309: Unknown result type (might be due to invalid IL or missing references)
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0333: Unknown result type (might be due to invalid IL or missing references)
				//IL_0338: Unknown result type (might be due to invalid IL or missing references)
				//IL_035d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0362: Unknown result type (might be due to invalid IL or missing references)
				//IL_0387: Unknown result type (might be due to invalid IL or missing references)
				//IL_038c: 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_03bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c6: Expected O, but got Unknown
				//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0403: Expected O, but got Unknown
				//IL_042c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0431: Unknown result type (might be due to invalid IL or missing references)
				//IL_0436: Unknown result type (might be due to invalid IL or missing references)
				//IL_0440: Expected O, but got Unknown
				//IL_0469: Unknown result type (might be due to invalid IL or missing references)
				//IL_046e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0473: Unknown result type (might be due to invalid IL or missing references)
				//IL_047d: Expected O, but got Unknown
				//IL_0673: Unknown result type (might be due to invalid IL or missing references)
				//IL_0678: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_080a: Unknown result type (might be due to invalid IL or missing references)
				//IL_080f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0825: Unknown result type (might be due to invalid IL or missing references)
				//IL_082a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0866: Unknown result type (might be due to invalid IL or missing references)
				//IL_086b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0881: Unknown result type (might be due to invalid IL or missing references)
				//IL_0886: Unknown result type (might be due to invalid IL or missing references)
				//IL_089c: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_08b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_08bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_093d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0942: Unknown result type (might be due to invalid IL or missing references)
				//IL_094d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0958: Unknown result type (might be due to invalid IL or missing references)
				//IL_095f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0966: Unknown result type (might be due to invalid IL or missing references)
				//IL_096d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0974: Unknown result type (might be due to invalid IL or missing references)
				//IL_097f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0986: Unknown result type (might be due to invalid IL or missing references)
				//IL_098d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0994: Unknown result type (might be due to invalid IL or missing references)
				//IL_099b: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_09b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_09b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_09be: Unknown result type (might be due to invalid IL or missing references)
				//IL_09c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_09cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_09d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_09d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_09dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_09ed: Expected O, but got Unknown
				//IL_0a43: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a48: Unknown result type (might be due to invalid IL or missing references)
				//IL_1433: Unknown result type (might be due to invalid IL or missing references)
				//IL_1363: Unknown result type (might be due to invalid IL or missing references)
				GameObject val5 = peakBundle.LoadAsset<GameObject>("Antifreeze.prefab");
				Log.LogInfo((object)"Loading Antifreeze...");
				MeshRenderer[] componentsInChildren = val5.GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val6 in componentsInChildren)
				{
					((Renderer)val6).sortingOrder = 1;
					if (((Object)((Renderer)val6).sharedMaterial.shader).name == "Shader Graphs/LiquidEffect" || ((Object)((Renderer)val6).material.shader).name == "Shader Graphs/LiquidEffect")
					{
						GameObject gameObject = ((Component)val6).gameObject;
						LiquidController orAddComponent3 = ExtGameObject.GetOrAddComponent<LiquidController>(gameObject);
						Log.LogInfo((object)"Initializing Liquid Controller...");
						orAddComponent3.mesh = gameObject.GetComponent<MeshFilter>().sharedMesh;
						orAddComponent3.rend = (Renderer)(object)val6;
						orAddComponent3.compensateShapeAmount = 0.132f;
						orAddComponent3.Thickness = 0.5f;
						orAddComponent3.fillAmount = 0.4f;
						orAddComponent3.Recovery = 1f;
						orAddComponent3.MaxWobble = 0.03f;
						orAddComponent3.WobbleSpeedMove = 0.5f;
					}
				}
				ExplodeOnBurningAction explodeOnBurningAction = val5.AddComponent<ExplodeOnBurningAction>();
				explodeOnBurningAction.dontRunIfOutOfFuel = false;
				((ItemAction)explodeOnBurningAction).OnCastFinished = true;
				UnnamedSpawnRestriction orAddComponent4 = ExtGameObject.GetOrAddComponent<UnnamedSpawnRestriction>(val5);
				orAddComponent4.biomeType = CollectionExtensions.AddToArray<BiomeType>(orAddComponent4.biomeType, (BiomeType)2);
				orAddComponent4.whenNightIsCold = true;
				orAddComponent4.hasColdNightRestrictions = true;
				LootData orAddComponent5 = ExtGameObject.GetOrAddComponent<LootData>(val5);
				orAddComponent5.spawnLocations = UnnamedSpawnPool;
				Log.LogInfo((object)"Loading sticky fireball...");
				GameObject val7 = peakBundle.LoadAsset<GameObject>("StickyFireball.prefab");
				StickyFireballController orAddComponent6 = ExtGameObject.GetOrAddComponent<StickyFireballController>(val7);
				orAddComponent6.destroyAfterTime = val7.GetComponent<DestroyAfterTime>();
				orAddComponent6.rb = val7.GetComponent<Rigidbody>();
				AudioSource component = ((Component)orAddComponent6).GetComponent<AudioSource>();
				Item val8 = default(Item);
				if (ItemDatabase.TryGetItem((ushort)62, ref val8))
				{
					AudioClip clip = ((Component)val8).GetComponent<Constructable>().constructedPrefab.gameObject.GetComponent<AudioSource>().clip;
					component.clip = clip;
					Campfire componentInChildren = ((Component)val8).GetComponent<Constructable>().constructedPrefab.GetComponentInChildren<Campfire>();
					SFX_Instance[] fireStart = componentInChildren.fireStart;
					SFX_Instance[] extinguish = componentInChildren.extinguish;
					orAddComponent6.extinguish = extinguish;
					orAddComponent6.fireStart = fireStart;
				}
				component.SetCustomCurve((AudioSourceCurveType)0, new AnimationCurve((Keyframe[])(object)new Keyframe[10]
				{
					new Keyframe(0.002f, 1f, -500.2007f, -500.2007f, 0f, 0f),
					new Keyframe(0.004f, 0.5f, -125.0502f, -125.0502f, 0f, 0f),
					new Keyframe(0.008f, 0.25f, -31.2625f, -31.2625f, 0f, 0f),
					new Keyframe(0.016f, 0.125f, -7.8156f, -7.8156f, 0f, 0f),
					new Keyframe(0.032f, 0.0625f, -1.9539f, -1.9539f, 0f, 0f),
					new Keyframe(0.064f, 1f / 32f, -0.4885f, -0.4885f, 0f, 0f),
					new Keyframe(0.128f, 1f / 64f, -0.1221f, -0.1221f, 0f, 0f),
					new Keyframe(0.256f, 1f / 128f, -0.0305f, -0.0305f, 0f, 0f),
					new Keyframe(0.512f, 0.00390625f, -0.00076f, -0.00076f, 0f, 0f),
					new Keyframe(1f, 0f, -0.002f, -0.002f, 0f, 0f)
				}));
				component.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 0.3333f, 0.3333f)
				}));
				component.SetCustomCurve((AudioSourceCurveType)2, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 0.3333f, 0.3333f)
				}));
				component.SetCustomCurve((AudioSourceCurveType)3, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 0.3333f, 0.3333f)
				}));
				Renderer[] componentsInChildren2 = ((Component)orAddComponent6).GetComponentsInChildren<Renderer>(true);
				Material item;
				foreach (Renderer val9 in componentsInChildren2)
				{
					Material[] materials = val9.materials;
					int l = 0;
					for (int num3 = materials.Length; l < num3; l++)
					{
						Material val10 = materials[l];
						val10.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val10.shader).name), "Shader.Find(mat.shader.name)");
					}
					Renderer val11 = val9;
					Material[] array = materials;
					List<Material> list = new List<Material>(array.Length);
					Material[] array2 = array;
					for (int m = 0; m < array2.Length; m++)
					{
						item = array2[m];
						list.Add(item);
					}
					val11.SetMaterials(list);
				}
				Item val12 = default(Item);
				if (ItemDatabase.TryGetItem((ushort)35, ref val12))
				{
					ItemCooking orAddComponent7 = ExtGameObject.GetOrAddComponent<ItemCooking>(val5);
					GameObject val13 = peakBundle.LoadAsset<GameObject>("AntifreezeExplosion.prefab");
					AntifreezeExplosionController antifreezeExplosionController = val13.AddComponent<AntifreezeExplosionController>();
					antifreezeExplosionController.stickyFireball = ((Component)orAddComponent6).gameObject;
					antifreezeExplosionController.m_amountOfFireballs = 20;
					GameObject val14 = Object.Instantiate<GameObject>(((Component)val12).GetComponent<ItemCooking>().explosionPrefab);
					val14.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)val14);
					antifreezeExplosionController.explosionPrefab = val14;
					orAddComponent7.explosionPrefab = ((Component)antifreezeExplosionController).gameObject;
					NetworkPrefabManager.RegisterNetworkPrefab(ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info), ((Component)antifreezeExplosionController).gameObject);
					NetworkPrefabManager.RegisterNetworkPrefab(ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info), val14);
				}
				StickyFireballController.FireballPrefab = ((Component)orAddComponent6).gameObject;
				NetworkPrefabManager.RegisterNetworkPrefab(ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info), ((Component)orAddComponent6).gameObject);
				UnnamedUniques.Add(((Object)val5).name.Trim());
				GameObject val15 = peakBundle.LoadAsset<GameObject>("LaundryDetergent.prefab");
				Action_Detergent orAddComponent8 = ExtGameObject.GetOrAddComponent<Action_Detergent>(val15);
				((ItemAction)orAddComponent8).OnCastFinished = true;
				UnnamedSpawnRestriction orAddComponent9 = ExtGameObject.GetOrAddComponent<UnnamedSpawnRestriction>(val15);
				orAddComponent9.biomeType = CollectionExtensions.AddToArray<BiomeType>(CollectionExtensions.AddToArray<BiomeType>(CollectionExtensions.AddToArray<BiomeType>(orAddComponent9.biomeType, (BiomeType)7), (BiomeType)6), (BiomeType)2);
				orAddComponent9.hasZombieRestrictions = true;
				orAddComponent9.whenZombieSpawnGlobally = true;
				LootData orAddComponent10 = ExtGameObject.GetOrAddComponent<LootData>(val15);
				orAddComponent10.spawnLocations = UnnamedSpawnPool;
				UnnamedUniques.Add(((Object)val15).name.Trim());
				GameObject val16 = peakBundle.LoadAsset<GameObject>("GarbageBag.prefab");
				Item val17 = default(Item);
				ItemDatabase.TryGetItem((ushort)91, ref val17);
				BananaPeel component2 = ((Component)val17).GetComponent<BananaPeel>();
				UnnamedGarbageBagController orAddComponent11 = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagController>(val16);
				UnnamedGarbageBagSlips orAddComponent12 = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagSlips>(val16);
				UnnamedGarbageBagAudio orAddComponent13 = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagAudio>(val16);
				ItemCooking orAddComponent14 = ExtGameObject.GetOrAddComponent<ItemCooking>(val16);
				BackPackAudio val18 = default(BackPackAudio);
				if (val16.TryGetComponent<BackPackAudio>(ref val18))
				{
					orAddComponent13.holdSFX = val18.holdSFX;
					orAddComponent13.dropSFX = val18.dropSFX;
					Object.Destroy((Object)(object)val18);
				}
				orAddComponent11.slipSDSfxInstances = (SFX_Instance[])(object)new SFX_Instance[1] { component2.slipSFX[0] };
				orAddComponent14.additionalCookingBehaviors = CollectionExtensions.AddToArray<AdditionalCookingBehavior>(orAddComponent14.additionalCookingBehaviors, (AdditionalCookingBehavior)(object)new CookingBehavior_DestroyAndReleaseGarbageBagItems
				{
					cookedAmountToTrigger = 1
				});
				orAddComponent12.garbageBag = orAddComponent11;
				orAddComponent12.rig = val16.GetComponent<Rigidbody>();
				orAddComponent12.slipOnCollision = true;
				orAddComponent12.minSlipVelocity = 15f;
				orAddComponent12.ragdollCharacterOnSlip = false;
				orAddComponent12.pushForce = 2f;
				orAddComponent12.wholeBodyPushForce = 1f;
				orAddComponent11.fullBagGameObject = ((Component)val16.transform.Find("GarbageBag/filled")).gameObject;
				orAddComponent11.emptyBagGameObject = ((Component)val16.transform.Find("GarbageBag/empty")).gameObject;
				orAddComponent11.rightHandEmptyPosition = new Vector3(0.1941f, 0.179f, -0.3009f);
				orAddComponent11.leftHandEmptyPosition = new Vector3(-0.187f, 0.179f, -0.292f);
				orAddComponent11.rightHandFullPosition = new Vector3(0.407f, 0.17900696f, -0.429f);
				orAddComponent11.leftHandFullPosition = new Vector3(-0.377f, 0.179f, -0.42899966f);
				orAddComponent11.fullBagGameObject.SetActive(true);
				ShaderExtensions.ReplaceShaders(orAddComponent11.fullBagGameObject);
				orAddComponent11.fullBagGameObject.SetActive(false);
				((Item)orAddComponent11).defaultPos = new Vector3(0f, -0.3f, 1.3166288f);
				orAddComponent11.defaultPosFilled = new Vector3(0f, -0.3f, 1.3166288f);
				orAddComponent11.defaultPosEmpty = new Vector3(0f, -0.3f, 0.81002724f);
				((Item)orAddComponent11).defaultForward = new Vector3(0f, 0f, 1f);
				((Item)orAddComponent11).mainRenderer = orAddComponent11.fullBagGameObject.GetComponent<Renderer>();
				((Item)orAddComponent11).addtlRenderers = (Renderer[])(object)new Renderer[1] { orAddComponent11.emptyBagGameObject.GetComponent<Renderer>() };
				UnnamedGarbageBagVisuals orAddComponent15 = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagVisuals>(val16);
				orAddComponent15.item = (Item)(object)orAddComponent11;
				orAddComponent11.m_unnamedGarbageBagVisuals = orAddComponent15;
				orAddComponent11.openRadialMenuTime = 0f;
				GarbageBagIcon = peakBundle.LoadAsset<Texture2D>("GarbageBag Icon.png");
				((Item)orAddComponent11).carryWeight = 1;
				((Item)orAddComponent11).mass = 50f;
				((Item)orAddComponent11).UIData = new ItemUIData
				{
					itemName = "Garbage Bag",
					icon = GarbageBagIcon,
					hasAltIcon = false,
					hasColorBlindIcon = false,
					altIcon = null,
					hasMainInteract = false,
					mainInteractPrompt = "OPEN",
					hasSecondInteract = false,
					secondaryInteractPrompt = null,
					hasScrollingInteract = false,
					scrollInteractPrompt = null,
					canDrop = true,
					canPocket = true,
					canBackpack = true,
					canThrow = true,
					isShootable = false,
					hideFuel = true,
					iconPositionOffset = default(Vector3),
					iconRotationOffset = default(Vector3),
					iconScaleOffset = 1.49f
				};
				((Item)orAddComponent11).totalUses = -1;
				UnnamedUniques.Add(((Object)val16).name.Trim());
				GameObject val19 = peakBundle.LoadAsset<GameObject>("GarbageBagBox.prefab");
				Action_SpawnAndGrab orAddComponent16 = ExtGameObject.GetOrAddComponent<Action_SpawnAndGrab>(val19);
				orAddComponent16.itemToSpawn = val16.GetComponent<Item>();
				((ItemAction)orAddComponent16).OnCastFinished = true;
				LootData orAddComponent17 = ExtGameObject.GetOrAddComponent<LootData>(val19);
				orAddComponent17.spawnLocations = UnnamedSpawnPool;
				UnnamedUniques.Add(((Object)val19).name.Trim());
				SmallLuggageMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage.mat");
				SmallLuggageInteriorMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage_interior.mat");
				EpicLuggageMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage_epic.mat");
				LargeLuggageMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage_large.mat");
				LargeLuggageInteriorMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage_interior_large.mat");
				AncientLuggageMaterial = peakBundle.LoadAsset<Material>("M_UnnamedLuggage_ancient.mat");
				AncientLuggageMetalMaterial = peakBundle.LoadAsset<Material>("M_UnnamedMetal.mat");
				AncientLuggageCrystalMaterial = peakBundle.LoadAsset<Material>("M_UnnamedRock_Crystal.mat");
				RespawnStatueCalderaMaterial = peakBundle.LoadAsset<Material>("M_UnnamedRock_Volcano.mat");
				RespawnStatueAlpineMaterial = peakBundle.LoadAsset<Material>("M_UnnamedRock_peak Snow.mat");
				RespawnStatueMesaMaterial = peakBundle.LoadAsset<Material>("M_UnnamedDesertSand.mat");
				RespawnStatueRootsMaterial = peakBundle.LoadAsset<Material>("M_UnnamedForest_rock.mat");
				RespawnStatueTropicsMaterial = peakBundle.LoadAsset<Material>("M_UnnamedRock 1.mat");
				RespawnStatueShoreMaterial = peakBundle.LoadAsset<Material>("M_UnnamedSaltRock.mat");
				RespawnStatueRockVFXMaterial = peakBundle.LoadAsset<Material>("M_UnnamedRock_staticTopColour.mat");
				PlaneMaterials = new Dictionary<string, Material>();
				string[] array3 = new string[10] { "Plane", "Plane 1", "Plane 3", "Plane 4", "Plane cleaner", "Plane Glass", "Plane seat", "Plane-snow", "PlaneWings", "PlaneWings-snow" };
				string[] array4 = array3;
				foreach (string text in array4)
				{
					Material val20 = peakBundle.LoadAsset<Material>("M_Unnamed" + text + ".mat");
					val20.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val20.shader).name), "Shader.Find(planeMaterial.shader.name)");
					Log.LogInfo((object)("Added plane material named " + ((Object)val20).name + "."));
					PlaneMaterials[text] = val20;
				}
				MirageMaterials = new Dictionary<string, Material>();
				string[] array5 = new string[6] { "Luggage_Large_Mirage", "Luggage_Ancient_Mirage", "Luggage_AncientChain_Mirage", "Luggage_AncientCrystal_Mirage", "Luggage-mirage", "Luggage_Epic_Mirage" };
				string[] array6 = array5;
				foreach (string text2 in array6)
				{
					Material val21 = peakBundle.LoadAsset<Material>("M_Unnamed" + text2 + ".mat");
					val21.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val21.shader).name), "Shader.Find(mirageMaterial.shader.name)");
					Log.LogInfo((object)("Added mirage material named " + ((Object)val21).name + "."));
					MirageMaterials[text2] = val21;
				}
				SmallLuggageMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)SmallLuggageMaterial.shader).name), "Shader.Find(SmallLuggageMaterial.shader.name)");
				SmallLuggageInteriorMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)SmallLuggageInteriorMaterial.shader).name), "Shader.Find(SmallLuggageInteriorMaterial.shader.name)");
				EpicLuggageMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)EpicLuggageMaterial.shader).name), "Shader.Find(EpicLuggageMaterial.shader.name)");
				LargeLuggageMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)LargeLuggageMaterial.shader).name), "Shader.Find(LargeLuggageMaterial.shader.name)");
				LargeLuggageInteriorMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)LargeLuggageInteriorMaterial.shader).name), "Shader.Find(LargeLuggageInteriorMaterial.shader.name)");
				AncientLuggageMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)AncientLuggageMaterial.shader).name), "Shader.Find(AncientLuggageMaterial.shader.name)");
				AncientLuggageMetalMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)AncientLuggageMetalMaterial.shader).name), "Shader.Find(AncientLuggageMetalMaterial.shader.name)");
				AncientLuggageCrystalMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)AncientLuggageCrystalMaterial.shader).name), "Shader.Find(AncientLuggageCrystalMaterial.shader.name)");
				RespawnStatueRockVFXMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueRockVFXMaterial.shader).name), "Shader.Find(RespawnStatueRockVFXMaterial.shader.name)");
				RespawnStatueCalderaMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueCalderaMaterial.shader).name), "Shader.Find(RespawnStatueCalderaMaterial.shader.name)");
				RespawnStatueAlpineMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueAlpineMaterial.shader).name), "Shader.Find(RespawnStatueAlpineMaterial.shader.name)");
				RespawnStatueMesaMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueMesaMaterial.shader).name), "Shader.Find(RespawnStatueMesaMaterial.shader.name)");
				RespawnStatueRootsMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueRootsMaterial.shader).name), "Shader.Find(RespawnStatueRootsMaterial.shader.name)");
				RespawnStatueTropicsMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueTropicsMaterial.shader).name), "Shader.Find(RespawnStatueTropicsMaterial.shader.name)");
				RespawnStatueShoreMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)RespawnStatueShoreMaterial.shader).name), "Shader.Find(RespawnStatueShoreMaterial.shader.name)");
				Log.LogInfo((object)("Added material named " + ((Object)SmallLuggageMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)SmallLuggageInteriorMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)EpicLuggageMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)LargeLuggageMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)LargeLuggageInteriorMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)AncientLuggageMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)AncientLuggageMetalMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)AncientLuggageCrystalMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueRockVFXMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueCalderaMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueAlpineMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueMesaMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueRootsMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueTropicsMaterial).name + "."));
				Log.LogInfo((object)("Added material named " + ((Object)RespawnStatueShoreMaterial).name + "."));
				List<ushort> list2 = new List<ushort>(34)
				{
					0, 1, 2, 7, 115, 17, 18, 24, 106, 27,
					29, 32, 152, 99, 33, 70, 35, 42, 43, 44,
					58, 98, 61, 62, 100, 63, 64, 65, 107, 66,
					67, 71, 104, 73
				};
				int num5 = 0;
				Item val22 = default(Item);
				for (int count = list2.Count; num5 < count; num5++)
				{
					ushort num6 = list2[num5];
					if (ItemDatabase.TryGetItem(num6, ref val22))
					{
						string itemName = val22.UIData.itemName;
						GameObject go = GenerateInstancedVariant(((Component)val22).gameObject, CleanItemName(((Object)((Component)val22).gameObject).name));
						Item it = go.gameObject.GetComponent<Item>();
						CopyUnnamedMaterials(ref go, peakBundle);
						CopyUnnamedIcons(ref it, peakBundle);
						PopulateUnnamedData(ref it, peakBundle);
						CopyExplosionData(ref it, peakBundle);
						LootData component3 = go.gameObject.GetComponent<LootData>();
						Object.Destroy((Object)(object)component3);
						AddItemToDatabase(itemName, go.gameObject);
						if (itemName == "Lantern")
						{
							GameObject gameObject2 = ((Component)it).gameObject;
							((Object)gameObject2).name = ((Object)gameObject2).name + "_lant";
						}
						new ItemContent(it).Register(ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info));
					}
				}
				BigUnnamedLuggagePrefab = GenerateUnnamedLuggagePrefab("0_Items/LuggageBig");
				SmallUnnamedLuggagePrefab = GenerateUnnamedLuggagePrefab("0_Items/LuggageSmall");
				EpicUnnamedLuggagePrefab = GenerateUnnamedLuggagePrefab("0_Items/LuggageEpic");
				AncientUnnamedLuggagePrefab = GenerateUnnamedLuggagePrefab("0_Items/LuggageAncient");
				GameObject val23 = peakBundle.LoadAsset<GameObject>("UnnamedAirportSetup.prefab");
				ShaderExtensions.ReplaceShaders(val23);
				TextMeshProUGUI componentInChildren2 = val23.GetComponentInChildren<TextMeshProUGUI>(true);
				((TMP_Text)componentInChildren2).font = DarumaDropOne;
				((TMP_Text)componentInChildren2).lineSpacing = -50f;
				Material val24 = (((Graphic)componentInChildren2).material = DarumaDropOneShadowMaterial);
				item = (((TMP_Text)componentInChildren2).fontMaterial = val24);
				((TMP_Text)componentInChildren2).fontSharedMaterial = item;
				LocalizedText orAddComponent18 = ExtGameObject.GetOrAddComponent<LocalizedText>(((Component)componentInChildren2).gameObject);
				orAddComponent18.fontStyle = (FontStyle)1;
				orAddComponent18.index = "KIOSK_READY_TEXT";
				orAddComponent18.tmp = (TMP_Text)(object)componentInChildren2;
				orAddComponent18.autoSet = true;
				UnnamedKioskSetup = val23;
				GameObject val26 = peakBundle.LoadAsset<GameObject>("UnnamedBrokenStandee.prefab");
				ShaderExtensions.ReplaceShaders(val26);
				UnnamedBrokenStandeeSetup = val26;
				peakBundle.Mod.RegisterContent();
				Log.LogInfo((object)"Unnamed items are loaded!");
			});
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "unnamedui.peakbundle", (Action<PeakBundle>)delegate(PeakBundle bundle)
			{
				GameObject val2 = bundle.LoadAsset<GameObject>("UnnamedGarbageBagWheel.prefab");
				UnnamedGarbageBagScreen unnamedGarbageBagScreen = val2.AddComponent<UnnamedGarbageBagScreen>();
				((UIWheel)unnamedGarbageBagScreen).maxCursorDistance = 190f;
				unnamedGarbageBagScreen.chosenItemText = ((Component)((Component)unnamedGarbageBagScreen).transform.Find("SelectedItemName")).GetComponent<TextMeshProUGUI>();
				unnamedGarbageBagScreen.currentlyHeldItem = ((Component)((Component)unnamedGarbageBagScreen).transform.Find("HeldItem")).GetComponent<RawImage>();
				ShaderExtensions.ReplaceShaders(val2);
				int i = 0;
				BackpackWheelSlice val3 = default(BackpackWheelSlice);
				BackpackWheelSlice val4 = default(BackpackWheelSlice);
				for (int childCount = val2.transform.Find("Wheel").childCount; i < childCount; i++)
				{
					Transform child = val2.transform.Find("Wheel").GetChild(i);
					if (((Object)child).name == "UI_PickupZone")
					{
						UnnamedGarbageBagZone orAddComponent = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagZone>(((Component)child).gameObject);
						orAddComponent.image = ((Component)((Component)orAddComponent).transform.Find("Segment")).GetComponentInChildren<RawImage>();
						((UIWheelSlice)orAddComponent).button = ((Component)orAddComponent).GetComponent<Button>();
						unnamedGarbageBagScreen.pickupZone = orAddComponent;
						if (((Component)child).gameObject.TryGetComponent<BackpackWheelSlice>(ref val3))
						{
							Object.Destroy((Object)(object)val3);
						}
					}
					else
					{
						UnnamedGarbageBagZone orAddComponent2 = ExtGameObject.GetOrAddComponent<UnnamedGarbageBagZone>(((Component)child).gameObject);
						orAddComponent2.image = ((Component)((Component)orAddComponent2).transform.Find("Segment")).GetComponentInChildren<RawImage>();
						((UIWheelSlice)orAddComponent2).button = ((Component)orAddComponent2).GetComponent<Button>();
						unnamedGarbageBagScreen.garbageBagZones = CollectionExtensions.AddToArray<UnnamedGarbageBagZone>(unnamedGarbageBagScreen.garbageBagZones, orAddComponent2);
						if (((Component)child).gameObject.TryGetComponent<BackpackWheelSlice>(ref val4))
						{
							Object.Destroy((Object)(object)val4);
						}
					}
				}
				UnnamedGarbageBagPrefab = ((Component)unnamedGarbageBagScreen).gameObject;
				bundle.Mod.RegisterContent();
				Log.LogInfo((object)"Garbage Bag UI is loaded!");
			});
			Harmony val = new Harmony("com.github.MiiMii1205.UnnamedProducts");
			if (Unnamed4FoodCompatibility.enabled)
			{
				Unnamed4FoodCompatibility.LoadCompatibilityBundle(this);
			}
			if (UnnamedCanadianCompatibility.enabled)
			{
				UnnamedCanadianCompatibility.LoadCompatibilityBundle(this);
			}
			if (UnnamedLuckyBlocksCompatibility.enabled)
			{
				UnnamedLuckyBlocksCompatibility.LoadCompatibilityBundle(this, val);
			}
			val.PatchAll(typeof(UnnamedItemPatcher));
			val.PatchAll(typeof(UnnamedPatcher));
			val.PatchAll(typeof(UnnamedSpawnerPatcher));
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private static string CleanItemName(string dirtyName)
		{
			return dirtyName.Replace(_modInfoPrefix, "").Replace("(Clone)", "").Replace("(Instanced)", "");
		}

		private GameObject GenerateUnnamedLuggagePrefab(string normalPrefabName)
		{
			GameObject val = Object.Instantiate<GameObject>(Resources.Load<GameObject>(normalPrefabName));
			LuggageBrandHandler luggageBrandHandler = val.AddComponent<LuggageBrandHandler>();
			luggageBrandHandler.shouldBeUnnamed = true;
			luggageBrandHandler.luggage = val.GetComponent<Luggage>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return RegisterOrGetNetworkPrefab(val);
		}

		public GameObject RegisterOrGetNetworkPrefab(GameObject prefab, string folder = "")
		{
			string text = ((Object)prefab).name.Split(":").Last();
			string text2 = folder + ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info).Id + ":" + text;
			if (NetworkPrefabManager.TryRegisterNetworkPrefab(text2, prefab))
			{
				((Object)prefab).name = text2;
				return prefab;
			}
			GameObject val = default(GameObject);
			if (NetworkPrefabManager.TryGetNetworkPrefab(text2, ref val) && (Object)(object)val != (Object)null)
			{
				return val;
			}
			throw new Exception("Failed to get network prefab!");
		}

		public GameObject RegisterOrGetItemPrefab(GameObject prefab)
		{
			RegisterOrGetNetworkPrefab(prefab, "0_Items/");
			((Object)prefab).name = ((Object)prefab).name.Replace("0_Items/", "");
			return prefab;
		}

		public static void RenameToUnnamed(GameObject ob, bool withPrefix = true)
		{
			((Object)ob).name = ModDefinition.GetOrCreate(UnnamedInfo).Id + ":" + (withPrefix ? "Unnamed" : "") + ((Object)ob).name.Replace("Unnamed", "");
		}

		public void CopyExplosionData(ref Item newIt, PeakBundle peakBundle)
		{
			ItemCooking val = default(ItemCooking);
			if (((Component)newIt).gameObject.TryGetComponent<ItemCooking>(ref val) && Object.op_Implicit((Object)(object)val.explosionPrefab))
			{
				GameObject val2 = Object.Instantiate<GameObject>(val.explosionPrefab);
				((Object)val2).name = "Unnamed" + ((Object)val.explosionPrefab).name.Replace("Unnamed", "");
				AOE componentInChildren = val2.GetComponentInChildren<AOE>();
				if (componentInChildren != null && !IsUnnamed(((Component)componentInChildren).gameObject))
				{
					RenameToUnnamed(((Component)componentInChildren).gameObject);
				}
				val.explosionPrefab = RegisterOrGetNetworkPrefab(val2);
				Object.DontDestroyOnLoad((Object)(object)val2);
				val2.SetActive(false);
			}
			Breakable val3 = default(Breakable);
			if (!((Component)newIt).gameObject.TryGetComponent<Breakable>(ref val3))
			{
				return;
			}
			for (int i = 0; i < val3.instantiateNonItemOnBreak.Count; i++)
			{
				GameObject val4 = Object.Instantiate<GameObject>(val3.instantiateNonItemOnBreak[i]);
				((Object)val4).name = "Unnamed" + ((Object)val3.instantiateNonItemOnBreak[i]).name.Replace("Unnamed", "");
				AOE componentInChildren2 = val4.GetComponentInChildren<AOE>();
				if (componentInChildren2 != null && !IsUnnamed(((Component)componentInChildren2).gameObject))
				{
					RenameToUnnamed(((Component)componentInChildren2).gameObject);
				}
				val3.instantiateNonItemOnBreak[i] = RegisterOrGetNetworkPrefab(val4);
				Object.DontDestroyOnLoad((Object)(object)val4);
				val4.SetActive(false);
			}
		}

		private static void CheckForStickyFireballs(Item item, Character chara)
		{
			if (Object.op_Implicit((Object)(object)item))
			{
				StickyFireballController componentInChildren = ((Component)item).GetComponentInChildren<StickyFireballController>();
				if (componentInChildren != null && componentInChildren.m_isBurning)
				{
					StickyFireballController.Burn(chara.GetBodypart((BodypartType)(((double)Random.value > 0.5) ? 7 : 10)));
				}
			}
		}

		public void PopulateUnnamedData(ref Item it, PeakBundle peakBundle)
		{
			//IL_1e3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e61: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e81: Unknown result type (might be due to invalid IL or missing references)
			//IL_13c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_13d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_13fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_1655: Unknown result type (might be due to invalid IL or missing references)
			//IL_165a: Unknown result type (might be due to invalid IL or missing references)
			//IL_126f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1285: Unknown result type (might be due to invalid IL or missing references)
			//IL_12aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_15cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_15f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2065: Unknown result type (might be due to invalid IL or missing references)
			//IL_206a: Unknown result type (might be due to invalid IL or missing references)
			//IL_208f: Unknown result type (might be due to invalid IL or missing references)
			//IL_2094: Unknown result type (might be due to invalid IL or missing references)
			//IL_2099: Unknown result type (might be due to invalid IL or missing references)
			//IL_20a3: Expected O, but got Unknown
			//IL_20cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_20d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_20d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_20e0: Expected O, but got Unknown
			//IL_2109: Unknown result type (might be due to invalid IL or missing references)
			//IL_210e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2113: Unknown result type (might be due to invalid IL or missing references)
			//IL_211d: Expected O, but got Unknown
			//IL_2146: Unknown result type (might be due to invalid IL or missing references)
			//IL_214b: Unknown result type (might be due to invalid IL or missing references)
			//IL_2150: Unknown result type (might be due to invalid IL or missing references)
			//IL_215a: Expected O, but got Unknown
			//IL_2183: Unknown result type (might be due to invalid IL or missing references)
			//IL_2188: Unknown result type (might be due to invalid IL or missing references)
			//IL_218d: Unknown result type (might be due to invalid IL or missing references)
			//IL_2197: Expected O, but got Unknown
			//IL_222e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1aef: Unknown result type (might be due to invalid IL or missing references)
			//IL_1af4: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b19: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b1e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b23: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b2d: Expected O, but got Unknown
			//IL_1b56: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b60: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b6a: Expected O, but got Unknown
			//IL_1b93: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b98: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ba7: Expected O, but got Unknown
			//IL_1bd0: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bda: Unknown result type (might be due to invalid IL or missing references)
			//IL_1be4: Expected O, but got Unknown
			//IL_1c0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c12: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c17: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c21: Expected O, but got Unknown
			//IL_1cc0: Unknown result type (might be due to invalid IL or missing references)
			//IL_1cc5: Unknown result type (might be due to invalid IL or missing references)
			//IL_14fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1503: Unknown result type (might be due to invalid IL or missing references)
			//IL_17f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_17f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1802: Unknown result type (might be due to invalid IL or missing references)
			//IL_1807: Unknown result type (might be due to invalid IL or missing references)
			//IL_1810: Unknown result type (might be due to invalid IL or missing references)
			//IL_1815: Unknown result type (might be due to invalid IL or missing references)
			//IL_1856: Unknown result type (might be due to invalid IL or missing references)
			//IL_185b: Unknown result type (might be due to invalid IL or missing references)
			//IL_130d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1323: Unknown result type (might be due to invalid IL or missing references)
			//IL_1348: Unknown result type (might be due to invalid IL or missing references)
			//IL_23be: Unknown result type (might be due to invalid IL or missing references)
			//IL_23d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_23f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_249f: Unknown result type (might be due to invalid IL or missing references)
			//IL_24a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2703: Unknown result type (might be due to invalid IL or missing references)
			//IL_2708: Unknown result type (might be due to invalid IL or missing references)
			//IL_272d: Unknown result type (might be due to invalid IL or missing references)
			//IL_2732: Unknown result type (might be due to invalid IL or missing references)
			//IL_2737: Unknown result type (might be due to invalid IL or missing references)
			//IL_2741: Expected O, but got Unknown
			//IL_276a: Unknown result type (might be due to invalid IL or missing references)
			//IL_276f: Unknown result type (might be due to invalid IL or missing references)
			//IL_2774: Unknown result type (might be due to invalid IL or missing references)
			//IL_277e: Expected O, but got Unknown
			//IL_27a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_27ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_27b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_27bb: Expected O, but got Unknown
			//IL_27e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_27e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_27ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_27f8: Expected O, but got Unknown
			//IL_2821: Unknown result type (might be due to invalid IL or missing references)
			//IL_2826: Unknown result type (might be due to invalid IL or missing references)
			//IL_282b: Unknown result type (might be due to invalid IL or missing references)
			//IL_2835: Expected O, but got Unknown
			//IL_2889: Unknown result type (might be due to invalid IL or missing references)
			//IL_288e: Unknown result type (might be due to invalid IL or missing references)
			//IL_290c: Unknown result type (might be due to invalid IL or missing references)
			//IL_291d: Unknown result type (might be due to invalid IL or missing references)
			//IL_292e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Unknown result type (might be due to invalid IL or missing references)
			//IL_077e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_111b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1131: Unknown result type (might be due to invalid IL or missing references)
			//IL_1156: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_069f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_11e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_11fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			string itemName = it.UIData.itemName;
			if (itemName == null)
			{
				return;
			}
			RopeSpool orAddComponent;
			UnnamedRopeSpool orAddComponent2;
			GameObject val;
			GameObject val2;
			RopeTier orAddComponent3;
			GameObject val3;
			GameObject val4;
			RopeBoneVisualizer component;
			AudioSource orAddComponent4;
			UnnamedRopeBreaker orAddComponent5;
			RopeAudio componentInChildren;
			RopeShooter orAddComponent9;
			UnnamedRopeShooter orAddComponent10;
			GameObject go3;
			RopeAnchorWithRope component4;
			GameObject go4;
			RopeBoneVisualizer component5;
			AudioSource orAddComponent11;
			UnnamedRopeBreaker orAddComponent12;
			StatusField componentInChildren3;
			switch (itemName.Length)
			{
			case 7:
				switch (itemName[0])
				{
				default:
					return;
				case 'F':
					if (itemName == "Frisbee")
					{
						Frisbee component14 = ((Component)it).GetComponent<Frisbee>();
						UnnamedFrisbeeItem orAddComponent29 = ExtGameObject.GetOrAddComponent<UnnamedFrisbeeItem>(((Component)it).gameObject);
						orAddComponent29.frisbee = component14;
						orAddComponent29.originalLiftForce = component14.liftForce;
						orAddComponent29.originalVelocityForLift = component14.velocityForLift;
					}
					return;
				case 'P':
				{
					if (!(itemName == "Parasol"))
					{
						return;
					}
					Parasol orAddComponent26 = ExtGameObject.GetOrAddComponent<Parasol>(((Component)it).gameObject);
					UnnamedParasol orAddComponent27 = ExtGameObject.GetOrAddComponent<UnnamedParasol>(((Component)it).gameObject);
					((Parasol)orAddComponent27).item = orAddComponent26.item;
					((Parasol)orAddComponent27).extraYDrag = orAddComponent26.extraYDrag;
					((Parasol)orAddComponent27).extraXZDrag = orAddComponent26.extraXZDrag;
					((Parasol)orAddComponent27).sinceGroundedOnClose = orAddComponent26.sinceGroundedOnClose;
					((Parasol)orAddComponent27).openParasol = orAddComponent26.openParasol;
					((Parasol)orAddComponent27).closedParasol = orAddComponent26.closedParasol;
					((Parasol)orAddComponent27).anim = orAddComponent26.anim;
					((Parasol)orAddComponent27).isOpen = orAddComponent26.isOpen;
					((Parasol)orAddComponent27).isOpen = orAddComponent26.isOpen;
					Action_Parasol orAddComponent28 = ExtGameObject.GetOrAddComponent<Action_Parasol>(((Component)it).gameObject);
					orAddComponent28.parasol = (Parasol)(object)orAddComponent27;
					MeshFilter[] componentsInChildren14 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val51 in componentsInChildren14)
					{
						string name = ((Object)((Component)val51).gameObject).name;
						if (name == "Parasol Open")
						{
							GameObject gameObject = ((Component)val51).gameObject;
							Object.DestroyImmediate((Object)(object)val51);
							Object.DestroyImmediate((Object)(object)gameObject.GetComponent<Collider>());
							GameObject val52 = peakBundle.LoadAsset<GameObject>("UnnamedParasolOpened.prefab");
							GameObject val53 = Object.Instantiate<GameObject>(val52, gameObject.transform, false);
							Renderer component10 = gameObject.GetComponent<Renderer>();
							Renderer component11 = val53.GetComponent<Renderer>();
							component11.materials = component10.materials;
							component11.sharedMaterials = component10.sharedMaterials;
							Object.DestroyImmediate((Object)(object)component10);
							val53.transform.localPosition = Vector3.zero;
							val53.transform.localScale = ExtDataTypes.ToVec(1f);
							val53.transform.localRotation = new Quaternion(0.7071068f, -3.7252903E-09f, -1.0104486E-09f, 0.7071068f);
						}
						if (name == "Parasol Closed")
						{
							GameObject gameObject2 = ((Component)val51).gameObject;
							Object.DestroyImmediate((Object)(object)val51);
							Object.DestroyImmediate((Object)(object)gameObject2.GetComponent<Collider>());
							GameObject val54 = peakBundle.LoadAsset<GameObject>("UnnamedParasolClosed.prefab");
							GameObject val55 = Object.Instantiate<GameObject>(val54, gameObject2.transform, false);
							Renderer component12 = gameObject2.GetComponent<Renderer>();
							Renderer component13 = val55.GetComponent<Renderer>();
							component13.materials = component12.materials;
							component13.sharedMaterials = component12.sharedMaterials;
							Object.DestroyImmediate((Object)(object)component12);
							val55.transform.localPosition = Vector3.zero;
							val55.transform.localScale = ExtDataTypes.ToVec(1f);
							val55.transform.localRotation = new Quaternion(0.7071068f, -3.7252903E-09f, -1.0104486E-09f, 0.7071068f);
						}
					}
					Object.Destroy((Object)(object)orAddComponent26);
					return;
				}
				case 'B':
				{
					if (!(itemName == "Blowgun"))
					{
						return;
					}
					MeshFilter[] componentsInChildren13 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val49 in componentsInChildren13)
					{
						if (((Object)((Component)val49).gameObject).name == "Blowgun")
						{
							Mesh mesh = (val49.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedBlowgun.fbx"));
							val49.mesh = mesh;
						}
					}
					return;
				}
				case 'L':
					break;
				}
				if (!(itemName == "Lantern"))
				{
					break;
				}
				goto IL_14d6;
			case 14:
				switch (itemName[5])
				{
				case 'b':
				{
					if (!(itemName == "Portable Stove"))
					{
						return;
					}
					Constructable component6 = ((Component)it).GetComponent<Constructable>();
					GameObject go7 = Object.Instantiate<GameObject>(component6.constructedPrefab);
					((Object)go7).name = "Unnamed" + ((Object)component6.constructedPrefab).name;
					Object.DontDestroyOnLoad((Object)(object)go7);
					GameObject val24 = peakBundle.LoadAsset<GameObject>("UnnamedStovePaint.prefab");
					MeshFilter[] componentsInChildren5 = go7.GetComponentsInChildren<MeshFilter>(true);
					MeshCollider val26 = default(MeshCollider);
					foreach (MeshFilter val25 in componentsInChildren5)
					{
						if (((Object)((Component)val25).gameObject).name == "Cube" && ((Component)val25).TryGetComponent<MeshCollider>(ref val26))
						{
							GameObject val27 = Object.Instantiate<GameObject>(val24, ((Component)val25).transform.parent, false);
							val27.transform.localPosition = Vector3.zero;
							val27.transform.localScale = ExtDataTypes.ToVec(3.827086f);
							val27.transform.localRotation = new Quaternion(0f, 0f, 0f, 1f);
							ShaderExtensions.ReplaceShaders(val27);
						}
					}
					MeshFilter[] componentsInChildren6 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val28 in componentsInChildren6)
					{
						if (((Object)((Component)val28).gameObject).name == "Cube" && ((Component)val28).TryGetComponent<MeshCollider>(ref val26))
						{
							GameObject val29 = Object.Instantiate<GameObject>(val24, ((Component)val28).transform.parent, false);
							val29.transform.localPosition = new Vector3(0f, 0f, -4.950033E-05f);
							val29.transform.localScale = ExtDataTypes.ToVec(3.827086f);
							val29.transform.localRotation = new Quaternion(0f, 0f, 0f, 1f);
							ShaderExtensions.ReplaceShaders(val29);
						}
					}
					go7.SetActive(false);
					CopyUnnamedMaterials(ref go7, peakBundle);
					Campfire component7 = go7.GetComponent<Campfire>();
					UnnamedCampfire orAddComponent17 = ExtGameObject.GetOrAddComponent<UnnamedCampfire>(go7);
					((Campfire)orAddComponent17).advanceToSegment = component7.advanceToSegment;
					((Campfire)orAddComponent17).state = component7.state;
					((Campfire)orAddComponent17).enableWhenLit = component7.enableWhenLit;
					((Campfire)orAddComponent17).disableWhenLit = component7.disableWhenLit;
					((Campfire)orAddComponent17).burnsFor = component7.burnsFor;
					((Campfire)orAddComponent17).cookTime = component7.cookTime;
					((Campfire)orAddComponent17).logRoot = component7.logRoot;
					((Campfire)orAddComponent17).endSize = component7.endSize;
					((Campfire)orAddComponent17).endRot = component7.endRot;
					((Campfire)orAddComponent17).beenBurningFor = component7.beenBurningFor;
					((Campfire)orAddComponent17).fireParticles = component7.fireParticles;
					((Campfire)orAddComponent17).smokeParticlesOff = component7.smokeParticlesOff;
					((Campfire)orAddComponent17).smokeParticlesLit = component7.smokeParticlesLit;
					((Campfire)orAddComponent17).moraleBoostRadius = component7.moraleBoostRadius;
					((Campfire)orAddComponent17).moraleBoostBaseline = component7.moraleBoostBaseline;
					((Campfire)orAddComponent17).moraleBoostPerAdditionalScout = component7.moraleBoostPerAdditionalScout;
					((Campfire)orAddComponent17).injuryReduction = component7.injuryReduction;
					((Campfire)orAddComponent17).fireStart = component7.fireStart;
					((Campfire)orAddComponent17).extinguish = component7.extinguish;
					((Campfire)orAddComponent17).moraleBoost = component7.moraleBoost;
					((Campfire)orAddComponent17).loop = component7.loop;
					((Campfire)orAddComponent17).nameOverride = component7.nameOverride;
					((Campfire)orAddComponent17).currentlyCookingItem = component7.currentlyCookingItem;
					((Campfire)orAddComponent17).mainRenderer = component7.mainRenderer;
					((Campfire)orAddComponent17).startRot = component7.startRot;
					((Campfire)orAddComponent17).startSize = component7.startSize;
					((Campfire)orAddComponent17).fireHasStarted = component7.fireHasStarted;
					((Campfire)orAddComponent17).view = component7.view;
					((Campfire)orAddComponent17)._timebuffLastApplied = component7._timebuffLastApplied;
					((Campfire)orAddComponent17).disableFogFakeMountain = component7.disableFogFakeMountain;
					((Campfire)orAddComponent17)._charactersInRadius = component7._charactersInRadius;
					Object.Destroy((Object)(object)component7);
					go7 = RegisterOrGetNetworkPrefab(go7);
					component6.constructedPrefab = go7;
					return;
				}
				case 'f':
				{
					if (!(itemName == "Fortified Milk"))
					{
						return;
					}
					MeshFilter[] componentsInChildren7 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val30 in componentsInChildren7)
					{
						if (((Object)((Component)val30).gameObject).name == "Milk")
						{
							Mesh mesh = (val30.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedMilk.fbx"));
							val30.mesh = mesh;
						}
					}
					return;
				}
				case 'e':
					break;
				case ' ':
				{
					if (!(itemName == "Chain Launcher"))
					{
						return;
					}
					VineShooter orAddComponent13 = ExtGameObject.GetOrAddComponent<VineShooter>(((Component)it).gameObject);
					UnnamedVineShooter orAddComponent14 = ExtGameObject.GetOrAddComponent<UnnamedVineShooter>(((Component)it).gameObject);
					orAddComponent14.baseReach = orAddComponent13.maxLength;
					GameObject go5 = Object.Instantiate<GameObject>(orAddComponent13.vinePrefab);
					((Object)go5).name = "Unnamed" + ((Object)orAddComponent13.vinePrefab).name.Replace("Unnamed", "");
					Object.DontDestroyOnLoad((Object)(object)go5);
					CopyUnnamedMaterials(ref go5, peakBundle);
					Renderer[] componentsInChildren4 = ((Component)it).gameObject.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val19 in componentsInChildren4)
					{
						if (!(((Object)((Component)val19).gameObject).name == "Rope"))
						{
							continue;
						}
						Material[] materials = val19.materials;
						int m = 0;
						for (int num = materials.Length; m < num; m++)
						{
							string text = ((Object)materials[m]).name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
							if (text == "M_RopeSpike")
							{
								Material val20 = peakBundle.LoadAsset<Material>("M_UnnamedChainShooterChains.mat");
								val20.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val20.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
								materials[m] = val20;
							}
						}
						Renderer val21 = val19;
						Material[] array = materials;
						List<Material> list = new List<Material>(array.Length);
						Material[] array2 = array;
						foreach (Material item in array2)
						{
							list.Add(item);
						}
						val21.SetMaterials(list);
					}
					go5.SetActive(false);
					AudioSource orAddComponent15 = ExtGameObject.GetOrAddComponent<AudioSource>(go5);
					orAddComponent15.priority = 128;
					orAddComponent15.volume = 0.125f;
					orAddComponent15.pitch = 1f;
					orAddComponent15.reverbZoneMix = 1f;
					orAddComponent15.rolloffMode = (AudioRolloffMode)2;
					orAddComponent15.spatialBlend = 1f;
					orAddComponent15.dopplerLevel = 0.25f;
					orAddComponent15.maxDistance = 120f;
					orAddComponent15.minDistance = 39.1865f;
					orAddComponent15.SetCustomCurve((AudioSourceCurveType)0, new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0.0067737103f, 1f, -3.1092653f, -3.1092653f, 0f, 0.04103275f),
						new Keyframe(1f, 0f, 0.020448748f, 0.020448748f, 0.13781565f, 0f)
					}));
					orAddComponent15.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
					{
						new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
					}));
					orAddComponent15.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
					{
						new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
					}));
					orAddComponent15.SetCustomCurve((AudioSourceCurveType)3, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
					{
						new Keyframe(0f, 0f, 0f, 0f, 1f / 3f, 1f / 3f)
					}));
					orAddComponent15.SetCustomCurve((AudioSourceCurveType)2, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
					{
						new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
					}));
					orAddComponent15.loop = true;
					orAddComponent15.resource = peakBundle.LoadAsset<AudioResource>("Au_ChainLoop.ogg");
					orAddComponent15.playOnAwake = false;
					UnnamedVine orAddComponent16 = ExtGameObject.GetOrAddComponent<UnnamedVine>(go5);
					orAddComponent16.breakPoint = 0.4f;
					orAddComponent16.breakChance = 0.25f;
					orAddComponent16.axisMul = new Vector3(2f, 1f, 0f);
					orAddComponent16.shakeScale = 33f;
					orAddComponent16.fallTime = 3f;
					orAddComponent16.amount = 0.1f;
					orAddComponent16.startShakeDistance = 30.87f;
					orAddComponent16.startShakeAmount = 10f;
					orAddComponent16.climbingScreenShake = 5f;
					orAddComponent16.screenShakeTickTime = 0.2f;
					GameObject val22 = peakBundle.LoadAsset<GameObject>("VFX_ChainBreak.prefab");
					GameObject go6 = Object.Instantiate<GameObject>(val22, ((Component)orAddComponent16).transform, false);
					go6.transform.localPosition = Vector3.zero;
					go6.transform.localRotation = Quaternion.identity;
					go6.transform.localScale = Vector3.one;
					ShaderExtensions.ReplaceShaders(go6);
					CopyUnnamedMaterials(ref go6, peakBundle);
					orAddComponent16.breakParticles = ((Component)go6.transform.GetChild(0)).GetComponent<ParticleSystem>();
					orAddComponent16.breakSfx = (SFX_Instance[])(object)new SFX_Instance[2]
					{
						peakBundle.LoadAsset<SFX_Instance>("SFXI Break Coconut 1.asset"),
						peakBundle.LoadAsset<SFX_Instance>("SFXI Bridge Break 4.asset")
					};
					orAddComponent16.fullMesh = ((Component)orAddComponent16).transform.GetChild(0).GetChild(0);
					SFX_Instance[] sfxs = go5.GetComponent<SFX_PlayOneShot>().sfxs;
					foreach (SFX_Instance val23 in sfxs)
					{
						if (((Object)val23).name == "SFXI ChainLauncher 4")
						{
							orAddComponent16.breakSfx = CollectionExtensions.AddToArray<SFX_Instance>(orAddComponent16.breakSfx, val23);
						}
					}
					((VineShooter)orAddComponent14).disableOnFire = orAddComponent13.disableOnFire;
					((VineShooter)orAddComponent14).maxLength = orAddComponent13.maxLength;
					((VineShooter)orAddComponent14).actionReduceUses = orAddComponent13.actionReduceUses;
					Object.Destroy((Object)(object)orAddComponent13);
					go5 = RegisterOrGetNetworkPrefab(go5);
					((VineShooter)orAddComponent14).vinePrefab = go5;
					return;
				}
				default:
					return;
				}
				if (!(itemName == "Faerie Lantern"))
				{
					break;
				}
				goto IL_14d6;
			case 12:
				switch (itemName[6])
				{
				case 'e':
				{
					if (!(itemName == "Airline Food"))
					{
						break;
					}
					MeshFilter[] componentsInChildren = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val7 in componentsInChildren)
					{
						if (((Object)val7.mesh).name == "plastic")
						{
							val7.mesh = peakBundle.LoadAsset<Mesh>("UnnamedAirplaneFoodPackaging.fbx");
							((Component)val7).transform.localPosition = new Vector3(0f, 0f, 0.27986586f);
							((Component)val7).transform.localScale = ExtDataTypes.ToVec(3.436053f);
							((Component)val7).transform.localRotation = new Quaternion(-0.7071067f, 2.0861626E-07f, -1.1920929E-07f, -0.70710695f);
						}
					}
					break;
				}
				case 'C':
				{
					if (!(itemName == "Scout Cannon"))
					{
						break;
					}
					Constructable component2 = ((Component)it).GetComponent<Constructable>();
					MeshFilter[] componentsInChildren2 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val11 in componentsInChildren2)
					{
						if (((Object)((Component)val11).gameObject).name == "Rend")
						{
							Mesh mesh = (val11.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedCannon.fbx"));
							val11.mesh = mesh;
						}
					}
					GameObject go = Object.Instantiate<GameObject>(component2.constructedPrefab);
					((Object)go).name = "Unnamed" + ((Object)component2.constructedPrefab).name;
					MeshFilter[] componentsInChildren3 = go.GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val13 in componentsInChildren3)
					{
						if (((Object)((Component)val13).gameObject).name == "CannonFeet")
						{
							Mesh mesh = (val13.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedCannonFeets.fbx"));
							val13.mesh = mesh;
							((Component)val13).transform.localRotation = Quaternion.identity;
						}
						if (((Object)((Component)val13).gameObject).name == "Rend")
						{
							Mesh mesh = (val13.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedCannonBody.fbx"));
							val13.mesh = mesh;
						}
						if (((Object)((Component)val13).gameObject).name == "Rend2")
						{
							Mesh mesh = (val13.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedCannonInnerWall.fbx"));
							val13.mesh = mesh;
						}
					}
					Object.DontDestroyOnLoad((Object)(object)go);
					go.SetActive(false);
					CopyUnnamedMaterials(ref go, peakBundle);
					ScoutCannon component3 = go.GetComponent<ScoutCannon>();
					UnnamedScoutCannon orAddComponent8 = ExtGameObject.GetOrAddComponent<UnnamedScoutCannon>(go);
					((ScoutCannon)orAddComponent8).launchForce = component3.launchForce;
					((ScoutCannon)orAddComponent8).itemLaunchForce = component3.itemLaunchForce;
					((ScoutCannon)orAddComponent8).backpackLaunchForce = component3.backpackLaunchForce;
					((ScoutCannon)orAddComponent8).fallFor = component3.fallFor;
					((ScoutCannon)orAddComponent8).pullForce = component3.pullForce;
					((ScoutCannon)orAddComponent8).pushForce = component3.pushForce;
					((ScoutCannon)orAddComponent8).lit = component3.lit;
					((ScoutCannon)orAddComponent8).fireTime = component3.fireTime;
					((ScoutCannon)orAddComponent8).litParticle = component3.litParticle;
					((ScoutCannon)orAddComponent8).fireParticle = component3.fireParticle;
					((ScoutCannon)orAddComponent8).fireSFX = component3.fireSFX;
					((ScoutCannon)orAddComponent8).anim = component3.anim;
					((ScoutCannon)orAddComponent8).mpb = component3.mpb;
					((ScoutCannon)orAddComponent8).view = component3.view;
					((ScoutCannon)orAddComponent8).tube = component3.tube;
					((ScoutCannon)orAddComponent8).entry = component3.entry;
					((ScoutCannon)orAddComponent8).target = component3.target;
					((ScoutCannon)orAddComponent8).targetID = component3.targetID;
					((ScoutCannon)orAddComponent8).characters = component3.characters;
					((ScoutCannon)orAddComponent8)._mr = component3._mr;
					ScoutCannonFuse componentInChildren2 = go.GetComponentInChildren<ScoutCannonFuse>();
					GameObject go2 = ((Component)componentInChildren2).gameObject;
					CopyUnnamedMaterials(ref go2, peakBundle);
					componentInChildren2.scoutCannon = (ScoutCannon)(object)orAddComponent8;
					Object.Destroy((Object)(object)component3);
					go = RegisterOrGetNetworkPrefab(go);
					component2.constructedPrefab = go;
					break;
				}
				case 'l':
					if (itemName == "Big Lollipop")
					{
						GameObject val8 = peakBundle.LoadAsset<GameObject>("UnnamedPitonPackaging.prefab");
						GameObject val9 = Object.Instantiate<GameObject>(val8, ((Component)it.mainRenderer).transform.parent, false);
						val9.transform.localPosition = new Vector3(0f, 10.51f, -0.06f);
						val9.transform.localScale = ExtDataTypes.ToVec(18.1f);
						val9.transform.localRotation = new Quaternion(0f, 0.7071068f, 0f, 0.7071068f);
						Renderer val10 = default(Renderer);
						if (val9.TryGetComponent<Renderer>(ref val10))
						{
							val10.SetMaterials(new List<Material>(1) { peakBundle.LoadAsset<Material>("M_UnnamedLollypopWrapper.mat") });
						}
						it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val9.GetComponent<Renderer>());
					}
					break;
				case 'E':
					if (itemName == "Scout Effigy")
					{
						ScoutEffigy orAddComponent6 = ExtGameObject.GetOrAddComponent<ScoutEffigy>(((Component)it).gameObject);
						UnnamedScoutEffigy orAddComponent7 = ExtGameObject.GetOrAddComponent<UnnamedScoutEffigy>(((Component)it).gameObject);
						GameObject val5 = peakBundle.LoadAsset<GameObject>("UnnamedScoutEffigyPackaging.prefab");
						GameObject val6 = Object.Instantiate<GameObject>(val5, ((Component)it.mainRenderer).transform, false);
						val6.transform.localPosition = Vector3.zero;
						val6.transform.localScale = ExtDataTypes.ToVec(16.66667f);
						val6.transform.localRotation = new Quaternion(0.49991274f, 0.50008726f, 0.49991274f, 0.50008726f);
						it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val6.GetComponent<Renderer>());
						((Constructable)orAddComponent7).previewPrefab = ((Constructable)orAddComponent6).previewPrefab;
						((Constructable)orAddComponent7).constructedPrefab = ((Constructable)orAddComponent6).constructedPrefab;
						((Constructable)orAddComponent7).maxPreviewDistance = ((Constructable)orAddComponent6).maxPreviewDistance;
						((Constructable)orAddComponent7).maxConstructDistance = ((Constructable)orAddComponent6).maxConstructDistance;
						((Constructable)orAddComponent7).maxConstructVerticalAngle = ((Constructable)orAddComponent6).maxConstructVerticalAngle;
						((Constructable)orAddComponent7).angleToNormal = ((Constructable)orAddComponent6).angleToNormal;
						((Constructable)orAddComponent7).currentPreview = ((Constructable)orAddComponent6).currentPreview;
						((Constructable)orAddComponent7).angleOffset = ((Constructable)orAddComponent6).angleOffset;
						((Constructable)orAddComponent7).isAngleable = ((Constructable)orAddComponent6).isAngleable;
						((Constructable)orAddComponent7).currentConstructHit = ((Constructable)orAddComponent6).currentConstructHit;
						((Constructable)orAddComponent7).constructing = ((Constructable)orAddComponent6).constructing;
						((Constructable)orAddComponent7).valid = ((Constructable)orAddComponent6).valid;
						Object.Destroy((Object)(object)orAddComponent6);
					}
					break;
				}
				break;
			case 16:
				switch (itemName[0])
				{
				default:
					return;
				case 'P':
				{
					if (!(itemName == "Pirate's Compass"))
					{
						return;
					}
					MeshFilter[] componentsInChildren12 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val48 in componentsInChildren12)
					{
						if (((Object)((Component)val48).gameObject).name == "PirateHat")
						{
							val48.mesh = peakBundle.LoadAsset<Mesh>("UnnamedCompass.fbx");
						}
					}
					return;
				}
				case 'a':
					break;
				}
				if (!(itemName == "anti-rope cannon"))
				{
					break;
				}
				goto IL_1948;
			case 9:
				switch (itemName[0])
				{
				case 'T':
				{
					if (!(itemName == "Trail Mix"))
					{
						break;
					}
					MeshFilter[] componentsInChildren11 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val47 in componentsInChildren11)
					{
						if (((Object)((Component)val47).gameObject).name == "TrailMix")
						{
							val47.mesh = peakBundle.LoadAsset<Mesh>("UnnamedTrailMix.fbx");
							Renderer component9 = ((Component)val47).gameObject.GetComponent<Renderer>();
							component9.SetMaterials(new List<Material>(3)
							{
								component9.materials[0],
								peakBundle.LoadAsset<Material>("M_UnnamedTrailMixOpaque.mat"),
								component9.materials[1]
							});
						}
					}
					break;
				}
				case 'S':
				{
					Action_Spawn val45 = default(Action_Spawn);
					if (itemName == "Sunscreen" && ((Component)it).gameObject.TryGetComponent<Action_Spawn>(ref val45))
					{
						GameObject val46 = Object.Instantiate<GameObject>(val45.objectToSpawn);
						((Object)val46).name = "Unnamed" + ((Object)val45.objectToSpawn).name.Replace("Unnamed", "");
						AOE componentInChildren4 = val46.GetComponentInChildren<AOE>();
						if (componentInChildren4 != null && !IsUnnamed(((Component)componentInChildren4).gameObject))
						{
							RenameToUnnamed(((Component)componentInChildren4).gameObject);
						}
						val45.objectToSpawn = RegisterOrGetNetworkPrefab(val46);
						Object.DontDestroyOnLoad((Object)(object)val46);
						val46.SetActive(false);
					}
					break;
				}
				}
				break;
			case 5:
				switch (itemName[0])
				{
				case 'P':
				{
					if (!(itemName == "Piton"))
					{
						break;
					}
					GameObject val39 = peakBundle.LoadAsset<GameObject>("UnnamedPitonPackaging.prefab");
					GameObject val40 = Object.Instantiate<GameObject>(val39, ((Component)it.mainRenderer).transform, false);
					val40.transform.localPosition = Vector3.zero;
					val40.transform.localScale = ExtDataTypes.ToVec(15.85264f);
					val40.transform.localRotation = new Quaternion(0.5023786f, 0.4976101f, 0.49761012f, -0.5023785f);
					it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val40.GetComponent<Renderer>());
					ClimbingSpikeComponent orAddComponent24 = ExtGameObject.GetOrAddComponent<ClimbingSpikeComponent>(((Component)it).gameObject);
					UnnamedClimbingSpikeComponent orAddComponent25 = ExtGameObject.GetOrAddComponent<UnnamedClimbingSpikeComponent>(((Component)it).gameObject);
					GameObject go8 = peakBundle.LoadAsset<GameObject>("UnnamedClimbingSpikeHammered_Bad.prefab");
					GameObject go9 = peakBundle.LoadAsset<GameObject>("UnnamedClimbingSpikeHammered_Good.prefab");
					ShaderExtensions.ReplaceShaders(go8);
					ShaderExtensions.ReplaceShaders(go9);
					CopyUnnamedMaterials(ref go8, peakBundle);
					CopyUnnamedMaterials(ref go9, peakBundle);
					go8 = RegisterOrGetNetworkPrefab(go8);
					go9 = RegisterOrGetNetworkPrefab(go9);
					Renderer[] componentsInChildren9 = go8.gameObject.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val41 in componentsInChildren9)
					{
						Material[] materials2 = val41.materials;
						foreach (Material val42 in materials2)
						{
							val42.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val42.shader).name), "Shader.Find(material.shader.name)");
						}
					}
					Renderer[] componentsInChildren10 = go9.gameObject.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val43 in componentsInChildren10)
					{
						Material[] materials3 = val43.materials;
						foreach (Material val44 in materials3)
						{
							val44.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val44.shader).name), "Shader.Find(material.shader.name)");
						}
					}
					orAddComponent25.hammeredBadVersionPrefab = go8;
					orAddComponent25.hammeredGoodVersionPrefab = go9;
					((ClimbingSpikeComponent)orAddComponent25).hammeredVersionPrefab = orAddComponent24.hammeredVersionPrefab;
					((ClimbingSpikeComponent)orAddComponent25).climbingSpikeStartDistance = orAddComponent24.climbingSpikeStartDistance;
					((ClimbingSpikeComponent)orAddComponent25).climbingSpikePreviewPrefab = orAddComponent24.climbingSpikePreviewPrefab;
					((ClimbingSpikeComponent)orAddComponent25).climbingSpikePreviewDisableDistance = orAddComponent24.climbingSpikePreviewDisableDistance;
					((ClimbingSpikeComponent)orAddComponent25).climbingSpikeStartDistanceGrounded = orAddComponent24.climbingSpikeStartDistanceGrounded;
					((ClimbingSpikeComponent)orAddComponent25).climbingSpikePreviewDisableDistanceGrounded = orAddComponent24.climbingSpikePreviewDisableDistanceGrounded;
					Object.Destroy((Object)(object)orAddComponent24);
					break;
				}
				case 'F':
					if (itemName == "Flare")
					{
						Flare orAddComponent22 = ExtGameObject.GetOrAddComponent<Flare>(((Component)it).gameObject);
						UnnamedFlare orAddComponent23 = ExtGameObject.GetOrAddComponent<UnnamedFlare>(((Component)it).gameObject);
						((Flare)orAddComponent23).trackable = orAddComponent22.trackable;
						((Flare)orAddComponent23).flareVFXPrefab = orAddComponent22.flareVFXPrefab;
						((Flare)orAddComponent23).flareColor = orAddComponent22.flareColor;
						Object.Destroy((Object)(object)orAddComponent22);
						Action_Flare component8 = ((Component)it).gameObject.GetComponent<Action_Flare>();
						component8.flare = (Flare)(object)orAddComponent23;
					}
					break;
				}
				break;
			case 8:
				switch (itemName[0])
				{
				case 'D':
					if (itemName == "Dynamite")
					{
						Dynamite orAddComponent20 = ExtGameObject.GetOrAddComponent<Dynamite>(((Component)it).gameObject);
						UnnamedDynamite orAddComponent21 = ExtGameObject.GetOrAddComponent<UnnamedDynamite>(((Component)it).gameObject);
						orAddComponent21.baseFuseTime = orAddComponent20.startingFuseTime;
						((Dynamite)orAddComponent21)._hasExploded = orAddComponent20._hasExploded;
						((Dynamite)orAddComponent21).trackable = orAddComponent20.trackable;
						((Dynamite)orAddComponent21).smokeVFXPrefab = orAddComponent20.smokeVFXPrefab;
						((Dynamite)orAddComponent21).explosionPrefab = orAddComponent20.explosionPrefab;
						((Dynamite)orAddComponent21).startingFuseTime = orAddComponent20.startingFuseTime;
						((Dynamite)orAddComponent21).lightFuseRadius = orAddComponent20.lightFuseRadius;
						((Dynamite)orAddComponent21).fuseTime = orAddComponent20.fuseTime;
						((Dynamite)orAddComponent21).sparks = orAddComponent20.sparks;
						((Dynamite)orAddComponent21).sparksPhotosensitive = orAddComponent20.sparksPhotosensitive;
						((Dynamite)orAddComponent21).setting = orAddComponent20.setting;
						((Dynamite)orAddComponent21).DEBUG_PauseOnExplode = orAddComponent20.DEBUG_PauseOnExplode;
						Object.Destroy((Object)(object)orAddComponent20);
						if (Object.op_Implicit((Object)(object)((Dynamite)orAddComponent21).explosionPrefab))
						{
							GameObject val36 = Object.Instantiate<GameObject>(((Dynamite)orAddComponent21).explosionPrefab);
							((Object)val36).name = "Unnamed" + ((Object)((Dynamite)orAddComponent21).explosionPrefab).name.Replace("Unnamed", "");
							val36 = RegisterOrGetNetworkPrefab(val36);
							Object.DontDestroyOnLoad((Object)(object)val36);
							val36.SetActive(false);
							((Dynamite)orAddComponent21).explosionPrefab = val36;
						}
					}
					break;
				case 'B':
					if (itemName == "Bandages")
					{
						GameObject val37 = peakBundle.LoadAsset<GameObject>("UnnamedBandageWrapping.prefab");
						GameObject val38 = Object.Instantiate<GameObject>(val37, ((Component)it.mainRenderer).transform, false);
						val38.transform.localPosition = Vector3.zero;
						val38.transform.localScale = ExtDataTypes.ToVec(6.181997f);
						val38.transform.localRotation = new Quaternion(0.7071068f, 0f, 0f, 0.7071068f);
						it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val38.GetComponent<Renderer>());
					}
					break;
				case 'C':
					if (itemName == "Cure-All")
					{
						GameObject val34 = peakBundle.LoadAsset<GameObject>("UnnamedCureAllLabel.prefab");
						GameObject val35 = Object.Instantiate<GameObject>(val34, ((Component)it.mainRenderer).transform, false);
						val35.transform.localPosition = new Vector3(4.4668468E-05f, 0f, 0f);
						val35.transform.localScale = ExtDataTypes.ToVec(6.216943f);
						val35.transform.localRotation = new Quaternion(0.54746115f, -0.44753358f, -0.44753358f, 0.54746115f);
						it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val35.GetComponent<Renderer>());
					}
					break;
				}
				break;
			case 11:
				switch (itemName[0])
				{
				default:
					return;
				case 'R':
				{
					if (!(itemName == "Rescue Claw"))
					{
						return;
					}
					RescueHook orAddComponent18 = ExtGameObject.GetOrAddComponent<RescueHook>(((Component)it).gameObject);
					UnnamedRescueHook orAddComponent19 = ExtGameObject.GetOrAddComponent<UnnamedRescueHook>(((Component)it).gameObject);
					MeshFilter[] componentsInChildren8 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
					foreach (MeshFilter val32 in componentsInChildren8)
					{
						if (((Object)((Component)val32).gameObject).name == "RescueClawBody")
						{
							Mesh mesh = (val32.sharedMesh = peakBundle.LoadAsset<Mesh>("UnnamedRescueClaw.fbx"));
							val32.mesh = mesh;
						}
					}
					((RescueHook)orAddComponent19).dragPoint = orAddComponent18.dragPoint;
					((RescueHook)orAddComponent19).claw = orAddComponent18.claw;
					((RescueHook)orAddComponent19).clawButt = orAddComponent18.clawButt;
					((RescueHook)orAddComponent19).maxLength = orAddComponent18.maxLength;
					((RescueHook)orAddComponent19).dragForce = orAddComponent18.dragForce;
					((RescueHook)orAddComponent19).liftDragForce = orAddComponent18.liftDragForce;
					((RescueHook)orAddComponent19).extraDragSelf = orAddComponent18.extraDragSelf;
					((RescueHook)orAddComponent19).extraDragOther = orAddComponent18.extraDragOther;
					((RescueHook)orAddComponent19).launchForce = orAddComponent18.launchForce;
					((RescueHook)orAddComponent19).liftForce = orAddComponent18.liftForce;
					((RescueHook)orAddComponent19).actionReduceUses = orAddComponent18.actionReduceUses;
					((RescueHook)orAddComponent19).camera = orAddComponent18.camera;
					((RescueHook)orAddComponent19).currentDistance = orAddComponent18.currentDistance;
					((RescueHook)orAddComponent19).fly = orAddComponent18.fly;
					((RescueHook)orAddComponent19).hitNothing = orAddComponent18.hitNothing;
					((RescueHook)orAddComponent19).isPulling = orAddComponent18.isPulling;
					((RescueHook)orAddComponent19).sinceFire = orAddComponent18.sinceFire;
					((RescueHook)orAddComponent19).targetPlayer = orAddComponent18.targetPlayer;
					((RescueHook)orAddComponent19).targetPos = orAddComponent18.targetPos;
					((RescueHook)orAddComponent19).startingPos = orAddComponent18.startingPos;
					((RescueHook)orAddComponent19).rescuedCharacterStartingPos = orAddComponent18.rescuedCharacterStartingPos;
					((RescueHook)orAddComponent19).threwAchievement = orAddComponent18.threwAchievement;
					((RescueHook)orAddComponent19).targetRig = orAddComponent18.targetRig;
					((RescueHook)orAddComponent19).ropeRender = orAddComponent18.ropeRender;
					((RescueHook)orAddComponent19).line = orAddComponent18.line;
					((RescueHook)orAddComponent19).startingClawLocalPos = orAddComponent18.startingClawLocalPos;
					((RescueHook)orAddComponent19).maxWallHookTime = orAddComponent18.maxWallHookTime;
					((RescueHook)orAddComponent19).maxScoutHookTime = orAddComponent18.maxScoutHookTime;
					((RescueHook)orAddComponent19).maxLiftDistance = orAddComponent18.maxLiftDistance;
					((RescueHook)orAddComponent19).stopPullDistance = orAddComponent18.stopPullDistance;
					((RescueHook)orAddComponent19).stopPullFriendDistance = orAddComponent18.stopPullFriendDistance;
					((RescueHook)orAddComponent19).minRaycastDistance = orAddComponent18.minRaycastDistance;
					((RescueHook)orAddComponent19).rescueShot = orAddComponent18.rescueShot;
					((RescueHook)orAddComponent19).rescueHit = orAddComponent18.rescueHit;
					((RescueHook)orAddComponent19).pulLStrengthCurve = orAddComponent18.pulLStrengthCurve;
					((RescueHook)orAddComponent19).firePoint = orAddComponent18.firePoint;
					((RescueHook)orAddComponent19).range = orAddComponent18.range;
					((RescueHook)orAddComponent19).rangeDownward = orAddComponent18.rangeDownward;
					((RescueHook)orAddComponent19).curRange = orAddComponent18.curRange;
					((RescueHook)orAddComponent19).afterLetGoDragSeconds = orAddComponent18.afterLetGoDragSeconds;
					((RescueHook)orAddComponent19).afterLetGoDragTime = orAddComponent18.afterLetGoDragTime;
					((RescueHook)orAddComponent19).selfFallSeconds = orAddComponent18.selfFallSeconds;
					Object.Destroy((Object)(object)orAddComponent18);
					return;
				}
				case 'r':
					break;
				}
				if (!(itemName == "rope cannon"))
				{
					break;
				}
				goto IL_1948;
			case 13:
				if (itemName == "First Aid Kit")
				{
					GameObject val17 = peakBundle.LoadAsset<GameObject>("UnnamedFirstAidKitPackaging.prefab");
					GameObject val18 = Object.Instantiate<GameObject>(val17, ((Component)it.mainRenderer).transform, false);
					val18.transform.localPosition = Vector3.zero;
					val18.transform.localScale = ExtDataTypes.ToVec(3.348572f);
					val18.transform.localRotation = new Quaternion(0.7071068f, 0f, 0f, 0.7071068f);
					it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val18.GetComponent<Renderer>());
				}
				break;
			case 10:
				if (!(itemName == "rope spool"))
				{
					break;
				}
				goto IL_1de8;
			case 15:
				if (!(itemName == "anti-rope spool"))
				{
					break;
				}
				goto IL_1de8;
			case 6:
				break;
				IL_1de8:
				orAddComponent = ExtGameObject.GetOrAddComponent<RopeSpool>(((Component)it).gameObject);
				orAddComponent2 = ExtGameObject.GetOrAddComponent<UnnamedRopeSpool>(((Component)it).gameObject);
				orAddComponent2.baseStartFuel = orAddComponent.ropeStartFuel;
				val = peakBundle.LoadAsset<GameObject>("UnnamedRopeWrapper.prefab");
				val2 = Object.Instantiate<GameObject>(val, ((Component)it.mainRenderer).transform, false);
				val2.transform.localPosition = Vector3.zero;
				val2.transform.localRotation = new Quaternion(-0.28808928f, 0.6457595f, 0.28809026f, 0.645758f);
				val2.transform.localScale = new Vector3(0.080336176f, 0.08033618f, 0.080336176f);
				if (it.UIData.itemName == "anti-rope spool")
				{
					val2.GetComponent<Renderer>().material = peakBundle.LoadAsset<Material>("M_UnnamedAnttiRopeWrapper.mat");
				}
				it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val2.GetComponent<Renderer>());
				orAddComponent3 = ExtGameObject.GetOrAddComponent<RopeTier>(((Component)it).gameObject);
				val3 = Object.Instantiate<GameObject>(orAddComponent3.anchorPrefab);
				((Object)val3).name = "Unnamed" + ((Object)orAddComponent3.anchorPrefab).name.Replace("Unnamed", "");
				val3 = RegisterOrGetNetworkPrefab(val3);
				Object.DontDestroyOnLoad((Object)(object)val3);
				CopyUnnamedMaterials(ref val3, peakBundle);
				val3.SetActive(false);
				orAddComponent3.anchorPrefab = val3;
				val4 = Object.Instantiate<GameObject>(orAddComponent.ropePrefab);
				((Object)val4).name = "Unnamed" + ((Object)orAddComponent.ropePrefab).name.Replace("Unnamed", "");
				val4 = RegisterOrGetNetworkPrefab(val4);
				component = val4.GetComponent<RopeBoneVisualizer>();
				component.ropeMaterial = GetUnnamedMaterial(component.ropeMaterial, peakBundle);
				Object.DontDestroyOnLoad((Object)(object)val4);
				CopyUnnamedMaterials(ref val4, peakBundle);
				val4.SetActive(false);
				orAddComponent4 = ExtGameObject.GetOrAddComponent<AudioSource>(val4);
				orAddComponent4.priority = 128;
				orAddComponent4.volume = 0.125f;
				orAddComponent4.pitch = 1f;
				orAddComponent4.reverbZoneMix = 1f;
				orAddComponent4.rolloffMode = (AudioRolloffMode)2;
				orAddComponent4.spatialBlend = 1f;
				orAddComponent4.dopplerLevel = 0.25f;
				orAddComponent4.maxDistance = 120f;
				orAddComponent4.minDistance = 39.1865f;
				orAddComponent4.SetCustomCurve((AudioSourceCurveType)0, new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0.0067737103f, 1f, -3.1092653f, -3.1092653f, 0f, 0.04103275f),
					new Keyframe(1f, 0f, 0.020448748f, 0.020448748f, 0.13781565f, 0f)
				}));
				orAddComponent4.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent4.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent4.SetCustomCurve((AudioSourceCurveType)3, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 0f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent4.SetCustomCurve((AudioSourceCurveType)2, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent4.resource = peakBundle.LoadAsset<AudioResource>("Au_RopeLoop.ogg");
				orAddComponent4.playOnAwake = false;
				orAddComponent5 = ExtGameObject.GetOrAddComponent<UnnamedRopeBreaker>(val4);
				orAddComponent5.startBreakSfx = peakBundle.LoadAsset<SFX_Instance>("SFXI Climb Rope Grab 1.asset");
				orAddComponent5.breakSfx = (SFX_Instance[])(object)new SFX_Instance[4]
				{
					peakBundle.LoadAsset<SFX_Instance>("SFXI Break Coconut 1.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI Bridge Break 4.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI Climb Rope Grab 1.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI RopeShooter 2.asset")
				};
				orAddComponent5.breakChance = 0.25f;
				orAddComponent5.axisMul = new Vector3(2f, 1f, 0f);
				orAddComponent5.shakeScale = 33f;
				orAddComponent5.fallTime = 3f;
				orAddComponent5.amount = 0.1f;
				orAddComponent5.startShakeDistance = 30.87f;
				orAddComponent5.startShakeAmount = 10f;
				orAddComponent5.climbingScreenShake = 5f;
				orAddComponent5.screenShakeTickTime = 0.2f;
				((RopeSpool)orAddComponent2).segments = orAddComponent.segments;
				((RopeSpool)orAddComponent2).minSegments = orAddComponent.minSegments;
				((RopeSpool)orAddComponent2).ropeStartFuel = orAddComponent.ropeStartFuel;
				((RopeSpool)orAddComponent2).ropeFuel = orAddComponent.ropeFuel;
				((RopeSpool)orAddComponent2).ropeBase = orAddComponent.ropeBase;
				((RopeSpool)orAddComponent2).ropeStart = orAddComponent.ropeStart;
				((RopeSpool)orAddComponent2).ropeSpoolTf = orAddComponent.ropeSpoolTf;
				((RopeSpool)orAddComponent2).ropeInstance = orAddComponent.ropeInstance;
				((RopeSpool)orAddComponent2).rig = orAddComponent.rig;
				((RopeSpool)orAddComponent2).rope = orAddComponent.rope;
				((RopeSpool)orAddComponent2).scroll = orAddComponent.scroll;
				((RopeSpool)orAddComponent2).segsVel = orAddComponent.segsVel;
				((RopeSpool)orAddComponent2).ropeTier = orAddComponent.ropeTier;
				((RopeSpool)orAddComponent2).isAntiRope = orAddComponent.isAntiRope;
				((RopeSpool)orAddComponent2).ropePrefab = val4;
				Object.Destroy((Object)(object)orAddComponent);
				componentInChildren = ((Component)it).gameObject.GetComponentInChildren<RopeAudio>();
				componentInChildren.ropeSpool = (RopeSpool)(object)orAddComponent2;
				break;
				IL_1948:
				orAddComponent9 = ExtGameObject.GetOrAddComponent<RopeShooter>(((Component)it).gameObject);
				orAddComponent10 = ExtGameObject.GetOrAddComponent<UnnamedRopeShooter>(((Component)it).gameObject);
				orAddComponent10.baseShooterLength = orAddComponent9.length;
				orAddComponent10.baseReach = orAddComponent9.maxLength;
				go3 = Object.Instantiate<GameObject>(orAddComponent9.ropeAnchorWithRopePref);
				((Object)go3).name = "Unnamed" + ((Object)orAddComponent9.ropeAnchorWithRopePref).name.Replace("Unnamed", "") + "_c";
				Object.DontDestroyOnLoad((Object)(object)go3);
				CopyUnnamedMaterials(ref go3, peakBundle);
				go3.SetActive(false);
				component4 = go3.GetComponent<RopeAnchorWithRope>();
				go4 = Object.Instantiate<GameObject>(component4.ropePrefab);
				((Object)go4).name = "Unnamed" + ((Object)component4.ropePrefab).name.Replace("Unnamed", "") + "_c";
				Object.DontDestroyOnLoad((Object)(object)go4);
				CopyUnnamedMaterials(ref go4, peakBundle);
				component5 = go4.GetComponent<RopeBoneVisualizer>();
				component5.ropeMaterial = GetUnnamedMaterial(component5.ropeMaterial, peakBundle);
				go4.SetActive(false);
				orAddComponent11 = ExtGameObject.GetOrAddComponent<AudioSource>(go4);
				orAddComponent11.priority = 128;
				orAddComponent11.volume = 0.125f;
				orAddComponent11.pitch = 1f;
				orAddComponent11.reverbZoneMix = 1f;
				orAddComponent11.rolloffMode = (AudioRolloffMode)2;
				orAddComponent11.spatialBlend = 1f;
				orAddComponent11.dopplerLevel = 0.25f;
				orAddComponent11.maxDistance = 120f;
				orAddComponent11.minDistance = 39.1865f;
				orAddComponent11.SetCustomCurve((AudioSourceCurveType)0, new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0.0067737103f, 1f, -3.1092653f, -3.1092653f, 0f, 0.04103275f),
					new Keyframe(1f, 0f, 0.020448748f, 0.020448748f, 0.13781565f, 0f)
				}));
				orAddComponent11.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent11.SetCustomCurve((AudioSourceCurveType)1, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent11.SetCustomCurve((AudioSourceCurveType)3, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 0f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent11.SetCustomCurve((AudioSourceCurveType)2, new AnimationCurve((Keyframe[])(object)new Keyframe[1]
				{
					new Keyframe(0f, 1f, 0f, 0f, 1f / 3f, 1f / 3f)
				}));
				orAddComponent11.loop = true;
				orAddComponent11.resource = peakBundle.LoadAsset<AudioResource>("Au_RopeLoop.ogg");
				orAddComponent11.playOnAwake = false;
				orAddComponent12 = ExtGameObject.GetOrAddComponent<UnnamedRopeBreaker>(go4);
				orAddComponent12.startBreakSfx = peakBundle.LoadAsset<SFX_Instance>("SFXI Climb Rope Grab 1.asset");
				orAddComponent12.breakSfx = (SFX_Instance[])(object)new SFX_Instance[4]
				{
					peakBundle.LoadAsset<SFX_Instance>("SFXI Break Coconut 1.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI Bridge Break 4.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI Climb Rope Grab 1.asset"),
					peakBundle.LoadAsset<SFX_Instance>("SFXI RopeShooter 2.asset")
				};
				orAddComponent12.breakChance = 0.25f;
				orAddComponent12.axisMul = new Vector3(2f, 1f, 0f);
				orAddComponent12.shakeScale = 33f;
				orAddComponent12.fallTime = 3f;
				orAddComponent12.amount = 0.1f;
				orAddComponent12.startShakeDistance = 30.87f;
				orAddComponent12.startShakeAmount = 10f;
				orAddComponent12.climbingScreenShake = 5f;
				orAddComponent12.screenShakeTickTime = 0.2f;
				component4.ropePrefab = RegisterOrGetNetworkPrefab(go4);
				((RopeShooter)orAddComponent10).ropeAnchorWithRopePref = RegisterOrGetNetworkPrefab(go3);
				((RopeShooter)orAddComponent10).gunshotVFX = orAddComponent9.gunshotVFX;
				((RopeShooter)orAddComponent10).fumesVFX = orAddComponent9.fumesVFX;
				((RopeShooter)orAddComponent10).cantReFire = orAddComponent9.cantReFire;
				((RopeShooter)orAddComponent10).spawnPoint = orAddComponent9.spawnPoint;
				((RopeShooter)orAddComponent10).length = orAddComponent9.length;
				((RopeShooter)orAddComponent10).hideOnFire = orAddComponent9.hideOnFire;
				((RopeShooter)orAddComponent10).screenshakeIntensity = orAddComponent9.screenshakeIntensity;
				((RopeShooter)orAddComponent10).startAmmo = orAddComponent9.startAmmo;
				((RopeShooter)orAddComponent10).shotSound = orAddComponent9.shotSound;
				((RopeShooter)orAddComponent10).emptySound = orAddComponent9.emptySound;
				((RopeShooter)orAddComponent10).maxLength = orAddComponent9.maxLength;
				Object.Destroy((Object)(object)orAddComponent9);
				break;
				IL_14d6:
				componentInChildren3 = ((Component)it).gameObject.GetComponentInChildren<StatusField>(true);
				if (componentInChildren3 != null)
				{
					UnnamedStatusField unnamedStatusField = ((Component)componentInChildren3).gameObject.AddComponent<UnnamedStatusField>();
					((StatusField)unnamedStatusField).statusType = componentInChildren3.statusType;
					((StatusField)unnamedStatusField).statusAmountPerSecond = componentInChildren3.statusAmountPerSecond;
					((StatusField)unnamedStatusField).statusAmountOnEntry = componentInChildren3.statusAmountOnEntry;
					((StatusField)unnamedStatusField).radius = componentInChildren3.radius;
					((StatusField)unnamedStatusField).lastEnteredTime = componentInChildren3.lastEnteredTime;
					((StatusField)unnamedStatusField).entryCooldown = componentInChildren3.entryCooldown;
					((StatusField)unnamedStatusField).doNotApplyIfStatusesMaxed = componentInChildren3.doNotApplyIfStatusesMaxed;
					((StatusField)unnamedStatusField).additionalStatuses = componentInChildren3.additionalStatuses;
					((StatusField)unnamedStatusField).inflicting = componentInChildren3.inflicting;
					Object.Destroy((Object)(object)componentInChildren3);
				}
				break;
			}
		}

		private Material GetUnnamedPlaneMaterial(Material vanillaMaterial, bool isWings = false)
		{
			string name = ((Object)vanillaMaterial).name;
			string text = name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
			string text2 = text.Replace("m_", "M_").Replace("M_", "M_Unnamed").Trim() ?? "";
			if (CustomStartsWith(text, "M_Unnamed"))
			{
				vanillaMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)vanillaMaterial.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return vanillaMaterial;
			}
			if ((isWings && text2 == "Plane") || text2 == "Plane-snow")
			{
				return PlaneMaterials[text2.Replace("Plane", "PlaneWings")];
			}
			return PlaneMaterials.GetValueOrDefault(text2, vanillaMaterial);
		}

		private Material GetUnnamedMaterial(Material vanillaMaterial, PeakBundle peakBundle)
		{
			string name = ((Object)vanillaMaterial).name;
			string text = name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
			string text2 = text.Replace("m_", "M_").Replace("M_", "M_Unnamed").Trim() + ".mat";
			if (CustomStartsWith(text, "M_Unnamed"))
			{
				vanillaMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)vanillaMaterial.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return vanillaMaterial;
			}
			switch (text)
			{
			case "LanternGlass":
			{
				Material val10 = peakBundle.LoadAsset<Material>("M_UnnamedLanternGlass.mat");
				val10.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val10.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val10;
			}
			case "Blowgun":
			{
				Material val9 = peakBundle.LoadAsset<Material>("M_UnnamedBlowgun.mat");
				val9.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val9.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val9;
			}
			case "Jug Glass":
			{
				Material val8 = peakBundle.LoadAsset<Material>("M_UnnamedJug Glass.mat");
				val8.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val8.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val8;
			}
			case "GlassBrown":
			{
				Material val7 = peakBundle.LoadAsset<Material>("M_UnnamedGlassBrown.mat");
				val7.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val7.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val7;
			}
			case "Glass-purple liquid":
			{
				Material val6 = peakBundle.LoadAsset<Material>("M_UnnamedGlass-purple liquid.mat");
				val6.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val6.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val6;
			}
			case "bean_can":
			{
				Material val5 = peakBundle.LoadAsset<Material>("M_Unnamedbean_can.mat");
				val5.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val5.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val5;
			}
			case "chailk_sack":
			{
				Material val4 = peakBundle.LoadAsset<Material>("M_Unnamedchailk_sack.mat");
				val4.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val4.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val4;
			}
			case "Material.001":
			case "Material.002":
			{
				Material val3 = peakBundle.LoadAsset<Material>("M_Unnamedchailk_sack.mat");
				val3.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val3.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val3;
			}
			case "RescueClawGlow":
			{
				Material val2 = peakBundle.LoadAsset<Material>("M_UnnamedRescueClawGlow.mat");
				val2.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val2.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val2;
			}
			default:
			{
				Material val = peakBundle.LoadAsset<Material>(text2);
				val.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)val.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return val;
			}
			}
		}

		public void CopyUnnamedMaterials(ref GameObject go, PeakBundle peakBundle)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				Material[] materials = val.materials;
				int j = 0;
				for (int num = materials.Length; j < num; j++)
				{
					Material val2 = materials[j];
					string name = ((Object)val2).name;
					string text = name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
					string text2 = text.Replace("m_", "M_").Replace("M_", "M_Unnamed").Trim() + ".mat";
					try
					{
						materials[j] = GetUnnamedMaterial(materials[j], peakBundle);
					}
					catch (Exception ex)
					{
						if (peakBundle.Contains(text2))
						{
							Log.LogWarning((object)ex.Message);
						}
					}
				}
				Renderer val3 = val;
				Material[] array = materials;
				List<Material> list = new List<Material>(array.Length);
				Material[] array2 = array;
				foreach (Material item in array2)
				{
					list.Add(item);
				}
				val3.SetMaterials(list);
			}
		}

		public void CopyUnnamedIcons(ref Item it, PeakBundle peakBundle)
		{
			string text = "Unnamed " + ((Object)it.UIData.icon).name + ".png";
			if (peakBundle.Contains(text))
			{
				try
				{
					Texture2D icon = peakBundle.LoadAsset<Texture2D>(text);
					it.UIData.icon = icon;
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)ex.Message);
				}
			}
		}

		public GameObject GenerateInstancedVariant(GameObject variant, string nameToUse)
		{
			Item val = default(Item);
			Item val2 = default(Item);
			if (variant.TryGetComponent<Item>(ref val) && ItemDatabase.TryGetItem(val.itemID, ref val2))
			{
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
				((Object)val3).name = "Unnamed" + nameToUse.Replace("Unnamed", "");
				Object.DontDestroyOnLoad((Object)(object)val3);
				val3.SetActive(false);
				return val3;
			}
			return variant;
		}

		public GameObject GenerateInstancedVariantById(ushort id)
		{
			Item val = default(Item);
			if (ItemDatabase.TryGetItem(id, ref val))
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject);
				((Object)val2).name = "Unnamed" + ((Object)val).name.Replace("Unnamed", "");
				Object.DontDestroyOnLoad((Object)(object)val2);
				val2.SetActive(false);
				return val2;
			}
			throw new NullReferenceException($"Item {id} not found in database!");
		}

		public static GameObject GetUnnamedVariant(Item item)
		{
			if (UnnamedDatabase.TryGetValue(item.UIData.itemName, out GameObject value))
			{
				return value;
			}
			return ((Component)item).gameObject;
		}

		public static bool HasUnnamedVariant(Item item)
		{
			return UnnamedDatabase.ContainsKey(item.UIData.itemName);
		}

		private void OnEnable()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDisable()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		public static bool CustomStartsWith(string a, string b)
		{
			int length = a.Length;
			int length2 = b.Length;
			int num = 0;
			int num2 = 0;
			while (num < length && num2 < length2 && a[num] == b[num2])
			{
				num++;
				num2++;
			}
			return num2 == length2;
		}

		public static bool IsUnnamed(GameObject go)
		{
			return CustomStartsWith(((Object)go).name, _unnamedPrefix);
		}

		public static bool IsUnnamedUnique(GameObject go)
		{
			string item = ((Object)go).name.Replace(_modInfoPrefix, "").Replace("(Clone)", "").Replace("(Instance)", "")
				.Trim();
			return UnnamedUniques.Contains(item);
		}

		public static float RandomModifier(float baseMod = 0.5f)
		{
			return Random.Range(1f - baseMod, 1f + baseMod);
		}

		public static bool IsUnnamedLucky(float baseMod = 0.5f)
		{
			return Random.value < 0.5f;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			if (((Scene)(ref scene)).name.Equals("Airport"))
			{
				Object.Instantiate<GameObject>(UnnamedKioskSetup);
			}
			else
			{
				if (!((Scene)(ref scene)).name.StartsWith("Level_") && !((Scene)(ref scene)).name.Equals("WilIsland"))
				{
					return;
				}
				Log.LogInfo((object)"GENERATING LEVEL SEEDS!!!");
				GenerateSeedStates(((Component)Singleton<MapHandler>.Instance).gameObject.GetComponent<LevelGeneration>());
				State state = Random.state;
				MapSegment[] segments = Singleton<MapHandler>.Instance.segments;
				Item item2 = default(Item);
				Dynamite val12 = default(Dynamite);
				foreach (MapSegment val in segments)
				{
					Random.state = BiomeSeeds[val._biome];
					Transform parent = val._segmentParent.transform.parent.parent;
					if ((int)val._biome == 0 && ShouldBeUnnamed)
					{
						Transform val2 = val.segmentParent.transform.Find("crashed plane");
						Transform val3 = ((Component)val2).transform.Find("Back Half");
						Transform val4 = ((Component)val2).transform.Find("front half");
						Transform val5 = ((Component)val2).transform.Find("Wings.003");
						Object.Instantiate<GameObject>(UnnamedBrokenStandeeSetup, val3);
						Renderer[] array = CollectionExtensions.AddRangeToArray<Renderer>(CollectionExtensions.AddRangeToArray<Renderer>(((Component)val3).GetComponentsInChildren<Renderer>(true), ((Component)val4).GetComponentsInChildren<Renderer>(true)), ((Component)val5).GetComponentsInChildren<Renderer>(true));
						Renderer[] array2 = array;
						foreach (Renderer val6 in array2)
						{
							bool isWings = ((Object)((Component)val6).gameObject).name.StartsWith("Tail") || ((Object)((Component)val6).gameObject).name.StartsWith("Wings");
							Material[] materials = val6.materials;
							int k = 0;
							for (int num = materials.Length; k < num; k++)
							{
								Material val7 = materials[k];
								string name = ((Object)val7).name;
								string key = name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
								try
								{
									materials[k] = GetUnnamedPlaneMaterial(materials[k], isWings);
								}
								catch (Exception ex)
								{
									if (PlaneMaterials.ContainsKey(key))
									{
										Log.LogWarning((object)ex.Message);
									}
								}
							}
							Renderer val8 = val6;
							Material[] array3 = materials;
							List<Material> list = new List<Material>(array3.Length);
							Material[] array4 = array3;
							foreach (Material item in array4)
							{
								list.Add(item);
							}
							val8.SetMaterials(list);
						}
						SingleItemSpawner[] componentsInChildren = ((Component)val2).GetComponentsInChildren<SingleItemSpawner>(true);
						SingleItemSpawner[] array5 = componentsInChildren;
						foreach (SingleItemSpawner val9 in array5)
						{
							if (val9.prefab.gameObject.TryGetComponent<Item>(ref item2) && HasUnnamedVariant(item2))
							{
								RenameToUnnamed(((Component)val9).gameObject);
								val9.prefab = GetUnnamedVariant(val9.prefab.GetComponent<Item>());
							}
						}
					}
					Luggage[] componentsInChildren2 = ((Component)parent).GetComponentsInChildren<Luggage>(true);
					Luggage[] array6 = componentsInChildren2;
					foreach (Luggage val10 in array6)
					{
						LuggageBrandHandler orAddComponent = ExtGameObject.GetOrAddComponent<LuggageBrandHandler>(((Component)val10).gameObject);
						orAddComponent.luggage = val10;
						if (ShouldBeUnnamed)
						{
							orAddComponent.shouldBeUnnamed = true;
							if (((Component)val10).gameObject.activeInHierarchy)
							{
								orAddComponent.RPC_SetLuggageAsUnnamed(hardSet: true);
							}
						}
					}
					MirageLuggage[] componentsInChildren3 = ((Component)parent).GetComponentsInChildren<MirageLuggage>(true);
					MirageLuggage[] array7 = componentsInChildren3;
					foreach (MirageLuggage mirageAsUnnamed in array7)
					{
						if (ShouldBeUnnamed)
						{
							SetMirageAsUnnamed(mirageAsUnnamed);
						}
					}
					SingleItemSpawner[] componentsInChildren4 = ((Component)parent).GetComponentsInChildren<SingleItemSpawner>(true);
					SingleItemSpawner[] array8 = componentsInChildren4;
					foreach (SingleItemSpawner val11 in array8)
					{
						if (val11.prefab.gameObject.TryGetComponent<Dynamite>(ref val12) && ShouldBeUnnamed)
						{
							RenameToUnnamed(((Component)val11).gameObject);
							val11.prefab = GetUnnamedVariant(val11.prefab.GetComponent<Item>());
						}
					}
					BiomeSeeds[val._biome] = Random.state;
				}
				Random.state = state;
			}
		}

		private void SetMirageAsUnnamed(MirageLuggage mirage)
		{
			Renderer[] renderers = mirage.renderers;
			foreach (Renderer val in renderers)
			{
				List<Material> list = new List<Material>();
				Material[] materials = val.materials;
				Material[] array = materials;
				foreach (Material vanillaMaterial in array)
				{
					list.Add(GetMirageMaterial(vanillaMaterial));
				}
				val.SetMaterials(list);
			}
		}

		private Material GetMirageMaterial(Material vanillaMaterial)
		{
			string name = ((Object)vanillaMaterial).name;
			string text = name.Replace("(Instance)", "").Replace("(Clone)", "").Trim();
			string key = text.Replace("m_", "M_").Replace("M_", "M_Unnamed").Trim() ?? "";
			if (CustomStartsWith(text, "M_Unnamed"))
			{
				vanillaMaterial.shader = ThrowHelper.ThrowIfArgumentNull<Shader>(Shader.Find(((Object)vanillaMaterial.shader).name), "Shader.Find(unnamedMaterial.shader.name)");
				return vanillaMaterial;
			}
			return MirageMaterials.GetValueOrDefault(key, vanillaMaterial);
		}

		public static void GenerateSeedStates(LevelGeneration gens)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0033: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			State state = Random.state;
			Random.InitState(gens.seed);
			foreach (BiomeType value in Enum.GetValues(typeof(BiomeType)))
			{
				int num = Random.Range(int.MinValue, int.MaxValue);
				State state2 = Random.state;
				Random.InitState(num);
				BiomeSeeds[value] = Random.state;
				Random.state = state2;
			}
			Random.state = state;
		}

		public static void PopulateUnnamedDynamite(BiomeType type, List<SingleItemSpawner> list)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			State state = Random.state;
			Random.state = BiomeSeeds[type];
			foreach (SingleItemSpawner item in list)
			{
				if (Random.value < 0.25f)
				{
					item.prefab = GetUnnamedVariant(item.prefab.GetComponent<Item>());
				}
			}
			BiomeSeeds[type] = Random.state;
			Random.state = state;
		}

		private void AddLocalizedTextCsv()
		{
			using StreamReader streamReader = new StreamReader(Path.Join((ReadOnlySpan<char>)Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), (ReadOnlySpan<char>)"UnnamedLocalizedText.csv"));
			int num = 0;
			while (!streamReader.EndOfStream)
			{
				string text = streamReader.ReadLine();
				if (text == null)
				{
					break;
				}
				num++;
				List<string> list = new List<string>(CSVReader.SplitCsvLine(text, true));
				string text2 = ExtCollections.Deque<string>(list);
				string text3 = ExtCollections.Pop<string>(list);
				if (text3 != "ENDLINE")
				{
					Log.LogError((object)$"Invalid localization at line {num}");
				}
				if (!(text2 != "CURRENT_LANGUAGE"))
				{
					continue;
				}
				if (text2 == "KIOSK_READY_TEXT")
				{
					for (int i = 0; i < list.Count; i++)
					{
						list[i] = list[i].Replace("#modname", Name).Replace("#version", Version);
					}
				}
				LocalizedText.mainTable[text2] = list;
				Log.LogDebug((object)("Added localization of " + text2));
			}
			Log.LogDebug((object)$"Added {num - 1} localizations");
		}

		private static Vector3 GetSpawnPosition()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)MainCamera.instance))
			{
				Log.LogWarning((object)"GetSpawnPosition: MainCamera not found, using default position");
				return Vector3.zero;
			}
			Transform transform = ((Component)MainCamera.instance).transform;
			float num = 5000f;
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(transform.position, transform.forward, ref val, num))
			{
				return ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * 0.1f;
			}
			return transform.position + transform.forward * 25f;
		}

		private static Quaternion GetSpawnRotation()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_002f: 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_0031: 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_0043: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)MainCamera.instance))
			{
				return Quaternion.identity;
			}
			Vector3 forward = ((Component)MainCamera.instance).transform.forward;
			forward.y = 0f;
			Vector3 val = forward;
			if (!(val != Vector3.zero))
			{
				return Quaternion.identity;
			}
			return Quaternion.LookRotation(val);
		}

		[ConsoleCommand]
		public static void SpawnBigUnnamedLuggage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 spawnPosition = GetSpawnPosition();
			Quaternion spawnRotation = GetSpawnRotation();
			try
			{
				NetworkPrefabManager.SpawnNetworkPrefab(((Object)BigUnnamedLuggagePrefab).name, spawnPosition, spawnRotation, (byte)0, (object[])null);
				Log.LogInfo((object)$"Spawned Big Unnamed luggage at {spawnPosition}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("spawnsmallluggage: Failed - " + ex.Message));
			}
		}

		[ConsoleCommand]
		public static void SpawnSmallUnnamedLuggage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 spawnPosition = GetSpawnPosition();
			Quaternion identity = Quaternion.identity;
			try
			{
				NetworkPrefabManager.SpawnNetworkPrefab(((Object)SmallUnnamedLuggagePrefab).name, spawnPosition, identity, (byte)0, (object[])null);
				Log.LogInfo((object)$"Spawned Small Unnamed luggage at {spawnPosition}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("spawnsmallluggage: Failed - " + ex.Message));
			}
		}

		[ConsoleCommand]
		public static void SpawnEpicUnnamedLuggage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 spawnPosition = GetSpawnPosition();
			Quaternion identity = Quaternion.identity;
			try
			{
				NetworkPrefabManager.SpawnNetworkPrefab(((Object)EpicUnnamedLuggagePrefab).name, spawnPosition, identity, (byte)0, (object[])null);
				Log.LogInfo((object)$"Spawned Epic Unnamed luggage at {spawnPosition}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("spawnsmallluggage: Failed - " + ex.Message));
			}
		}

		[ConsoleCommand]
		public static void SpawnAncientUnnamedLuggage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 spawnPosition = GetSpawnPosition();
			Quaternion identity = Quaternion.identity;
			try
			{
				NetworkPrefabManager.SpawnNetworkPrefab(((Object)AncientUnnamedLuggagePrefab).name, spawnPosition, identity, (byte)0, (object[])null);
				Log.LogInfo((object)$"Spawned Ancient Unnamed luggage at {spawnPosition}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("spawnsmallluggage: Failed - " + ex.Message));
			}
		}

		public static void ApplyUnnamedModifierToAffliction(ref Affliction affliction)
		{
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			Affliction val = affliction;
			Affliction_PoisonOverTime val2 = (Affliction_PoisonOverTime)(object)((val is Affliction_PoisonOverTime) ? val : null);
			if (val2 == null)
			{
				Affliction_FasterBoi val3 = (Affliction_FasterBoi)(object)((val is Affliction_FasterBoi) ? val : null);
				if (val3 == null)
				{
					Affliction_Exhaustion val4 = (Affliction_Exhaustion)(object)((val is Affliction_Exhaustion) ? val : null);
					if (val4 == null)
					{
						Affliction_AdjustColdOverTime val5 = (Affliction_AdjustColdOverTime)(object)((val is Affliction_AdjustColdOverTime) ? val : null);
						if (val5 == null)
						{
							Affliction_Chaos val6 = (Affliction_Chaos)(object)((val is Affliction_Chaos) ? val : null);
							if (val6 == null)
							{
								Affliction_AdjustStatus val7 = (Affliction_AdjustStatus)(object)((val is Affliction_AdjustStatus) ? val : null);
								if (val7 == null)
								{
									Affliction_AddBonusStamina val8 = (Affliction_AddBonusStamina)(object)((val is Affliction_AddBonusStamina) ? val : null);
									if (val8 == null)
									{
										Affliction_AdjustDrowsyOverTime val9 = (Affliction_AdjustDrowsyOverTime)(object)((val is Affliction_AdjustDrowsyOverTime) ? val : null);
										if (val9 == null)
										{
											Affliction_AdjustStatusOverTime val10 = (Affliction_AdjustStatusOverTime)(object)((val is Affliction_AdjustStatusOverTime) ? val : null);
											if (val10 == null)
											{
												Affliction_ZombieBite val11 = (Affliction_ZombieBite)(object)((val is Affliction_ZombieBite) ? val : null);
												if (val11 == null)
												{
													Affliction_ClimbingChalk val12 = (Affliction_ClimbingChalk)(object)((val is Affliction_ClimbingChalk) ? val : null);
													if (val12 == null)
													{
														Affliction_LowGravity val13 = (Affliction_LowGravity)(object)((val is Affliction_LowGravity) ? val : null);
														if (val13 != null)
														{
															int num = Mathf.RoundToInt((float)val13.lowGravAmount * RandomUnnamedModifier);
															Log.LogInfo((object)$"Climbing Chalk climb stamina multiplier from {val13.lowGravAmount} to {num}");
															val13.lowGravAmount = Mathf.RoundToInt((float)val13.lowGravAmount * RandomUnnamedModifier);
															return;
														}
														if (UnnamedCanadianCompatibility.enabled)
														{
															UnnamedCanadianCompatibility.ApplyUnnamedModifierToAffliction(ref affliction);
														}
														if (Unnamed4FoodCompatibility.enabled)
														{
															Unnamed4FoodCompatibility.ApplyUnnamedModifierToAffliction(ref affliction);
														}
													}
													else
													{
														float num2 = val12.climbStaminaMultiplier * RandomUnnamedModifier;
														Log.LogInfo((object)$"Climbing Chalk climb stamina multiplier from {val12.climbStaminaMultiplier} to {num2}");
														val12.climbStaminaMultiplier = num2;
													}
												}
												else
												{
													float num3 = val11.statusPerSecond * RandomUnnamedModifier;
													float num4 = val11.delayBeforeEffect * RandomUnnamedModifier;
													Log.LogInfo((object)$"Zombie bite status per seconds from {val11.statusPerSecond}/s to {num3}/s");
													Log.LogInfo((object)$"Zombie bite delay from {val11.delayBeforeEffect}/s to {num4}/s");
													val11.statusPerSecond = num3;
													val11.delayBeforeEffect = num4;
												}
											}
											else
											{
												float num5 = val10.statusPerSecond * RandomUnnamedModifier;
												Log.LogInfo((object)$"Adjust status over time from {val10.statusPerSecond} to {num5}");
												val10.statusPerSecond = num5;
											}
										}
										else
										{
											float num6 = val9.statusPerSecond * RandomUnnamedModifier;
											Log.LogInfo((object)$"Adjust DROWSY over time from {val9.statusPerSecond} to {num6}");
											val9.statusPerSecond = num6;
										}
									}
									else
									{
										float num7 = val8.staminaAmount * RandomUnnamedModifier;
										Log.LogInfo((object)$"Add bonus stam from {val8.staminaAmount} to {num7}");
										val8.staminaAmount = num7;
									}
								}
								else
								{
									float num8 = val7.statusAmount * RandomUnnamedModifier;
									Log.LogInfo((object)$"Adjust {val7.statusType} from {val7.statusAmount} to {num8}");
									val7.statusAmount = num8;
								}
							}
							else
							{
								float num9 = val6.averageBonusStamina * RandomUnnamedModifier;
								float num10 = val6.statusAmountAverage * RandomUnnamedModifier;
								Log.LogInfo((object)$"Chaos bonus stam from {val6.averageBonusStamina} to {num9}");
								Log.LogInfo((object)$"Chaos average status amount from {val6.statusAmountAverage} to {num10}");
								val6.averageBonusStamina = num9;
								val6.statusAmountAverage = num10;
							}
						}
						else
						{
							float num11 = val5.statusPerSecond * RandomUnnamedModifier;
							Log.LogInfo((object)$"Adjust COLD over time from {val5.statusPerSecond}/s to {num11}/s");
							val5.statusPerSecond = num11;
						}
					}
					else
					{
						float num12 = val4.drainAmount * RandomUnnamedModifier;
						Log.LogInfo((object)$"Exhaustion from {val4.drainAmount} to {num12}");
						val4.drainAmount = num12;
					}
				}
				else
				{
					float num13 = val3.moveSpeedMod * RandomUnnamedModifier;
					float num14 = val3.climbSpeedMod * RandomUnnamedModifier;
					float num15 = val3.drowsyOnEnd * RandomUnnamedModifier;
					Log.LogInfo((object)$"Faster boi move speed from {val3.moveSpeedMod}/s to {num13}/s");
					Log.LogInfo((object)$"Faster boi climb speed from {val3.climbSpeedMod}/s to {num14}/s");
					Log.LogInfo((object)$"Faster boi drowsiness on end from {val3.drowsyOnEnd} to {num15}");
					val3.moveSpeedMod = num13;
					val3.climbSpeedMod = num14;
					val3.drowsyOnEnd = num15;
				}
			}
			else
			{
				float num16 = val2.statusPerSecond * RandomUnnamedModifier;
				Log.LogInfo((object)$"Poison over time from {val2.statusPerSecond}/s to {num16}/s");
				val2.statusPerSecond = num16;
			}
		}

		public static bool DoesZombiesSpawnGlobally()
		{
			ConfigEntry<bool> val = default(ConfigEntry<bool>);
			ConfigEntry<bool> val2 = default(ConfigEntry<bool>);
			if (Chainloader.PluginInfos.TryGetValue("tony4twenty.PEAK_Zombies", out var value) && value.Instance.Config.TryGetEntry<bool>("General", "DisableZombies", ref val) && value.Instance.Config.TryGetEntry<bool>("General", "AutoSpawnEnabled", ref val2) && val.Value)
			{
				return val2.Value;
			}
			ConfigEntry<bool> val3 = default(ConfigEntry<bool>);
			if (Chainloader.PluginInfos.TryGetValue("com.github.Thanks.ShootZombies", out var value2) && value2.Instance.Config.TryGetEntry<bool>("Zombie Spawn", "Zombie Spawn", ref val3) && val3.Value)
			{
				return true;
			}
			return _hasAnyGlobalSpawningZombies;
		}

		public void AddItemToDatabase(string originalItemName, GameObject newVariantGameObject)
		{
			UnnamedDatabase.Add(originalItemName, newVariantGameObject.gameObject);
			Log.LogInfo((object)("Added item named " + ((Object)newVariantGameObject.gameObject).name + " for " + originalItemName + "."));
		}

		public static string CleanedName(string dirtyString)
		{
			return dirtyString.Replace("(Clone)", "").Replace("(Instanced)", "").Trim();
		}
	}
}
namespace UnnamedProducts.Patchers
{
	public static class UnnamedItemPatcher
	{
		[HarmonyPatch(typeof(Item), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(Item __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(ClimbHandle), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(ClimbHandle __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(ScoutCannonFuse), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(ScoutCannonFuse __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance.scoutCannon).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(RopeSegment), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(RopeSegment __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance.rope).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(JungleVine), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(JungleVine __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(ShittyPiton), "Start")]
		[HarmonyPostfix]
		public static void StartPostfix(ShittyPiton __instance)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				float totalSecondsOfHang = __instance.totalSecondsOfHang;
				__instance.totalSecondsOfHang *= UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)$"Hang time for {((Object)((Component)__instance).gameObject).name} will be {__instance.totalSecondsOfHang} instead of {totalSecondsOfHang} because {((Object)((Component)__instance).gameObject).name} is UNNAMED");
			}
		}

		[HarmonyPatch(typeof(Breakable), "RPC_NonItemBreak")]
		[HarmonyPrefix]
		public static void BreakableNonItemPrefix(Breakable __instance, ref bool __runOriginal)
		{
			//IL_0035: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (!UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				return;
			}
			__runOriginal = false;
			int i = 0;
			Rigidbody val2 = default(Rigidbody);
			for (int count = __instance.instantiateNonItemOnBreak.Count; i < count; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.instantiateNonItemOnBreak[i], ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				if (!val.activeSelf)
				{
					val.SetActive(true);
				}
				if (val.TryGetComponent<Rigidbody>(ref val2))
				{
					val2.linearVelocity = __instance.item.rig.linearVelocity;
					val2.angularVelocity = __instance.item.rig.angularVelocity;
				}
			}
		}

		[HarmonyPatch(typeof(Action_Spawn), "RPCSpawn")]
		[HarmonyPrefix]
		public static void RPCSpawnPrefix(Action_Spawn __instance, Vector3 position, Quaternion rotation, ref bool __runOriginal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				__runOriginal = false;
				GameObject val = Object.Instantiate<GameObject>(__instance.objectToSpawn, position, rotation);
				if (!val.activeSelf)
				{
					val.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(Item), "HideRenderers")]
		[HarmonyPrefix]
		public static void RPCSpawnPrefix(Item __instance, ref bool __runOriginal)
		{
			if (__instance is UnnamedGarbageBagController unnamedGarbageBagController)
			{
				__runOriginal = false;
				LinqExtensions.ForEach<Renderer>((IEnumerable<Renderer>)unnamedGarbageBagController.allBagRenderers, (Action<Renderer>)delegate(Renderer meshRenderer)
				{
					meshRenderer.enabled = false;
				});
			}
		}

		[HarmonyPatch(typeof(ItemCooking), "RPC_CookingExplode")]
		[HarmonyPrefix]
		public static void CookingExplodePrefix(ItemCooking __instance, ref bool __runOriginal)
		{
			//IL_00ae: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			if (!UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				return;
			}
			__runOriginal = false;
			UnnamedDynamite unnamedDynamite = default(UnnamedDynamite);
			if (((Component)((ItemComponent)__instance).item).TryGetComponent<UnnamedDynamite>(ref unnamedDynamite) && unnamedDynamite.IsADud)
			{
				UnnamedPlugin.Log.LogInfo((object)("UnnamedDynamite " + ((Object)((Component)((ItemComponent)__instance).item).gameObject).name + " is a dud. Not exploding"));
				return;
			}
			UnnamedFlare unnamedFlare = default(UnnamedFlare);
			if (((Component)((ItemComponent)__instance).item).TryGetComponent<UnnamedFlare>(ref unnamedFlare) && unnamedFlare.IsADud)
			{
				UnnamedPlugin.Log.LogInfo((object)("UnnamedFlare " + ((Object)((Component)((ItemComponent)__instance).item).gameObject).name + " is a dud. Not exploding"));
				return;
			}
			if (Object.op_Implicit((Object)(object)__instance.explosionPrefab))
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.explosionPrefab, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				if (!val.activeSelf)
				{
					val.SetActive(true);
				}
			}
			if ((Object)(object)Character.localCharacter.data.currentItem == (Object)(object)((ItemComponent)__instance).item)
			{
				Player.localPlayer.EmptySlot(Character.localCharacter.refs.items.currentSelectedSlot);
				Character.localCharacter.refs.afflictions.UpdateWeight();
			}
			((ItemComponent)__instance).item.ClearDataFromBackpack();
			if (((ItemComponent)__instance).photonView.IsMine)
			{
				PhotonNetwork.Destroy(((Component)__instance).gameObject);
			}
		}

		[HarmonyPatch(typeof(Action_ModifyStatus), "RunAction")]
		[HarmonyPrefix]
		public static void ModifyStatusPrefix(Action_ModifyStatus __instance, ref bool __runOriginal)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Invalid comparison between Unknown and I4
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				return;
			}
			__runOriginal = false;
			float num = __instance.changeAmount * UnnamedPlugin.RandomUnnamedModifier;
			Character character = ((ItemActionBase)__instance).character;
			if (character == null || (__instance.ifSkeleton && !character.data.isSkeleton))
			{
				return;
			}
			bool passedOut = character.data.passedOut;
			Character val = default(Character);
			bool flag = ((ItemActionBase)__instance).item.TryGetFeeder(ref val);
			UnnamedPlugin.Log.LogInfo((object)$"Applying {num} of {__instance.statusType} instead of {__instance.changeAmount} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
			if (__instance.changeAmount < 0f)
			{
				if ((int)__instance.statusType == 3)
				{
					character.refs.afflictions.ClearPoisonAfflictions();
					int num2 = Mathf.RoundToInt(Mathf.Min(character.refs.afflictions.GetCurrentStatus((STATUSTYPE)3), Mathf.Abs(num)) * 100f);
					if (flag)
					{
						GameUtils.instance.IncrementFriendPoisonHealing(num2, ((MonoBehaviourPun)val).photonView.Owner);
					}
					else
					{
						Singleton<AchievementManager>.Instance.IncrementSteamStat((STEAMSTATTYPE)4, num2);
					}
				}
				if ((int)__instance.statusType == 0 && flag)
				{
					int num3 = Mathf.RoundToInt(Mathf.Min(character.refs.afflictions.GetCurrentStatus((STATUSTYPE)0), Mathf.Abs(num)) * 100f);
					GameUtils.instance.IncrementFriendHealing(num3, ((MonoBehaviourPun)val).photonView.Owner);
				}
				character.refs.afflictions.SubtractStatus(__instance.statusType, Mathf.Abs(num), false, false);
			}
			else
			{
				character.refs.afflictions.AddStatus(__instance.statusType, Mathf.Abs(num), false, true, true);
			}
			float statusSum = character.refs.afflictions.statusSum;
			if (passedOut && statusSum <= 1f)
			{
				UnnamedPlugin.Log.LogDebug((object)"LIFE WAS SAVED");
				if (flag)
				{
					GameUtils.instance.ThrowEmergencyPreparednessAchievement(((MonoBehaviourPun)val).photonView.Owner);
				}
			}
		}

		[HarmonyPatch(typeof(Action_RestoreHunger), "RunAction")]
		[HarmonyPrefix]
		public static void RestoreHungerPrefix(Action_RestoreHunger __instance, ref bool __runOriginal)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				__runOriginal = false;
				float num = __instance.restorationAmount * UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)$"Restoring {num} hunger instead of {__instance.restorationAmount} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
				((ItemActionBase)__instance).character.refs.afflictions.SubtractStatus((STATUSTYPE)1, num, false, false);
			}
		}

		[HarmonyPatch(typeof(Action_Flare), "RunAction")]
		[HarmonyPrefix]
		public static void RestoreHungerPrefix(Action_Flare __instance, ref bool __runOriginal)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				__runOriginal = false;
				UnnamedFlare unnamedFlare = default(UnnamedFlare);
				if (((Component)((ItemActionBase)__instance).item).TryGetComponent<UnnamedFlare>(ref unnamedFlare) && !unnamedFlare.isDud)
				{
					__runOriginal = true;
				}
			}
		}

		[HarmonyPatch(typeof(Action_BecomeSkeleton), "RunAction")]
		[HarmonyPrefix]
		public static void BecomeSkeletonPrefix(Action_BecomeSkeleton __instance, ref bool __runOriginal)
		{
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject) || !((Component)((ItemActionBase)__instance).item).CompareTag("BookOfBones") || !((ItemActionBase)__instance).item.GetData<BoolItemData>((DataEntryKey)16, (Func<BoolItemData>)DefaultBookOfBoneBad).Value)
			{
				return;
			}
			UnnamedPlugin.Log.LogInfo((object)("Book of bones will skeletonize everyone BUT " + ((ItemActionBase)__instance).character.characterName + " because " + ((Object)((ItemActionBase)__instance).item).name + " is UNNAMED"));
			__runOriginal = false;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)(object)((ItemActionBase)__instance).character))
				{
					allCharacter.view.RPC("RPC_SyncSkeleton", (RpcTarget)0, new object[1] { !allCharacter.data.isSkeleton });
				}
			}
		}

		[HarmonyPatch(typeof(Action_ClearAllStatus), "RunAction")]
		[HarmonyPrefix]
		public static void ClearAllPrefix(Action_ClearAllStatus __instance, ref bool __runOriginal)
		{
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject) || !((Component)((ItemActionBase)__instance).item).CompareTag("BookOfBones") || !((ItemActionBase)__instance).item.GetData<BoolItemData>((DataEntryKey)16, (Func<BoolItemData>)DefaultBookOfBoneBad).Value)
			{
				return;
			}
			__runOriginal = false;
			UnnamedPlugin.Log.LogInfo((object)(((Object)((ItemActionBase)__instance).item).name + " will skeletonize everyone BUT " + ((ItemActionBase)__instance).character.characterName + " because " + ((Object)((ItemActionBase)__instance).item).name + " is UNNAMED"));
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)(object)((ItemActionBase)__instance).character))
				{
					allCharacter.view.RPC("RPC_ClearAllStatusesBones", (RpcTarget)0, new object[2]
					{
						__instance.excludeCurse,
						LinqExtensions.Convert<int>((IEnumerable)__instance.otherExclusions, (Func<object, int>)((object s) => (int)s)).ToArray()
					});
				}
			}
		}

		private static BoolItemData DefaultBookOfBoneBad()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = !UnnamedPlugin.RandomUnnamedBool
			};
		}

		[HarmonyPatch(typeof(Action_ClearAllStatus), "RunAction")]
		[HarmonyPostfix]
		public static void ClearAllPost(Action_ClearAllStatus __instance)
		{
			Character character = ((ItemActionBase)__instance).character;
			CharacterBurnController characterBurnController = default(CharacterBurnController);
			if (character != null && ((Component)character).TryGetComponent<CharacterBurnController>(ref characterBurnController))
			{
				characterBurnController.ExtinguishFires();
			}
		}

		[HarmonyPatch(typeof(ScoutCannon), "FireTargets")]
		[HarmonyPrefix]
		public static void FireTargetsPre(ScoutCannon __instance, ref bool __runOriginal)
		{
			if (__instance is UnnamedScoutCannon unnamedScoutCannon)
			{
				__runOriginal = false;
				unnamedScoutCannon.UnnamedFireCannon();
			}
		}

		[HarmonyPatch(typeof(RescueHook), "Fire")]
		[HarmonyPrefix]
		public static void FireTargetsPre(RescueHook __instance, ref bool __runOriginal)
		{
			if (__instance is UnnamedRescueHook unnamedRescueHook)
			{
				__runOriginal = false;
				unnamedRescueHook.Fire();
			}
		}

		[HarmonyPatch(typeof(Action_ModifyStatus), "RunAction")]
		[HarmonyPrefix]
		public static void ClearAllPrefix(Action_ModifyStatus __instance, ref bool __runOriginal)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected I4, but got Unknown
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject) || !((Component)((ItemActionBase)__instance).item).CompareTag("BookOfBones") || !((ItemActionBase)__instance).item.GetData<BoolItemData>((DataEntryKey)16, (Func<BoolItemData>)DefaultBookOfBoneBad).Value)
			{
				return;
			}
			UnnamedPlugin.Log.LogInfo((object)$"{((Object)((ItemActionBase)__instance).item).name} will apply {__instance.changeAmount} of {__instance.statusType} to everyone BUT {((ItemActionBase)__instance).character.characterName} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
			__runOriginal = false;
			Character val = default(Character);
			bool flag = ((ItemActionBase)__instance).item.TryGetFeeder(ref val);
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)(object)((ItemActionBase)__instance).character))
				{
					allCharacter.view.RPC("RPC_ChangeStatsBones", (RpcTarget)0, new object[4]
					{
						(int)__instance.statusType,
						__instance.changeAmount,
						__instance.ifSkeleton,
						flag ? val.view.ViewID : (-1)
					});
				}
			}
		}

		[HarmonyPatch(typeof(Action_ModifyStatus), "RunAction")]
		[HarmonyPostfix]
		public static void ModifyStatusesPostfix(Action_ModifyStatus __instance)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (__instance != null && (int)__instance.statusType == 8 && __instance.changeAmount < 0f)
			{
				Character character = ((ItemActionBase)__instance).character;
				CharacterBurnController characterBurnController = default(CharacterBurnController);
				if (character != null && ((Component)character).TryGetComponent<CharacterBurnController>(ref characterBurnController))
				{
					characterBurnController.ExtinguishFires();
				}
			}
		}

		[HarmonyPatch(typeof(Action_GiveExtraStamina), "RunAction")]
		[HarmonyPrefix]
		public static void GiveExtraStaminaPrefix(Action_GiveExtraStamina __instance, ref bool __runOriginal)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				__runOriginal = false;
				float num = __instance.amount * UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)$"Giving {num} extra stamina instead of {__instance.amount} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
				((ItemActionBase)__instance).character.AddExtraStamina(num);
			}
		}

		[HarmonyPatch(typeof(Action_AddOrRemoveThorns), "RunAction")]
		[HarmonyPrefix]
		public static void AddOrRemoveThornsPrefix(Action_AddOrRemoveThorns __instance, ref bool __runOriginal)
		{
			//IL_0072: 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)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				return;
			}
			__runOriginal = false;
			int num = Mathf.RoundToInt((float)__instance.thornCount * UnnamedPlugin.RandomUnnamedModifier);
			UnnamedPlugin.Log.LogInfo((object)$"Applying {num:+0;-0;0} thorns instead of {__instance.thornCount} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
			int i = num;
			if (i > 0)
			{
				while (i > 0)
				{
					if (__instance.specificBodyPart)
					{
						Vector3 val = Vector3.Lerp(__instance.minOffset, __instance.maxOffset, Random.Range(0f, 1f));
						Transform transform = ((Component)((ItemActionBase)__instance).character.GetBodypart(__instance.location)).transform;
						Vector3 val2 = transform.position + transform.TransformVector(val);
						((ItemActionBase)__instance).character.refs.afflictions.AddThorn(val2);
					}
					else
					{
						((ItemActionBase)__instance).character.refs.afflictions.AddThorn((ushort)999);
					}
					i--;
				}
			}
			else
			{
				for (; i < 0; i++)
				{
					((ItemActionBase)__instance).character.refs.afflictions.RemoveRandomThornLinq();
				}
			}
		}

		[HarmonyPatch(typeof(RopeShooter), "OnPrimaryFinishedCast")]
		[HarmonyPrefix]
		public static void LaunchRopePrefix(RopeShooter __instance)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)((ItemComponent)__instance).item).gameObject))
			{
				float randomUnnamedModifier = UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)string.Format("Setting {0} length to {1} instead of {2} because {3} is UNNAMED", "Rope", __instance.length * randomUnnamedModifier, __instance.length, ((Object)((ItemComponent)__instance).item).name));
				__instance.length *= randomUnnamedModifier;
			}
		}

		[HarmonyPatch(typeof(Action_RaycastDart), "FireDart")]
		[HarmonyPrefix]
		public static void RaycastSelfPrefix(Action_RaycastDart __instance, ref bool __runOriginal)
		{
			//IL_0047: 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)
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject) || !UnnamedPlugin.RandomUnnamedBool)
			{
				return;
			}
			Character character = ((ItemActionBase)__instance).character;
			if (character != null)
			{
				Bodypart head = character.refs.head;
				if (head != null)
				{
					__runOriginal = false;
					Debug.Log((object)"no u");
					__instance.DartImpact(character, __instance.spawnTransform.position, ((Component)head).transform.position);
				}
			}
		}

		[HarmonyPatch(typeof(CompassPointer), "UpdateHeadingPirate")]
		[HarmonyPrefix]
		public static void UpdateHeadingPrefix(CompassPointer __instance, ref bool __runOriginal)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0085: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (!UnnamedPlugin.IsUnnamed(((Component)__instance.item).gameObject) || Luggage.ALL_LUGGAGE.Count <= 0 || !__instance.item.inActiveList)
			{
				return;
			}
			__runOriginal = false;
			float num = float.MaxValue;
			bool flag = false;
			LuggageBrandHandler luggageBrandHandler = default(LuggageBrandHandler);
			foreach (Luggage item in Luggage.ALL_LUGGAGE)
			{
				if (((Component)item).TryGetComponent<LuggageBrandHandler>(ref luggageBrandHandler) && luggageBrandHandler.isUnnamed)
				{
					Vector3 val = item.Center();
					if (val.SquareDistance(((Component)__instance).transform.position) < num)
					{
						num = val.SquareDistance(((Component)__instance).transform.position);
						__instance.currentLuggageVector = val - ((Component)__instance).transform.position;
						flag = true;
					}
				}
			}
			if (!flag)
			{
				__instance.heading = Quaternion.Euler(0f, Time.time * __instance.warpSpeed, 0f) * Vector3.forward;
			}
			else
			{
				__instance.heading = __instance.currentLuggageVector;
			}
		}

		[HarmonyPatch(typeof(Action_ApplyAffliction), "RunAction")]
		[HarmonyPrefix]
		public static void ApplyAfflictionPrefix(Action_ApplyAffliction __instance, ref bool __runOriginal)
		{
			if (!UnnamedPlugin.IsUnnamed(((Component)((ItemActionBase)__instance).item).gameObject))
			{
				return;
			}
			__runOriginal = false;
			if (__instance.affliction == null)
			{
				Debug.LogError((object)"Your affliction is null bro");
				return;
			}
			Affliction affliction = __instance.affliction.Copy();
			UnnamedPlugin.ApplyUnnamedModifierToAffliction(ref affliction);
			Affliction obj = affliction;
			obj.totalTime *= UnnamedPlugin.RandomUnnamedModifier;
			UnnamedPlugin.Log.LogInfo((object)$"Setting {((object)affliction).GetType().Name}'s total time to {affliction.totalTime} instead of {__instance.affliction.totalTime} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
			((ItemActionBase)__instance).character.refs.afflictions.AddAffliction(affliction, false);
			if (__instance.extraAfflictions != null)
			{
				Affliction[] extraAfflictions = __instance.extraAfflictions;
				Affliction[] array = extraAfflictions;
				foreach (Affliction val in array)
				{
					Affliction affliction2 = val.Copy();
					UnnamedPlugin.ApplyUnnamedModifierToAffliction(ref affliction2);
					Affliction obj2 = affliction2;
					obj2.totalTime *= UnnamedPlugin.RandomUnnamedModifier;
					UnnamedPlugin.Log.LogInfo((object)$"Setting {((object)affliction2).GetType().Name}'s total time to {affliction2.totalTime} instead of {val.totalTime} because {((Object)((ItemActionBase)__instance).item).name} is UNNAMED");
					((ItemActionBase)__instance).character.refs.afflictions.AddAffliction(affliction2, false);
				}
			}
		}

		[HarmonyPatch(typeof(Rope), "AddCharacterClimbing")]
		[HarmonyPostfix]
		public static void AddCharacterClimbingPostfix(Rope __instance, Character character)
		{
			UnnamedRopeBreaker unnamedRopeBreaker = default(UnnamedRopeBreaker);
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject) && ((Component)__instance).gameObject.TryGetComponent<UnnamedRopeBreaker>(ref unnamedRopeBreaker))
			{
				unnamedRopeBreaker.AddPlayerToRope(character);
			}
		}

		[HarmonyPatch(typeof(Rope), "RemoveCharacterClimbing")]
		[HarmonyPostfix]
		public static void RemoveCharacterClimbingPostfix(Rope __instance, Character character)
		{
			UnnamedRopeBreaker unnamedRopeBreaker = default(UnnamedRopeBreaker);
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject) && ((Component)__instance).gameObject.TryGetComponent<UnnamedRopeBreaker>(ref unnamedRopeBreaker))
			{
				unnamedRopeBreaker.RemovePlayerFromRope(character);
			}
		}

		[HarmonyPatch(typeof(Parasol), "ToggleOpen")]
		[HarmonyPrefix]
		public static void ToggleOpenPrefix(Parasol __instance, ref bool __runOriginal)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance.item).gameObject))
			{
				__runOriginal = __instance.isOpen || 1f * UnnamedPlugin.RandomUnnamedModifier >= 1f;
			}
		}

		[HarmonyPatch(typeof(AOE), "Explode")]
		[HarmonyPrefix]
		public static void ExplodePrefix(AOE __instance, ref bool __runOriginal)
		{
			//IL_0034: 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_0045: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			if (!UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				return;
			}
			__runOriginal = false;
			if (__instance.range == 0f)
			{
				return;
			}
			float num = __instance.statusAmount * UnnamedPlugin.RandomUnnamedModifier;
			Collider[] array = Physics.OverlapSphere(((Component)__instance).transform.position, __instance.range, LayerMask.op_Implicit(HelperFunctions.GetMask(__instance.mask)));
			List<Character> list = new List<Character>();
			Character val = default(Character);
			EventOnItemCollision val7 = default(EventOnItemCollision);
			for (int i = 0; i < array.Length; i++)
			{
				CharacterRagdoll.TryGetCharacterFromCollider(array[i], ref val);
				RaycastHit val2;
				Vector3 val4;
				if ((Object)(object)val != (Object)null && !list.Contains(val))
				{
					float num2 = Vector3.Distance(((Component)__instance).transform.position, val.Center);
					if (num2 > __instance.range)
					{
						continue;
					}
					float factor = __instance.GetFactor(num2);
					if (factor < __instance.minFactor)
					{
						continue;
					}
					if (__instance.requireLineOfSigh)
					{
						val2 = HelperFunctions.LineCheck(((Component)__instance).transform.position, val.Center, (LayerType)1, 0f, (QueryTriggerInteraction)1);
						if (Object.op_Implicit((Object)(object)((RaycastHit)(ref val2)).transform))
						{
							continue;
						}
					}
					list.Add(val);
					Vector3 val3;
					if (__instance.useSingleDirection)
					{
						val3 = __instance.singleDirectionForwardTF.forward;
					}
					else
					{
						val4 = val.Center - ((Component)__instance).transform.position;
						val3 = ((Vector3)(ref val4)).normalized;
					}
					Vector3 val5 = val3;
					if (Mathf.Abs(__instance.statusAmount) > 0f)
					{
						if (__instance.illegalStatus != "")
						{
							if (__instance.illegalStatus.ToUpperInvariant().Equals("BLIND"))
							{
								Affliction_Blind val6 = new Affliction_Blind
								{
									totalTime = num * factor
								};
								UnnamedPlugin.Log.LogInfo((object)$"Applying {__instance.illegalStatus} to {val.characterName} with an total time of {num * factor} instead of {__instance.statusAmount * factor} because {((Object)__instance).name} is UNNAMED");
								val.refs.afflictions.AddAffliction((Affliction)(object)val6, false);
							}
							else
							{
								UnnamedPlugin.Log.LogInfo((object)$"Applying {__instance.illegalStatus} to {val.characterName} with an amount of {num * factor} instead of {__instance.statusAmount * factor} because {((Object)__instance).name} is UNNAMED");
								val.AddIllegalStatus(__instance.illegalStatus, num * factor);
							}
						}
						else
						{
							UnnamedPlugin.Log.LogInfo((object)$"Applying {num * factor} {__instance.statusType} to {val.characterName} instead of {__instance.statusAmount * factor} because {((Object)__instance).name} is UNNAMED");
							val.refs.afflictions.AdjustStatus(__instance.statusType, num * factor, false);
							if (__instance.addtlStatus.Length != 0)
							{
								for (int j = 0; j < __instance.addtlStatus.Length; j++)
								{
									UnnamedPlugin.Log.LogInfo((object)$"Applying {num * factor} {__instance.addtlStatus[j]} to {val.characterName} instead of {__instance.statusAmount * factor} because {((Object)__instance).name} is UNNAMED");
									val.refs.afflictions.AdjustStatus(__instance.addtlStatus[j], num * factor, false);
								}
							}
						}
					}
					if (__instance.hasAffliction)
					{
						Affliction affliction = __instance.affliction.Copy();
						UnnamedPlugin.ApplyUnnamedModifierToAffliction(ref affliction);
						Affliction obj = affliction;
						obj.totalTime *= UnnamedPlugin.RandomUnnamedModifier;
						UnnamedPlugin.Log.LogInfo((object)$"Setting {((object)affliction).GetType().Name}'s total time to {affliction.totalTime} instead of {__instance.affliction.totalTime} because {((Object)((Component)__instance).gameObject).name} is UNNAMED");
						val.refs.afflictions.AddAffliction(__instance.affliction, false);
					}
					val.AddForce(val5 * factor * __instance.knockback, 0.7f, 1.3f);
					if (__instance.fallTime > 0f && ((MonoBehaviourPun)val).photonView.IsMine)
					{
						float num3 = factor * (__instance.fallTime * UnnamedPlugin.RandomUnnamedModifier);
						UnnamedPlugin.Log.LogInfo((object)$"Making {val.characterName} fall for {num3} instead of {factor * __instance.fallTime} because {((Object)((Component)__instance).gameObject).name} is UNNAMED");
						val.Fall(factor * __instance.fallTime, 0f);
					}
				}
				else
				{
					if (!__instance.canLaunchItems)
					{
						continue;
					}
					Item componentInParent = ((Component)array[i]).GetComponentInParent<Item>();
					if (!((Object)(object)componentInParent != (Object)null) || !((MonoBehaviourPun)componentInParent).photonView.IsMine || (int)componentInParent.itemState != 0)
					{
						continue;
					}
					float num4 = Vector3.Distance(((Component)__instance).transform.position, componentInParent.Center());
					if (num4 > __instance.range)
					{
						continue;
					}
					float factor2 = __instance.GetFactor(num4);
					if (factor2 < __instance.minFactor)
					{
						continue;
					}
					if (__instance.requireLineOfSigh)
					{
						val2 = HelperFunctions.LineCheck(((Component)__instance).transform.position, componentInParent.Center(), (LayerType)1, 0f, (QueryTriggerInteraction)1);
						if (Object.op_Implicit((Object)(object)((RaycastHit)(ref val2)).transform))
						{
							continue;
						}
					}
					if (__instance.procCollisionEvents && ((Component)componentInParent).TryGetComponent<EventOnItemCollision>(ref val7))
					{
						val7.TriggerEvent();
					}
					if (__instance.cooksItems)
					{
						componentInParent.cooking.FinishCooking();
					}
					val4 = componentInParent.Center() - ((Component)__instance).transform.position;
					Vector3 normalized = ((Vector3)(ref val4)).normalized;
					componentInParent.rig.AddForce(normalized * factor2 * __instance.knockback * __instance.itemKnockbackMultiplier, (ForceMode)1);
				}
			}
		}
	}
	public static class UnnamedPatcher
	{
		[HarmonyPatch(typeof(CharacterItems), "HammerClimbingSpike")]
		[HarmonyPrefix]
		public static void HammerClimbingSpikePrefix(CharacterItems __instance, RaycastHit hit, ref bool __runOriginal)
		{
			//IL_0089: 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_0095: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance.currentClimbingSpikeComponent != (Object)null) || !UnnamedPlugin.IsUnnamed(((Component)__instance.currentClimbingSpikeComponent).gameObject))
			{
				return;
			}
			__runOriginal = false;
			UnnamedClimbingSpikeComponent component = ((Component)__instance.currentClimbingSpikeComponent).gameObject.GetComponent<UnnamedClimbingSpikeComponent>();
			ItemSlot currentClimbingSpikeItemSlot = __instance.currentClimbingSpikeItemSlot;
			bool flag = false;
			BoolItemData val = default(BoolItemData);
			if (currentClimbingSpikeItemSlot != null && currentClimbingSpikeItemSlot.data.TryGetDataEntry<BoolItemData>((DataEntryKey)15, ref val))
			{
				flag = val.Value;
			}
			if (!((Object)(object)__instance.currentClimbingSpikeComponent != (Object)null) || !((Object)(object)PhotonNetwork.Instantiate(((Object)(flag ? component.hammeredBadVersionPrefab : component.hammeredGoodVersionPrefab).gameObject).name, ((RaycastHit)(ref hit)).point, Quaternion.LookRotation(-((RaycastHit)(ref hit)).normal, Vector3.up), (byte)0, (object[])null) != (Object)null))
			{
				return;
			}
			if (__instance.currentClimbingSpikeItemSlot != null)
			{
				ItemSlot currentClimbingSpikeItemSlot2 = __instance.currentClimbingSpikeItemSlot;
				__instance.currentClimbingSpikeItemSlot = null;
				__instance.currentClimbingSpikeComponent = null;
				__instance.character.player.EmptySlot(Optionable<byte>.Some(currentClimbingSpikeItemSlot2.itemSlotID));
				if ((Object)(object)__instance.character.data.currentItem != (Object)null)
				{
					__instance.EquipSlot(Optionable<byte>.None);
				}
				__instance.UpdateClimbingSpikeCount(__instance.character.player.itemSlots);
				__instance.character.data.lastConsumedItem = Time.time;
			}
			__instance.character.refs.afflictions.UpdateWeight();
			Singleton<AchievementManager>.Instance.IncrementSteamStat((STEAMSTATTYPE)3, 1);
			GameUtils.instance.IncrementPermanentItemsPlaced();
		}

		[HarmonyPatch(typeof(CharacterMovement), "SetWaterMovementModifier")]
		[HarmonyPostfix]
		public static void WaterMovementPostfix(CharacterMovement __instance)
		{
			CharacterBurnController characterBurnController = default(CharacterBurnController);
			if (((Component)__instance).gameObject.TryGetComponent<CharacterBurnController>(ref characterBurnController))
			{
				characterBurnController.ExtinguishFires();
			}
		}

		[HarmonyPatch(typeof(WaterfallTrigger), "OnTriggerStay")]
		[HarmonyPostfix]
		public static void WaterfallPostfix(WaterfallTrigger __instance, Collider other)
		{
			Character componentInParent = ((Component)other).gameObject.GetComponentInParent<Character>();
			StickyFireballController stickyFireballController = default(StickyFireballController);
			if (componentInParent != null)
			{
				CharacterBurnController characterBurnController = default(CharacterBurnController);
				if (((Component)componentInParent).TryGetComponent<CharacterBurnController>(ref characterBurnController))
				{
					characterBurnController.ExtinguishFires();
				}
			}
			else if (((Component)other).TryGetComponent<StickyFireballController>(ref stickyFireballController))
			{
				stickyFireballController.Extinguish();
			}
		}

		[HarmonyPatch(typeof(WaterfallPusher), "OnTriggerEnter")]
		[HarmonyPrefix]
		public static void WaterfallPushPrefix(WaterfallPusher __instance, Collider other)
		{
			Character componentInParent = ((Component)other).GetComponentInParent<Character>();
			StickyFireballController stickyFireballController = default(StickyFireballController);
			if (componentInParent != null)
			{
				CharacterBurnController characterBurnController = default(CharacterBurnController);
				if (componentInParent.IsLocal && Time.time > __instance.cooldown + __instance.cooldownTimer && ((Component)componentInParent).TryGetComponent<CharacterBurnController>(ref characterBurnController))
				{
					characterBurnController.ExtinguishFires();
				}
			}
			else if (((Component)other).TryGetComponent<StickyFireballController>(ref stickyFireballController))
			{
				stickyFireballController.Extinguish();
			}
		}

		[HarmonyPatch(typeof(CharacterVineClimbing), "StopVineClimbingRpc")]
		[HarmonyPostfix]
		public static void StopVineClimbingPostfix(CharacterVineClimbing __instance)
		{
			UnnamedVine unnamedVine = default(UnnamedVine);
			if ((Object)(object)__instance.character.data.heldVine != (Object)null && ((Component)__instance.character.data.heldVine).TryGetComponent<UnnamedVine>(ref unnamedVine))
			{
				unnamedVine.RemovePlayerFromVine(__instance.character);
			}
		}

		[HarmonyPatch(typeof(CharacterVineClimbing), "FixedUpdate")]
		[HarmonyPostfix]
		public static void FixedUpdatePostfix(CharacterVineClimbing __instance)
		{
			if (__instance.character.data.isVineClimbing && !Object.op_Implicit((Object)(object)__instance.character.data.heldVine))
			{
				__instance.character.refs.vineClimbing.Stop();
				__instance.character.Fall(1f, 0.25f);
			}
		}

		[HarmonyPatch(typeof(CharacterVineClimbing), "GrabVineRpc")]
		[HarmonyPostfix]
		public static void GrabVineRpcPostfix(CharacterVineClimbing __instance, PhotonView ropeView, int segmentIndex)
		{
			UnnamedVine unnamedVine = default(UnnamedVine);
			if (((Component)ropeView).TryGetComponent<UnnamedVine>(ref unnamedVine))
			{
				unnamedVine.AddPlayerToVine(__instance.character);
			}
		}

		[HarmonyPatch(typeof(Character), "Awake")]
		[HarmonyPostfix]
		public static void CharAwakePostfix(Character __instance)
		{
			UnnamedSkeletonHandler unnamedSkeletonHandler = ((Component)__instance).gameObject.AddComponent<UnnamedSkeletonHandler>();
			CharacterBurnController characterBurnController = ((Component)__instance).gameObject.AddComponent<CharacterBurnController>();
			StickyItemRemover stickyItemRemover = ((Component)__instance).gameObject.AddComponent<StickyItemRemover>();
			unnamedSkeletonHandler.m_character = __instance;
		}

		[HarmonyPatch(typeof(Enum), "GetValues")]
		[HarmonyPostfix]
		public static void GetValuePostfix(Enum __instance, Type enumType, ref Array __result)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			if (enumType == typeof(SpawnPool))
			{
				UnnamedPlugin.Log.LogInfo((object)("Adding \"UnnamedSpawnPool\" into " + enumType.Name + "'s values."));
				__result = CollectionExtensions.AddItem<int>((IEnumerable<int>)__result, (int)UnnamedPlugin.UnnamedSpawnPool).ToArray();
			}
		}

		[HarmonyPatch(typeof(GUIManager), "Awake")]
		[HarmonyPostfix]
		public static void GUIAwakePostfix(GUIManager __instance)
		{
			UnnamedUIManager orAddComponent = ExtensionMethods.GetOrAddComponent<UnnamedUIManager>(((Component)__instance).gameObject);
			if ((Object)(object)orAddComponent == (Object)null)
			{
				UnnamedPlugin.Log.LogError((object)("Can't add UnnamedUIManager to " + __instance.character.characterName + "'s GUI"));
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(UnnamedPlugin.UnnamedGarbageBagPrefab, ((Component)__instance.hudCanvas).transform);
			orAddComponent.m_garbageBagScreen = val.GetComponent<UnnamedGarbageBagScreen>();
			val.SetActive(false);
		}

		[HarmonyPatch(typeof(CactusBall), "Start")]
		[HarmonyPostfix]
		public static void StartPostfix(CactusBall __instance)
		{
			((Component)__instance).gameObject.AddComponent<StickyItemRemover>();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void GUIWheelActivePost(GUIManager __instance, ref bool __result)
		{
			__result = UnnamedUIManager.Instance.GarbageBagActive | __result;
		}

		private static int CalculateGarbageBagCarryWeight(ItemSlot[] slots, bool fromGarbageBag = false)
		{
			int num = 0;
			BackpackData val2 = default(BackpackData);
			UnnamedGarbageBagController unnamedGarbageBagController = default(UnnamedGarbageBagController);
			BackpackData val3 = default(BackpackData);
			for (int num2 = slots.Length - 1; num2 >= 0; num2--)
			{
				ItemSlot val = slots[num2];
				if (!val.IsEmpty())
				{
					if (val is BackpackSlot)
					{
						if (val.data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val2))
						{
							num += CalculateGarbageBagCarryWeight(val2.itemSlots, fromGarbageBag);
						}
					}
					else if (((Component)val.prefab).TryGetComponent<UnnamedGarbageBagController>(ref unnamedGarbageBagController) && val.data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val3))
					{
						num += CalculateGarbageBagCarryWeight(val3.itemSlots, fromGarbageBag: true);
					}
					else if (fromGarbageBag)
					{
						num += val.prefab.CarryWeight;
					}
				}
			}
			return num;
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
		[HarmonyPostfix]
		public static void UpdateGarbageBagWeight(CharacterAfflictions __instance)
		{
			//IL_0091: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			int num = CalculateGarbageBagCarryWeight(__instance.character.player.itemSlots);
			if (!((ItemSlot)__instance.character.player.backpackSlot).IsEmpty())
			{
				num += CalculateGarbageBagCarryWeight((ItemSlot[])(object)new ItemSlot[1] { (ItemSlot)__instance.character.player.backpackSlot });
			}
			if (!__instance.character.player.tempFullSlot.IsEmpty())
			{
				num += CalculateGarbageBagCarryWeight((ItemSlot[])(object)new ItemSlot[1] { __instance.character.player.tempFullSlot });
			}
			if (num > 0)
			{
				STATUSTYPE val = (STATUSTYPE)7;
				float num2 = 0.025f * (float)num;
				if ((!__instance.character.isZombie || __instance.StatusAffectsZombie(val)) && ((MonoBehaviourPun)__instance.character).photonView.IsMine)
				{
					__instance.currentStatuses[val] += num2;
					__instance.currentStatuses[val] = Mathf.Clamp(__instance.currentStatuses[val], 0f, __instance.GetStatusCap(val));
					__instance.currentStatuses[val] = __instance.RoundStatus(__instance.currentStatuses[val]);
					__instance.currentIncrementalStatuses[val] = 0f;
					__instance.currentDecrementalStatuses[val] = 0f;
					__instance.character.ClampStamina();
					GUIManager.instance.bar.ChangeBar();
					__instance.PushStatuses((Player)null);
				}
			}
		}

		[HarmonyPatch(typeof(LootData), "GetRandomItems")]
		[HarmonyPrefix]
		public static void GetRandomItemsPrefix(LootData __instance, SpawnPool spawnPool, int count, ref bool __runOriginal, ref List<GameObject> __result, bool canRepeat = false)
		{
			//IL_0011: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: 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)
			if (LootData.AllSpawnWeightData == null)
			{
				LootData.PopulateLootData();
			}
			if (LootData.AllSpawnWeightData.ContainsKey(spawnPool))
			{
				return;
			}
			__runOriginal = false;
			Array values = Enum.GetValues(((object)spawnPool).GetType());
			Dictionary<ushort, int> dictionary = new Dictionary<ushort, int>();
			foreach (int item in values)
			{
				if (!((Enum)spawnPool).HasFlag((Enum)(object)(SpawnPool)item) || !LootData.AllSpawnWeightData.TryGetValue((SpawnPool)item, out var value))
				{
					continue;
				}
				UnnamedPlugin.Log.LogInfo((object)$"Adding spawn pool {item} to spawn list.");
				foreach (KeyValuePair<ushort, int> item2 in value)
				{
					dictionary[item2.Key] = item2.Value;
				}
			}
			List<GameObject> list = new List<GameObject>();
			Item val = default(Item);
			for (int j = 0; j < count; j++)
			{
				ushort key = Util.RandomSelection<KeyValuePair<ushort, int>>((IEnumerable<KeyValuePair<ushort, int>>)dictionary, (Func<KeyValuePair<ushort, int>, int>)((KeyValuePair<ushort, int> i) => i.Value)).Key;
				if (!ItemDatabase.TryGetItem(key, ref val))
				{
					UnnamedPlugin.Log.LogWarning((object)$"Can't find item #{key} in database.");
					continue;
				}
				if (((Enum)spawnPool).HasFlag((Enum)(object)UnnamedPlugin.UnnamedSpawnPool) && !UnnamedPlugin.IsUnnamedUnique(((Component)val).gameObject) && !UnnamedPlugin.HasUnnamedVariant(val))
				{
					UnnamedPlugin.Log.LogInfo((object)(val.GetName() + " (" + ((Object)((Component)val).gameObject).name + ") cannot spawn in an unnamed luggage because it has no Unnamed variant"));
					dictionary.Remove(key);
					j--;
					continue;
				}
				if (!val.IsValidToSpawn())
				{
					UnnamedPlugin.Log.LogDebug((object)(val.GetName() + " (" + ((Object)((Component)val).gameObject).name + ") IS INVALID TO SPAWN"));
					dictionary.Remove(key);
					j--;
					continue;
				}
				list.Add(((Component)val).gameObject);
				if (!canRepeat)
				{
					dictionary.Remove(key);
				}
			}
			__result = list;
		}
	}
	internal static class UnnamedSpawnerPatcher
	{
		[HarmonyPatch(typeof(Item), "IsValidToSpawn")]
		[HarmonyPostfix]
		public static void IsValidToSpawnPostfix(Item __instance, ref bool __result)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			UnnamedSpawnRestriction unnamedSpawnRestriction = default(UnnamedSpawnRestriction);
			if ((!UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject) && !UnnamedPlugin.IsUnnamedUnique(((Component)__instance).gameObject)) || !((Component)__instance).gameObject.TryGetComponent<UnnamedSpawnRestriction>(ref unnamedSpawnRestriction))
			{
				return;
			}
			bool flag = true;
			bool flag2 = true;
			bool flag3 = true;
			bool flag4 = unnamedSpawnRestriction.biomeType.Length != 0;
			bool hasColdNightRestrictions = unnamedSpawnRestriction.hasColdNightRestrictions;
			bool hasZombieRestrictions = unnamedSpawnRestriction.hasZombieRestrictions;
			bool isNightCold = Ascents.isNightCold;
			bool flag5 = UnnamedPlugin.DoesZombiesSpawnGlobally();
			if (flag4)
			{
				MapHandler instance = Singleton<MapHandler>.Instance;
				if (instance != null)
				{
					BiomeType currentBiome = instance.GetCurrentBiome();
					if (!unnamedSpawnRestriction.biomeType.Contains(currentBiome))
					{
						flag = false;
					}
				}
				else
				{
					flag = false;
				}
			}
			else
			{
				flag = true;
			}
			flag2 = !hasColdNightRestrictions || unnamedSpawnRestriction.whenNightIsCold == isNightCold;
			if (hasZombieRestrictions)
			{
				flag3 = unnamedSpawnRestriction.whenZombieSpawnGlobally == flag5;
			}
			if (hasColdNightRestrictions && flag4 && hasZombieRestrictions)
			{
				__result = flag2 || flag || flag3;
			}
			else if (hasColdNightRestrictions && flag4 && !hasZombieRestrictions)
			{
				__result = flag2 || flag;
			}
			else if (hasColdNightRestrictions)
			{
				if (hasZombieRestrictions)
				{
					__result = flag2 || flag3;
				}
				else
				{
					__result = flag2;
				}
			}
			else if (flag4)
			{
				if (hasZombieRestrictions)
				{
					__result = flag || flag3;
				}
				else
				{
					__result = flag;
				}
			}
			else if (hasZombieRestrictions)
			{
				__result = flag3;
			}
			UnnamedPlugin.Log.LogInfo((object)(__instance.GetName() + " (" + ((Object)((Component)__instance).gameObject).name + ") is " + (__result ? "VALID" : "INVALID") + " to spawn!"));
			List<string> list = new List<string>();
			if (flag4)
			{
				list.Add(flag ? ("We're inside " + __instance.GetName() + "'s biome") : ("We're NOT in " + __instance.GetName() + "'s biome"));
			}
			if (hasColdNightRestrictions)
			{
				list.Add(flag2 ? ("Nights are " + (unnamedSpawnRestriction.whenNightIsCold ? "COLD" : "WARM") + " for global spawn (needed: " + (unnamedSpawnRestriction.whenNightIsCold ? "COLD NIGHTS" : "WARM NIGHTS") + ", got " + (isNightCold ? "COLD NIGHTS" : "WARM NIGHTS") + ")") : ("Night are NOT " + (unnamedSpawnRestriction.whenNightIsCold ? "COLD" : "WARM") + "  for global spawn (needed: " + (unnamedSpawnRestriction.whenNightIsCold ? "COLD NIGHTS" : "WARM NIGHTS") + ", got " + (isNightCold ? "COLD NIGHTS" : "WARM NIGHTS") + ")"));
			}
			if (hasZombieRestrictions)
			{
				list.Add(flag3 ? ("Zombies can " + (unnamedSpawnRestriction.whenZombieSpawnGlobally ? "span" : "not spawn") + " globably (needed: " + (unnamedSpawnRestriction.whenZombieSpawnGlobally ? "GLOBAL SPAWN" : "NO SPAWN") + ", got " + (flag5 ? "GLOBAL SPAWN" : "NO SPAWN") + ")") : ("Zombies cannot " + (unnamedSpawnRestriction.whenZombieSpawnGlobally ? "span" : "not spawn") + "  globably (needed: " + (unnamedSpawnRestriction.whenZombieSpawnGlobally ? "GLOBAL SPAWN" : "NO SPAWN") + ", got " + (flag5 ? "GLOBAL SPAWN" : "NO SPAWN") + ")"));
			}
			UnnamedPlugin.Log.LogInfo((object)GeneralExtensions.Join<string>((IEnumerable<string>)list, (Func<string, string>)null, ","));
		}

		[HarmonyPatch(typeof(Luggage), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(Item __instance, ref string __result)
		{
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				__result = LocalizedText.GetText("UNNAMED_ITEM", true).Replace("#", __result);
			}
		}

		[HarmonyPatch(typeof(Spawner), "GetObjectsToSpawn")]
		[HarmonyPostfix]
		public static void GetObjectsToSpawnPostfix(Spawner __instance, ref List<GameObject> __result, int spawnCount, bool canRepeat)
		{
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} items to spawn!", ThrowHelper.ThrowIfArgumentNull<List<GameObject>>(__result, "Results").Count));
			if (UnnamedPlugin.IsUnnamed(((Component)__instance).gameObject))
			{
				if (__instance.isSingleItem)
				{
					Item component = __instance.spawnedObjectPrefab.gameObject.GetComponent<Item>();
					UnnamedPlugin.Log.LogInfo((object)(component.UIData.itemName + " is to spawn."));
					if (component.UIData.itemName == "Dynamite")
					{
						List<GameObject> list = new List<GameObject>();
						for (int i = 0; i < spawnCount; i++)
						{
							GameObject unnamedVariant = UnnamedPlugin.GetUnnamedVariant(component);
							UnnamedPlugin.Log.LogInfo((object)("Turning " + component.GetName() + " into " + unnamedVariant.GetComponent<Item>().GetName() + "."));
							list.Add(unnamedVariant);
						}
						__result = list;
					}
					return;
				}
				int j = 0;
				for (int count = __result.Count; j < count; j++)
				{
					if (!UnnamedPlugin.IsUnnamed(__result[j]) && !UnnamedPlugin.IsUnnamedUnique(__result[j]))
					{
						Item component2 = __result[j].GetComponent<Item>();
						GameObject unnamedVariant2 = UnnamedPlugin.GetUnnamedVariant(component2);
						UnnamedPlugin.Log.LogInfo((object)("Turning " + component2.GetName() + " into " + unnamedVariant2.GetComponent<Item>().GetName() + "."));
						__result[j] = unnamedVariant2;
					}
				}
				return;
			}
			int k = 0;
			for (int count2 = __result.Count; k < count2; k++)
			{
				if (UnnamedPlugin.ShouldBeUnnamed && !UnnamedPlugin.IsUnnamed(__result[k]) && !UnnamedPlugin.IsUnnamedUnique(__result[k]))
				{
					Item component3 = __result[k].GetComponent<Item>();
					GameObject unnamedVariant3 = UnnamedPlugin.GetUnnamedVariant(component3);
					UnnamedPlugin.Log.LogInfo((object)("Turning " + component3.GetName() + " into " + unnamedVariant3.GetComponent<Item>().GetName() + "."));
					__result[k] = unnamedVariant3;
				}
			}
		}
	}
}
namespace UnnamedProducts.Extensions
{
	public static class VectorExt
	{
		public static float SquareDistance(this Vector3 a, Vector3 b)
		{
			//IL_0000: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.y - b.y;
			float num3 = a.z - b.z;
			return num * num + num2 * num2 + num3 * num3;
		}

		public static bool CompareDistanceFast(this Vector3 a, Vector3 b, float distance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return a.SquareDistance(b) <= distance * distance;
		}
	}
}
namespace UnnamedProducts.Compatibility
{
	public static class Unnamed4FoodCompatibility
	{
		private static bool _isLoaded;

		private static bool? _enabled;

		private static List<string> itemList = new List<string>(7) { "Chrisps Blue", "Chrisps Red", "Beans", "Extra Extreme Energy Drink", "bandaid", "Climbers Chalk", "IceAxe" };

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("com.github.BurningSulphur.Scouting4Food");
					UnnamedPlugin.Log.LogInfo((object)("Scouting4Food support is " + (_enabled.Value ? "enabled" : "disabled")));
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void LoadCompatibilityBundle(UnnamedPlugin loader)
		{
			UnnamedPlugin loader2 = loader;
			ModDefinition modDefinition = ModDefinition.GetOrCreate(Chainloader.PluginInfos["com.github.BurningSulphur.Scouting4Food"]);
			if (modDefinition.Content.Count >= 14)
			{
				UnnamedPlugin.Log.LogInfo((object)("Loading " + modDefinition.Name + " bundle immediately!"));
				LoadBundle(loader2, modDefinition);
				_isLoaded = true;
				return;
			}
			UnnamedPlugin.Log.LogInfo((object)("Loading " + modDefinition.Name + " bundle later..."));
			BundleLoader.OnBundleLoaded += delegate(PeakBundle bundle)
			{
				if (bundle.Mod.Id == modDefinition.Id && !_isLoaded && modDefinition.Content.Count >= 14)
				{
					LoadBundle(loader2, modDefinition);
					_isLoaded = true;
				}
			};
		}

		private static void LoadBundle(UnnamedPlugin loader, ModDefinition modDefinition)
		{
			ModDefinition modDefinition2 = modDefinition;
			UnnamedPlugin loader2 = loader;
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)loader2, "unnamed4food.peakbundle", (Action<PeakBundle>)delegate(PeakBundle peakBundle)
			{
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				foreach (IContent item2 in modDefinition2.Content)
				{
					UnityItemContent val = (UnityItemContent)(object)((item2 is UnityItemContent) ? item2 : null);
					if (val != null)
					{
						Item item = val.Item;
						if (item != null && itemList.Contains(CleanItemName(((Object)((Component)item).gameObject).name)))
						{
							string nameToUse = CleanItemName(((Object)((Component)item).gameObject).name);
							string itemName = item.UIData.itemName;
							GameObject gameObject = ((Component)val.Item).gameObject;
							GameObject go = loader2.GenerateInstancedVariant(gameObject, nameToUse);
							Item it = go.gameObject.GetComponent<Item>();
							loader2.CopyUnnamedMaterials(ref go, peakBundle);
							loader2.CopyUnnamedIcons(ref it, peakBundle);
							PopulateUnnamedData(ref it, peakBundle, loader2);
							loader2.CopyExplosionData(ref it, peakBundle);
							LootData component = go.gameObject.GetComponent<LootData>();
							Object.Destroy((Object)(object)component);
							loader2.AddItemToDatabase(itemName, go.gameObject);
							new ItemContent(it).Register(ModDefinition.GetOrCreate(UnnamedPlugin.UnnamedInfo));
						}
					}
				}
				UnnamedPlugin.Log.LogInfo((object)("UNNAMED items for " + modDefinition2.Name + " are loaded!"));
			});
		}

		private static void PopulateUnnamedData(ref Item it, PeakBundle peakBundle, UnnamedPlugin loader)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			loader.PopulateUnnamedData(ref it, peakBundle);
			string itemName = it.UIData.itemName;
			if (!(itemName == "Ice Axe"))
			{
				if (itemName == "Can o' Beans")
				{
					Action_Spawn component = ((Component)it).gameObject.GetComponent<Action_Spawn>();
					GameObject val = Object.Instantiate<GameObject>(component.objectToSpawn);
					((Object)val).name = "Unnamed" + CleanItemName(((Object)component.objectToSpawn).name).Replace("Unnamed", "");
					AOE componentInChildren = val.GetComponentInChildren<AOE>();
					if (componentInChildren != null && !UnnamedPlugin.IsUnnamed(((Component)componentInChildren).gameObject))
					{
						UnnamedPlugin.RenameToUnnamed(((Component)componentInChildren).gameObject);
					}
					component.objectToSpawn = loader.RegisterOrGetNetworkPrefab(val);
					Object.DontDestroyOnLoad((Object)(object)val);
					val.SetActive(false);
				}
				return;
			}
			MonoBehaviour[] components = ((Component)it).GetComponents<MonoBehaviour>();
			MonoBehaviour[] array = components;
			foreach (MonoBehaviour val2 in array)
			{
				Type type = ((object)val2).GetType();
				if (type.Name.Contains("IceAxe"))
				{
					FieldInfo field = type.GetField("instantiateOnBreak");
					GameObject val3 = (GameObject)field.GetValue(val2);
					GameObject go = Object.Instantiate<GameObject>(val3);
					((Object)go).name = "Unnamed" + CleanItemName(((Object)val3).name);
					Object.DontDestroyOnLoad((Object)(object)go);
					go.SetActive(false);
					loader.CopyUnnamedMaterials(ref go, peakBundle);
					go = loader.RegisterOrGetItemPrefab(go);
					field.SetValue(val2, go);
					break;
				}
			}
		}

		private static string CleanItemName(string dirtyName)
		{
			return dirtyName.Replace("com.github.BurningSulphur.Scouting4Food:", "").Replace("(Clone)", "").Replace("(Instanced)", "");
		}

		public static void ApplyUnnamedModifierToAffliction(ref Affliction affliction)
		{
		}
	}
	public static class UnnamedCanadianCompatibility
	{
		private static bool _isLoaded;

		private static bool? _enabled;

		private static List<string> itemList = new List<string>(13)
		{
			"AllDressed", "BigJoe", "CoffeeBar", "HostCuttings", "MapleCookies", "MapleToffee", "PapinoCookies", "Paw Cakes", "PoorManPudding", "Airplane Poutine",
			"Tourtiere", "SugarFudge", "SpruceBeer"
		};

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("com.github.MiiMii1205.CanadianCuisine");
					UnnamedPlugin.Log.LogInfo((object)("CannadianCuisine support is " + (_enabled.Value ? "enabled" : "disabled")));
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void LoadCompatibilityBundle(UnnamedPlugin loader)
		{
			UnnamedPlugin loader2 = loader;
			ModDefinition modDefinition = ModDefinition.GetOrCreate(Chainloader.PluginInfos["com.github.MiiMii1205.CanadianCuisine"]);
			if (modDefinition.Content.Count >= 16)
			{
				UnnamedPlugin.Log.LogInfo((object)("Loading " + modDefinition.Name + " bundle immediately!"));
				LoadBundle(loader2, modDefinition);
				_isLoaded = true;
				return;
			}
			UnnamedPlugin.Log.LogInfo((object)("Loading " + modDefinition.Name + " bundle later..."));
			BundleLoader.OnBundleLoaded += delegate(PeakBundle bundle)
			{
				if (bundle.Contains("AllDressed.prefab") && bundle.Mod.Id == modDefinition.Id && !_isLoaded)
				{
					LoadBundle(loader2, modDefinition);
					_isLoaded = true;
				}
			};
		}

		private static void LoadBundle(UnnamedPlugin loader, ModDefinition modDefinition)
		{
			ModDefinition modDefinition2 = modDefinition;
			UnnamedPlugin loader2 = loader;
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)loader2, "unnamedcanadian.peakbundle", (Action<PeakBundle>)delegate(PeakBundle peakBundle)
			{
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				foreach (IContent item2 in modDefinition2.Content)
				{
					UnityItemContent val = (UnityItemContent)(object)((item2 is UnityItemContent) ? item2 : null);
					if (val != null)
					{
						Item item = val.Item;
						if (item != null && itemList.Contains(CleanItemName(((Object)((Component)item).gameObject).name)))
						{
							string nameToUse = CleanItemName(((Object)((Component)item).gameObject).name);
							string itemName = item.UIData.itemName;
							GameObject gameObject = ((Component)val.Item).gameObject;
							GameObject go = loader2.GenerateInstancedVariant(gameObject, nameToUse);
							Item it = go.gameObject.GetComponent<Item>();
							loader2.CopyUnnamedMaterials(ref go, peakBundle);
							loader2.CopyUnnamedIcons(ref it, peakBundle);
							PopulateUnnamedData(ref it, peakBundle, loader2);
							loader2.CopyExplosionData(ref it, peakBundle);
							LootData component = go.gameObject.GetComponent<LootData>();
							Object.Destroy((Object)(object)component);
							loader2.AddItemToDatabase(itemName, go.gameObject);
							new ItemContent(it).Register(ModDefinition.GetOrCreate(UnnamedPlugin.UnnamedInfo));
						}
					}
				}
				UnnamedPlugin.Log.LogInfo((object)("UNNAMED items for " + modDefinition2.Name + " are loaded!"));
			});
		}

		private static void PopulateUnnamedData(ref Item it, PeakBundle peakBundle, UnnamedPlugin loader)
		{
			//IL_0137: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: 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)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			loader.PopulateUnnamedData(ref it, peakBundle);
			switch (it.UIData.itemName)
			{
			case "Spruce Beer":
			{
				Action_Spawn component = ((Component)it).gameObject.GetComponent<Action_Spawn>();
				GameObject val11 = Object.Instantiate<GameObject>(component.objectToSpawn);
				((Object)val11).name = "Unnamed" + CleanItemName(((Object)component.objectToSpawn).name).Replace("Unnamed", "");
				AOE componentInChildren = val11.GetComponentInChildren<AOE>();
				if (componentInChildren != null && !UnnamedPlugin.IsUnnamed(((Component)componentInChildren).gameObject))
				{
					UnnamedPlugin.RenameToUnnamed(((Component)componentInChildren).gameObject);
				}
				component.objectToSpawn = loader.RegisterOrGetNetworkPrefab(val11);
				Object.DontDestroyOnLoad((Object)(object)val11);
				val11.SetActive(false);
				break;
			}
			case "All Dressed":
			{
				GameObject val13 = peakBundle.LoadAsset<GameObject>("UnnamedAllDressedWrapper.prefab");
				GameObject val14 = Object.Instantiate<GameObject>(val13, ((Component)it.mainRenderer).transform, false);
				val14.transform.localPosition = new Vector3(0f, 0f, 0.017f);
				val14.transform.localScale = Vector3.one;
				val14.transform.localRotation = new Quaternion(0f, 1f, 0f, 0f);
				ShaderExtensions.ReplaceShaders(val14);
				it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val14.GetComponent<Renderer>());
				break;
			}
			case "Poor Man Pudding":
			{
				MeshFilter[] componentsInChildren4 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val10 in componentsInChildren4)
				{
					if (((Object)((Component)val10).gameObject).name == "plastic")
					{
						val10.mesh = peakBundle.LoadAsset<Mesh>("UnnamedPoorManPuddingPackaging.fbx");
					}
				}
				break;
			}
			case "Poutine":
			{
				MeshFilter[] componentsInChildren5 = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val12 in componentsInChildren5)
				{
					if (((Object)((Component)val12).gameObject).name == "plastic")
					{
						val12.mesh = peakBundle.LoadAsset<Mesh>("UnnamedPoutinePackaging.fbx");
					}
				}
				break;
			}
			case "Sugar Fudge":
			{
				MeshFilter[] componentsInChildren = ((Component)it).GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val5 in componentsInChildren)
				{
					if (((Object)((Component)val5).gameObject).name == "SugarFudge")
					{
						val5.mesh = peakBundle.LoadAsset<Mesh>("UnnamedPackagedSugarFudge.fbx");
					}
				}
				HandVisual[] componentsInChildren2 = ((Component)it).GetComponentsInChildren<HandVisual>(true);
				foreach (HandVisual val6 in componentsInChildren2)
				{
					if (((Object)((Component)val6).gameObject).name == "Hand_L")
					{
						((Component)val6).transform.localPosition = new Vector3(-0.429f, 0.0044f, 0.218f);
						((Component)val6).transform.localRotation = new Quaternion(0.092272826f, 0.7010605f, 0.7010605f, -0.092272826f);
					}
					if (((Object)((Component)val6).gameObject).name == "Hand_R")
					{
						((Component)val6).transform.localPosition = new Vector3(0.429f, 0.0044f, 0.218f);
						((Component)val6).transform.localRotation = new Quaternion(-0.09232013f, 0.7010542f, 0.7010542f, 0.09232013f);
					}
				}
				GameObject val7 = peakBundle.LoadAsset<GameObject>("UnnamedSugarFudgeWrapper.prefab");
				GameObject val8 = Object.Instantiate<GameObject>(val7, ((Component)it.mainRenderer).transform, false);
				val8.transform.localPosition = new Vector3(0f, 0f, 0.017f);
				val8.transform.localScale = Vector3.one;
				val8.transform.localRotation = Quaternion.identity;
				ShaderExtensions.ReplaceShaders(val8);
				Renderer[] componentsInChildren3 = val8.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val9 in componentsInChildren3)
				{
					it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val9);
				}
				((Component)it.mainRenderer).transform.localRotation = new Quaternion(-0.258819f, 0f, 0f, 0.9659259f);
				it.offsetLuggagePosition = new Vector3(0f, 0.4f, -0.27f);
				it.offsetLuggageRotation = new Vector3(-120f, 0f, 180f);
				Object.Destroy((Object)(object)((Component)it.mainRenderer).GetComponent<Collider>());
				break;
			}
			case "Tourtiere":
			{
				GameObject val = peakBundle.LoadAsset<GameObject>("UnnamedTourtiereAluminiumPlate.prefab");
				GameObject val2 = peakBundle.LoadAsset<GameObject>("UnnamedTourtiereLabel.prefab");
				GameObject val3 = Object.Instantiate<GameObject>(val, ((Component)it.mainRenderer).transform, false);
				GameObject val4 = Object.Instantiate<GameObject>(val2, ((Component)it.mainRenderer).transform, false);
				ShaderExtensions.ReplaceShaders(val3);
				ShaderExtensions.ReplaceShaders(val4);
				it.addtlRenderers = CollectionExtensions.AddToArray<Renderer>(CollectionExtensions.AddToArray<Renderer>(it.addtlRenderers, val3.GetComponent<Renderer>()), val4.GetComponent<Renderer>());
				break;
			}
			}
		}

		private static string CleanItemName(string dirtyName)
		{
			return dirtyName.Replace("com.github.MiiMii1205.CanadianCuisine:", "").Replace("(Clone)", "").Replace("(Instanced)", "");
		}

		public static void ApplyUnnamedModifierToAffliction(ref Affliction affliction)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Type type = ((object)affliction).GetType();
			if (type.Name.Contains("AfflictionWithConsequence"))
			{
				FieldInfo field = type.GetField("mainAffliction");
				FieldInfo field2 = type.GetField("consequentAffliction");
				Affliction affliction2 = (Affliction)field.GetValue(affliction);
				Affliction affliction3 = (Affliction)field2.GetValue(affliction);
				UnnamedPlugin.ApplyUnnamedModifierToAffliction(ref affliction2);
				UnnamedPlugin.ApplyUnnamedModifierToAffliction(ref affliction3);
				field.SetValue(affliction, affliction2);
				field2.SetValue(affliction, affliction3);
			}
			else if (type.Name.Contains("AfflictionHighJump"))
			{
				FieldInfo field3 = type.GetField("highJumpMultiplier");
				float num = (float)field3.GetValue(affliction) * UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)$"High Jump multiplier from {(float)field3.GetValue(affliction)} to {num}");
				field3.SetValue(affliction, num);
			}
		}
	}
	public static class UnnamedLuckyBlocksCompatibility
	{
		private static bool _isLoaded;

		private static bool? _enabled;

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("legocool.LuckyBlocks");
					UnnamedPlugin.Log.LogInfo((object)("Lucky Block support is " + (_enabled.Value ? "enabled" : "disabled")));
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void LoadCompatibilityBundle(UnnamedPlugin loader, Harmony harmony)
		{
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)SpawnUnnamedLuggage, 110, "Unnamed Luggage");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)SpawnFireball, 80, "Fireball");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)SetThingsOnFire, 70, "Set things on Fire");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)SpawnUnnamedRope, 95, "Unnamed Rope/Anti-Rope");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)SpawnUnnamedPiton, 95, "Unnamed Piton");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)PlaceUnnamedStove, 85, "Unnamed Portable Stove");
			Outcomes.AddOutcome((Action<LuckyBreakable, Collision>)PlaceUnnamedCannon, 95, "Unnamed Scout Cannon");
		}

		public static void PlaceUnnamedStove(LuckyBreakable lb, Collision coll)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.LookRotation(Vector3.forward, ((ContactPoint)(ref coll.contacts[0])).normal);
			PhotonNetwork.Instantiate("com.github.MiiMii1205.UnnamedProducts:UnnamedPortableStovetop_Placed", ((ContactPoint)(ref coll.contacts[0])).point, val, (byte)0, (object[])null);
		}

		public static void PlaceUnnamedCannon(LuckyBreakable lb, Collision coll)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.LookRotation(Vector3.forward, ((ContactPoint)(ref coll.contacts[0])).normal);
			PhotonNetwork.Instantiate("com.github.MiiMii1205.UnnamedProducts:UnnamedScoutCannon_Placed", ((ContactPoint)(ref coll.contacts[0])).point, val, (byte)0, (object[])null);
		}

		private static void SpawnUnnamedRope(LuckyBreakable lb, Collision col)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.LookRotation(Vector3.forward, ((ContactPoint)(ref col.contacts[0])).normal);
			GameObject val2 = (GameObject)(Random.Range(0, 2) switch
			{
				0 => PhotonNetwork.Instantiate("com.github.MiiMii1205.UnnamedProducts:UnnamedRopeAnchorForRopeShooterAnti_c", ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null), 
				1 => PhotonNetwork.Instantiate("com.github.MiiMii1205.UnnamedProducts:UnnamedRopeAnchorForRopeShooter_c", ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null), 
				_ => null, 
			});
			RopeAnchorWithRope val3 = default(RopeAnchorWithRope);
			if (val2 != null && val2.TryGetComponent<RopeAnchorWithRope>(ref val3))
			{
				val3.SpawnRope();
			}
		}

		private static void SpawnUnnamedPiton(LuckyBreakable lb, Collision col)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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)
			bool flag = 1f * Random.Range(0.5f, 1.5f) >= 1f;
			PhotonNetwork.Instantiate("com.github.MiiMii1205.UnnamedProducts:UnnamedClimbingSpikeHammered" + (flag ? "_Bad" : "_Good"), ((ContactPoint)(ref col.contacts[0])).point, Quaternion.LookRotation(-((ContactPoint)(ref col.contacts[0])).normal, Vector3.up), (byte)0, (object[])null);
			Singleton<AchievementManager>.Instance.IncrementSteamStat((STEAMSTATTYPE)3, 1);
			GameUtils.instance.IncrementPermanentItemsPlaced();
		}

		private static void SetThingsOnFire(LuckyBreakable lb, Collision col)
		{
			//IL_0025: 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_00f6: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = default(GameObject);
			if (!NetworkPrefabManager.TryGetNetworkPrefab("com.github.MiiMii1205.UnnamedProducts:StickyFireball", ref val))
			{
				return;
			}
			Collider[] array = (Collider[])(object)new Collider[20];
			int num = Physics.OverlapSphereNonAlloc(((ContactPoint)(ref col.contacts[0])).point, 5f, array, LayerMask.op_Implicit(HelperFunctions.CharacterAndDefaultMask), (QueryTriggerInteraction)1);
			if (num > 0)
			{
				for (int i = 0; i < num; i++)
				{
					Collider val2 = array[i];
					Item componentInParent = ((Component)val2).gameObject.GetComponentInParent<Item>();
					if (componentInParent != null)
					{
						StickyFireballController component = PhotonNetwork.Instantiate(((Object)val).name, ((Component)lb).transform.position, Quaternion.identity, (byte)0, (object[])null).GetComponent<StickyFireballController>();
						component.StickTo(((Component)componentInParent).gameObject);
						continue;
					}
					Character componentInParent2 = ((Component)val2).gameObject.GetComponentInParent<Character>();
					if (componentInParent2 != null)
					{
						StickyFireballController component2 = PhotonNetwork.Instantiate(((Object)val).name, ((Component)lb).transform.position, Quaternion.identity, (byte)0, (object[])null).GetComponent<StickyFireballController>();
						component2.StickTo(((Component)componentInParent2).gameObject);
					}
				}
			}
			else
			{
				PhotonNetwork.Instantiate(((Object)val).name, ((Component)lb).transform.position, Quaternion.identity, (byte)0, (object[])null);
			}
		}

		private static void SpawnUnnamedLuggage(LuckyBreakable arg1, Collision col)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.LookRotation(Vector3.forward, ((ContactPoint)(ref col.contacts[0])).normal);
			int num = 0;
			while (Util.Coinflip() && num < 4)
			{
				num++;
			}
			switch (num)
			{
			case 1:
				PhotonNetwork.Instantiate(((Object)UnnamedPlugin.BigUnnamedLuggagePrefab).name, ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null);
				break;
			case 2:
				PhotonNetwork.Instantiate(((Object)UnnamedPlugin.EpicUnnamedLuggagePrefab).name, ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null);
				break;
			case 3:
				PhotonNetwork.Instantiate(((Object)UnnamedPlugin.AncientUnnamedLuggagePrefab).name, ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null);
				break;
			default:
				PhotonNetwork.Instantiate(((Object)UnnamedPlugin.SmallUnnamedLuggagePrefab).name, ((ContactPoint)(ref col.contacts[0])).point, val, (byte)0, (object[])null);
				break;
			}
			UnnamedPlugin.Log.LogInfo((object)$"Spawned luggage at {((ContactPoint)(ref col.contacts[0])).point}");
		}

		private static void SpawnFireball(LuckyBreakable lb, Collision col)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Character.localCharacter.view.RPC("SpawnFireballRPC", (RpcTarget)0, new object[1] { ((ContactPoint)(ref col.contacts[0])).point });
			UnnamedPlugin.Log.LogInfo((object)$"Spawned luggage at {((ContactPoint)(ref col.contacts[0])).point}");
		}
	}
}
namespace UnnamedProducts.Compatibility.Patchers
{
	public static class UnnamedPiggyBankPatcher
	{
		[HarmonyPatch(typeof(PiggyBankScreen), "InitWheel")]
		[HarmonyPostfix]
		public static void InitWheelPostfix(PiggyBankScreen __instance, PiggyBankReference pg)
		{
			if (((Behaviour)__instance.currentlyHeldItem).enabled && Character.localCharacter.data.currentItem is UnnamedGarbageBagController)
			{
				((Behaviour)__instance.currentlyHeldItem).enabled = false;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void CanInteractPostfix(PiggyBankZone __instance, ref bool __result)
		{
			if (__result && Character.localCharacter.data.currentItem is UnnamedGarbageBagController)
			{
				__result = false;
			}
		}
	}
}
namespace UnnamedProducts.Behaviours
{
	public class Action_SpawnAndGrab : ItemAction
	{
		public Item itemToSpawn;

		public override void RunAction()
		{
			if (Object.op_Implicit((Object)(object)((ItemActionBase)this).character))
			{
				((MonoBehaviour)((ItemActionBase)this).character).StartCoroutine(SpawnItemDelayed(((ItemActionBase)this).item.GetData<FloatItemData>((DataEntryKey)11).Value <= 0f));
			}
		}

		private IEnumerator SpawnItemDelayed(bool shouldBeConsumed)
		{
			Character c = ((ItemActionBase)this).character;
			Item it = itemToSpawn;
			if (shouldBeConsumed)
			{
				float timeout = 2f;
				while ((Object)(object)this != (Object)null)
				{
					timeout -= Time.deltaTime;
					if (timeout <= 0f)
					{
						yield break;
					}
					yield return null;
				}
			}
			else
			{
				yield return (object)new WaitForEndOfFrame();
			}
			GameUtils.instance.InstantiateAndGrab(it, c, 0);
		}
	}
	public class AntifreezeExplosionController : MonoBehaviour
	{
		public GameObject explosionPrefab;

		public GameObject stickyFireball;

		public int m_amountOfFireballs = 5;

		private void Start()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00d8: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(explosionPrefab, ((Component)this).transform.position, ((Component)this).transform.rotation);
			val.SetActive(true);
			for (int i = 0; i < m_amountOfFireballs; i++)
			{
				Quaternion val2 = Quaternion.Euler(360f, 360f / (float)m_amountOfFireballs * (float)(i + 1), 330f);
				Vector3 val3 = Vector3.ProjectOnPlane(val2 * (Vector3.up * 5f), Vector3.up);
				Vector3 val4 = ((Vector3)(ref val3)).normalized * 0.125f + Vector3.up * 0.0625f;
				GameObject val5 = NetworkPrefabManager.SpawnNetworkPrefab(((Object)stickyFireball).name, val.transform.position + val4, Quaternion.identity, (byte)0, (object[])null);
				val5.gameObject.SetActive(true);
				val5.GetComponent<Rigidbody>().AddForce(val2 * (Vector3.up * 5f), (ForceMode)2);
			}
		}
	}
	public class CharacterBurnController : MonoBehaviourPun
	{
		public bool m_hasFire;

		public HashSet<StickyFireballController> m_fires;

		private void Awake()
		{
			m_fires = new HashSet<StickyFireballController>();
		}

		public void ExtinguishFires()
		{
			((MonoBehaviourPun)this).photonView.RPC("ExtinguishRPC", (RpcTarget)0, Array.Empty<object>());
		}

		[PunRPC]
		public void ExtinguishRPC()
		{
			if (!((MonoBehaviourPun)this).photonView.IsMine || m_fires.Count <= 0)
			{
				return;
			}
			m_hasFire = true;
			foreach (StickyFireballController fire in m_fires)
			{
				fire.Extinguish();
			}
			m_hasFire = false;
		}

		[PunRPC]
		public void SpawnFireballRPC(Vector3 position)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = default(GameObject);
			if (NetworkPrefabManager.TryGetNetworkPrefab("com.github.MiiMii1205.UnnamedProducts:AntifreezeExplosion", ref val))
			{
				Object.Instantiate<GameObject>(val, position, Quaternion.identity);
			}
		}

		public void RegisterFire(StickyFireballController stickyFireballController)
		{
			m_fires.Add(stickyFireballController);
		}

		public void DeRegisterFire(StickyFireballController stickyFireballController)
		{
			m_fires.Remove(stickyFireballController);
		}
	}
	public class ExplodeOnBurningAction : ItemAction
	{
		public bool dontRunIfOutOfFuel;

		private static bool HoldsLitItem(Character c)
		{
			if (Object.op_Implicit((Object)(object)c.data.currentItem) && c.data.currentItem.HasData((DataEntryKey)3))
			{
				return c.data.currentItem.GetData<BoolItemData>((DataEntryKey)3).Value;
			}
			return false;
		}

		private static bool HasHeatingElement(Character c)
		{
			Affliction val = default(Affliction);
			if (c.refs.afflictions.HasAfflictionType((AfflictionType)5, ref val))
			{
				return val.timeElapsed > 1f;
			}
			return false;
		}

		private static bool IsCurrentlyBurning(Character c)
		{
			CharacterBurnController characterBurnController = default(CharacterBurnController);
			if (((Component)c).TryGetComponent<CharacterBurnController>(ref characterBurnController))
			{
				return characterBurnController.m_hasFire;
			}
			return false;
		}

		public override void RunAction()
		{
			ItemCooking val = default(ItemCooking);
			if ((HoldsLitItem(((ItemActionBase)this).character) || HasHeatingElement(((ItemActionBase)this).character) || IsCurrentlyBurning(((ItemActionBase)this).character)) && ((Component)((ItemActionBase)this).item).TryGetComponent<ItemCooking>(ref val) && (!dontRunIfOutOfFuel || !(((ItemComponent)val).item.GetData<FloatItemData>((DataEntryKey)10).Value <= 0f)))
			{
				val.Explode();
			}
		}
	}
	public class LiquidController : MonoBehaviour
	{
		private static readonly int FillAmount = Shader.PropertyToID("_FillAmount");

		private static readonly int WobbleX = Shader.PropertyToID("_WobbleX");

		private static readonly int WobbleZ = Shader.PropertyToID("_WobbleZ");

		[SerializeField]
		public float MaxWobble = 0.03f;

		[SerializeField]
		public float WobbleSpeedMove = 1f;

		[SerializeField]
		public float fillAmount = 0.25f;

		[SerializeField]
		public float Recovery = 1f;

		[SerializeField]
		public float Thickness = 1f;

		[Range(0f, 1f)]
		public float compensateShapeAmount;

		[SerializeField]
		public Mesh mesh;

		[SerializeField]
		public Renderer rend;

		private Vector3 m_pos;

		private Vector3 m_lastPos;

		private Vector3 m_velocity;

		private Quaternion m_lastRot;

		private Vector3 m_angularVelocity;

		private float m_wobbleAmountX;

		private float m_wobbleAmountZ;

		private float m_wobbleAmountToAddX;

		private float m_wobbleAmountToAddZ;

		private float m_pulse;

		private float m_sinewave;

		private float m_time = 0.5f;

		private Vector3 m_comp;

		private void Start()
		{
			GetMeshAndRend();
		}

		private void OnValidate()
		{
			GetMeshAndRend();
		}

		private void GetMeshAndRend()
		{
			if ((Object)(object)mesh == (Object)null)
			{
				mesh = ((Component)this).GetComponent<MeshFilter>().sharedMesh;
			}
			if ((Object)(object)rend == (Object)null)
			{
				rend = ((Component)this).GetComponent<Renderer>();
			}
		}

		private void Update()
		{
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: 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_00fa: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			m_time += Time.deltaTime;
			if (Time.deltaTime != 0f)
			{
				m_wobbleAmountToAddX = Mathf.Lerp(m_wobbleAmountToAddX, 0f, Time.deltaTime * Recovery);
				m_wobbleAmountToAddZ = Mathf.Lerp(m_wobbleAmountToAddZ, 0f, Time.deltaTime * Recovery);
				m_pulse = MathF.PI * 2f * WobbleSpeedMove;
				m_sinewave = Mathf.Lerp(m_sinewave, Mathf.Sin(m_pulse * m_time), Time.deltaTime * Mathf.Clamp(((Vector3)(ref m_velocity)).magnitude + ((Vector3)(ref m_angularVelocity)).magnitude, Thickness, 10f));
				m_wobbleAmountX = m_wobbleAmountToAddX * m_sinewave;
				m_wobbleAmountZ = m_wobbleAmountToAddZ * m_sinewave;
				m_velocity = (m_lastPos - ((Component)this).transform.position) / Time.deltaTime;
				m_angularVelocity = GetAngularVelocity(m_lastRot, ((Component)this).transform.rotation);
				m_wobbleAmountToAddX += Mathf.Clamp((m_velocity.x + m_velocity.y * 0.2f + m_angularVelocity.z + m_angularVelocity.y) * MaxWobble, 0f - MaxWobble, MaxWobble);
				m_wobbleAmountToAddZ += Mathf.Clamp((m_velocity.z + m_velocity.y * 0.2f + m_angularVelocity.x + m_angularVelocity.y) * MaxWobble, 0f - MaxWobble, MaxWobble);
			}
			rend.sharedMaterial.SetFloat(WobbleX, m_wobbleAmountX);
			rend.sharedMaterial.SetFloat(WobbleZ, m_wobbleAmountZ);
			UpdatePos();
			m_lastPos = ((Component)this).transform.position;
			m_lastRot = ((Component)this).transform.rotation;
		}

		private void UpdatePos()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0096: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			Bounds bounds = mesh.bounds;
			Vector3 val = transform.TransformPoint(((Bounds)(ref bounds)).center);
			if (compensateShapeAmount > 0f)
			{
				if (Time.deltaTime != 0f)
				{
					m_comp = Vector3.Lerp(m_comp, val - new Vector3(0f, GetLowestPoint(), 0f), Time.deltaTime * 10f);
				}
				else
				{
					m_comp = val - new Vector3(0f, GetLowestPoint(), 0f);
				}
				m_pos = val - ((Component)this).transform.position - new Vector3(0f, fillAmount - m_comp.y * compensateShapeAmount, 0f);
			}
			else
			{
				m_pos = val - ((Component)this).transform.position - new Vector3(0f, fillAmount, 0f);
			}
			rend.sharedMaterial.SetVector(FillAmount, Vector4.op_Implicit(m_pos));
		}

		private static Vector3 GetAngularVelocity(Quaternion foreLastFrameRotation, Quaternion lastFrameRotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = lastFrameRotation * Quaternion.Inverse(foreLastFrameRotation);
			if (Mathf.Abs(val.w) > 0.9995117f)
			{
				return Vector3.zero;
			}
			float num2;
			if (val.w < 0f)
			{
				float num = Mathf.Acos(0f - val.w);
				num2 = -2f * num / (Mathf.Sin(num) * Time.deltaTime);
			}
			else
			{
				float num3 = Mathf.Acos(val.w);
				num2 = 2f * num3 / (Mathf.Sin(num3) * Time.deltaTime);
			}
			Vector3 zero = default(Vector3);
			((Vector3)(ref zero))..ctor(val.x * num2, val.y * num2, val.z * num2);
			if (float.IsNaN(zero.z))
			{
				zero = Vector3.zero;
				return zero;
			}
			return zero;
		}

		private float GetLowestPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			Vector3 val = Vector3.zero;
			Vector3[] vertices = mesh.vertices;
			int i = 0;
			for (int num2 = vertices.Length; i < num2; i++)
			{
				Vector3 val2 = ((Component)this).transform.TransformPoint(vertices[i]);
				if (val2.y < num)
				{
					num = val2.y;
					val = val2;
				}
			}
			return val.y;
		}
	}
	public class LuggageBrandHandler : MonoBehaviourPunCallbacks
	{
		public bool isUnnamed;

		public bool shouldBeUnnamed;

		public Luggage luggage;

		[PunRPC]
		public void RPC_RequestUpdate()
		{
			if (((MonoBehaviourPun)this).photonView.IsMine && shouldBeUnnamed)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_SetLuggageAsUnnamed", (RpcTarget)0, new object[1] { true });
			}
		}

		[PunRPC]
		public void RPC_SetLuggageAsUnnamed(bool hardSet)
		{
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			if (hardSet)
			{
				shouldBeUnnamed = true;
			}
			if (!shouldBeUnnamed || isUnnamed)
			{
				return;
			}
			UnnamedPlugin.Log.LogInfo((object)$"Setting luggage {luggage} brand to unnamed.");
			((Object)((Component)luggage).gameObject).name = "com.github.MiiMii1205.UnnamedProducts:Unnamed" + ((Object)((Component)luggage).gameObject).name;
			Renderer[] componentsInChildren = ((Component)luggage).GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				List<Material> list = new List<Material>();
				for (int j = 0; j < val.materials.Length; j++)
				{
					switch (((Object)val.materials[j]).name.Replace("(Instance)", "").Replace("(Clone)", "").Trim())
					{
					case "M_Luggage":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.SmallLuggageMaterial));
						break;
					case "M_Luggage_interior":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.SmallLuggageInteriorMaterial));
						break;
					case "M_Luggage_large":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.LargeLuggageMaterial));
						break;
					case "M_Luggage_interior_large":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.LargeLuggageInteriorMaterial));
						break;
					case "M_Luggage_ancient":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.AncientLuggageMaterial));
						break;
					case "M_Luggage_epic":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.EpicLuggageMaterial));
						break;
					case "M_Metal":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.AncientLuggageMetalMaterial));
						break;
					case "M_Rock_Crystal":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.AncientLuggageCrystalMaterial));
						break;
					case "M_Rock_Volcano":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueCalderaMaterial));
						break;
					case "M_DesertSand":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueMesaMaterial));
						break;
					case "M_Rock_peak Snow":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueAlpineMaterial));
						break;
					case "M_Rock 1":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueTropicsMaterial));
						break;
					case "M_Forest_rock":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueRootsMaterial));
						break;
					case "M_SaltRock":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueShoreMaterial));
						break;
					case "M_Rock_staticTopColour":
						list.Add(Object.Instantiate<Material>(UnnamedPlugin.RespawnStatueRockVFXMaterial));
						break;
					default:
						list.Add(val.materials[j]);
						break;
					}
				}
				val.SetSharedMaterials(list);
				val.SetMaterials(list);
			}
			foreach (HeightBasedSpawnListEntry heightBasedSpawnPool in ((Spawner)luggage).heightBasedSpawnPools)
			{
				heightBasedSpawnPool.spawnPool |= UnnamedPlugin.UnnamedSpawnPool;
			}
			isUnnamed = true;
		}

		public void SetLuggageAsUnnamed()
		{
			((MonoBehaviourPun)this).photonView.RPC("RPC_SetLuggageAsUnnamed", (RpcTarget)0, new object[1] { false });
		}

		public override void OnEnable()
		{
			if (((MonoBehaviourPun)this).photonView.IsMine && shouldBeUnnamed)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_SetLuggageAsUnnamed", (RpcTarget)0, new object[1] { true });
			}
		}

		public void Start()
		{
			if (!((MonoBehaviourPun)this).photonView.IsMine && shouldBeUnnamed && !isUnnamed)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_RequestUpdate", (RpcTarget)2, Array.Empty<object>());
			}
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			if (((MonoBehaviourPun)this).photonView.IsMine && !newPlayer.IsLocal && shouldBeUnnamed)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_SetLuggageAsUnnamed", newPlayer, new object[1] { true });
			}
		}
	}
	[RequireComponent(typeof(PhotonView))]
	[RequireComponent(typeof(PositionSyncer))]
	public class StickyFireballController : MonoBehaviourPun
	{
		private static readonly Quaternion SmokeRotation = new Quaternion(-0.7071068f, 2.9802315E-08f, -7.450579E-09f, 0.70710677f);

		public Rigidbody rb;

		public Item? m_item;

		public DestroyAfterTime destroyAfterTime;

		public bool m_isStuck;

		public bool m_canStick;

		private float m_startupTime = 0.125f;

		private Collider m_collider;

		private ParticleSystem m_smokeParticles;

		private ParticleSystem m_fireParticles;

		private AudioSource m_loop;

		private CharacterBurnController? m_burningCharacter;

		private Coroutine rainCheckCoroutine;

		public SFX_Instance[] fireStart;

		public SFX_Instance[] extinguish;

		public GameObject disableOnExtingush;

		private bool m_isStuckToCharacter;

		private bool m_isStuckToItem;

		public bool m_isBurning;

		public static GameObject FireballPrefab = null;

		private void Awake()
		{
			//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_0102: Unknown result type (might be due to invalid IL or missing references)
			if (rb == null)
			{
				rb = ((Component)this).GetComponent<Rigidbody>();
			}
			if (m_collider == null)
			{
				m_collider = ((Component)rb).GetComponent<Collider>();
			}
			if (m_loop == null)
			{
				m_loop = ((Component)rb).GetComponent<AudioSource>();
			}
			if (destroyAfterTime == null)
			{
				destroyAfterTime = ((Component)this).GetComponent<DestroyAfterTime>();
			}
			if (!Object.op_Implicit((Object)(object)m_smokeParticles))
			{
				ParticleSystem[] componentsInChildren = ((Component)this).GetComponentsInChildren<ParticleSystem>();
				ParticleSystem[] array = componentsInChildren;
				foreach (ParticleSystem val in array)
				{
					if (((Object)((Component)val).gameObject).name == "VFX_Smoke_Lit")
					{
						m_smokeParticles = val;
					}
					if (((Object)((Component)val).gameObject).name == "VFX_Fire")
					{
						m_fireParticles = val;
					}
				}
			}
			if (disableOnExtingush == null)
			{
				disableOnExtingush = ((Component)((Component)this).transform.Find("DisableOnExtinguish")).gameObject;
			}
			((Behaviour)destroyAfterTime).enabled = false;
			rb.AddForce(-Physics.gravity * 0.25f, (ForceMode)1);
		}

		private void Start()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			m_smokeParticles.Play(true);
			m_isBurning = true;
			SFX_Instance[] array = fireStart;
			foreach (SFX_Instance val in array)
			{
				val.Play(((Component)this).transform.position);
			}
			((MonoBehaviour)this).StartCoroutine(EnableSickyness());
			rainCheckCoroutine = ((MonoBehaviour)this).StartCoroutine(CheckForRain());
		}

		private void Update()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			((Component)m_smokeParticles).transform.rotation = SmokeRotation;
		}

		private IEnumerator CheckForRain()
		{
			Transform fireballTransform = ((Component)this).transform;
			while (Object.op_Implicit((Object)(object)WindChillZone.instance))
			{
				yield return (object)new WaitForSeconds(2f);
				if (WindChillZone.instance.windActive && ((Bounds)(ref WindChillZone.instance.windZoneBounds)).Contains(fireballTransform.position))
				{
					UnnamedPlugin.Log.LogInfo((object)"Wind is blowing. Fireball will extinguish.");
					Extinguish();
					break;
				}
			}
		}

		private IEnumerator EnableSickyness()
		{
			m_canStick = false;
			yield return (object)new WaitForSeconds(m_startupTime);
			UnnamedPlugin.Log.LogInfo((object)("Fireball " + ((Object)((Component)this).gameObject).name + " is now sticky."));
			m_canStick = true;
		}

		private void OnCollisionEnter(Collision other)
		{
			//IL_0322: 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_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected I4, but got Unknown
			StickyFireballController stickyFireballController = default(StickyFireballController);
			if (!m_canStick || m_isStuck || other.gameObject.TryGetComponent<StickyFireballController>(ref stickyFireballController))
			{
				return;
			}
			Character componentInParent = other.gameObject.GetComponentInParent<Character>();
			ContactPoint contact;
			if (componentInParent != null && componentInParent.IsLocal)
			{
				UnnamedPlugin.Log.LogInfo((object)("Sticking Fireball " + ((Object)((Component)this).gameObject).name + " to " + componentInParent.characterName + "..."));
				((MonoBehaviourPun)this).photonView.RequestOwnership();
				rb.isKinematic = true;
				m_collider.enabled = false;
				Transform transform = ((Component)this).transform;
				contact = other.GetContact(0);
				transform.position = ((ContactPoint)(ref contact)).point;
				Transform transform2 = ((Component)other.rigidbody).transform;
				int num = -1;
				List<Bodypart> partList = componentInParent.refs.ragdoll.partList;
				contact = other.GetContact(0);
				Bodypart val = ExtCollections.FindClosest<Bodypart>(partList, ((ContactPoint)(ref contact)).point);
				if (val != null)
				{
					transform2 = ((Component)val.rig).transform;
					num = (int)val.partType;
				}
				m_burningCharacter = ExtGameObject.GetOrAddComponent<CharacterBurnController>(((Component)componentInParent).gameObject);
				m_burningCharacter.m_hasFire = true;
				m_burningCharacter.RegisterFire(this);
				((Component)rb).transform.SetParent(transform2, true);
				((Component)rb).transform.localPosition = ExtDataTypes.ToVec(0f);
				((MonoBehaviourPun)this).photonView.RPC("BurnCharacterRPC", (RpcTarget)0, new object[2]
				{
					componentInParent.view.ViewID,
					num
				});
				m_isStuckToCharacter = true;
			}
			else
			{
				Item componentInParent2 = other.gameObject.GetComponentInParent<Item>();
				if (componentInParent2 != null && (int)componentInParent2.itemState == 0)
				{
					UnnamedPlugin.Log.LogInfo((object)("Sticking Fireball " + ((Object)((Component)this).gameObject).name + " to " + componentInParent2.UIData.itemName + " [" + ((Object)((Component)componentInParent2).gameObject).name + "]..."));
					rb.isKinematic = true;
					m_collider.enabled = false;
					Transform transform3 = ((Component)this).transform;
					contact = other.GetContact(0);
					transform3.position = ((ContactPoint)(ref contact)).point;
					((Component)rb).transform.SetParent(((Component)other.rigidbody).transform, true);
					((Component)rb).transform.localPosition = ExtDataTypes.ToVec(0f);
					((MonoBehaviourPun)this).photonView.RPC("BurnItemRPC", (RpcTarget)0, new object[1] { ((Component)componentInParent2).GetComponent<PhotonView>() });
				}
				else
				{
					UnnamedPlugin.Log.LogInfo((object)("Sticking Fireball " + ((Object)((Component)this).gameObject).name + " to " + ((Object)other.gameObject).name + "..."));
					rb.isKinematic = true;
					m_collider.enabled = false;
					Transform transform4 = ((Component)this).transform;
					contact = other.GetContact(0);
					transform4.position = ((ContactPoint)(ref contact)).point;
					((Component)rb).transform.SetParent(other.gameObject.transform, true);
				}
			}
			((MonoBehaviourPun)this).photonView.RPC("StickToSurfaceRPC", (RpcTarget)0, Array.Empty<object>());
		}

		[PunRPC]
		public void StickToSurfaceRPC()
		{
			UnnamedPlugin.Log.LogInfo((object)("Fireball " + ((Object)((Component)this).gameObject).name + " is stuck on " + ((Object)((Component)this).gameObject.transform.parent).name));
			m_isStuck = true;
			if (((MonoBehaviourPun)this).photonView.IsMine)
			{
				((MonoBehaviour)this).StartCoroutine(DoExtinguish(destroyAfterTime.time));
			}
		}

		[PunRPC]
		public void BurnItemRPC(PhotonView item)
		{
			m_item = ((Component)item).GetComponent<Item>();
			UnnamedPlugin.Log.LogInfo((object)("Fireball " + ((Object)((Component)this).gameObject).name + " will stick to item " + m_item.UIData.itemName + " [" + ((Object)((Component)m_item).gameObject).name + "]..."));
		}

		[PunRPC]
		public void CookItemRPC()
		{
			if (Object.op_Implicit((Object)(object)m_item))
			{
				UnnamedPlugin.Log.LogInfo((object)("Cooking " + m_item.UIData.itemName + " [" + ((Object)((Component)m_item).gameObject).name + "]..."));
			}
		}

		[PunRPC]
		public void BurnCharacterRPC(int cid, int bodypart)
		{
			Character val = default(Character);
			if (Character.GetCharacterWithPhotonID(cid, ref val))
			{
				UnnamedPlugin.Log.LogInfo((object)("Fireball " + ((Object)((Component)this).gameObject).name + " will stick to character " + val.characterName + "..."));
			}
		}

		public void Extinguish(float delay = 0f)
		{
			UnnamedPlugin.Log.LogInfo((object)("Fireball " + ((Object)((Component)this).gameObject).name + " got extinguished"));
			if (rainCheckCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rainCheckCoroutine);
			}
			if (((MonoBehaviourPun)this).photonView.IsMine)
			{
				((MonoBehaviour)this).StartCoroutine(DoExtinguish(delay));
			}
		}

		public void StickTo(GameObject sticking)
		{
			//IL_00e4: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			Character componentInParent = sticking.GetComponentInParent<Character>();
			if (componentInParent != null && componentInParent.IsLocal)
			{
				((MonoBehaviourPun)this).photonView.RequestOwnership();
				rb.isKinematic = true;
				m_collider.enabled = false;
				Transform transform = sticking.transform;
				m_burningCharacter = ExtGameObject.GetOrAddComponent<CharacterBurnController>(((Component)componentInParent).gameObject);
				m_burningCharacter.m_hasFire = true;
				m_burningCharacter.RegisterFire(this);
				((Component)rb).transform.SetParent(transform, true);
				((Component)rb).transform.localPosition = ExtDataTypes.ToVec(0f);
				((MonoBehaviourPun)this).photonView.RPC("BurnCharacterRPC", (RpcTarget)0, new object[2]
				{
					componentInParent.view.ViewID,
					-1
				});
				m_isStuckToCharacter = true;
			}
			else
			{
				Item componentInParent2 = sticking.GetComponentInParent<Item>();
				if (componentInParent2 != null && (int)componentInParent2.itemState == 0)
				{
					UnnamedPlugin.Log.LogInfo((object)("Sticking Fireball " + ((Object)((Component)this).gameObject).name + " to " + componentInParent2.UIData.itemName + " [" + ((Object)((Component)componentInParent2).gameObject).name + "]..."));
					rb.isKinematic = true;
					m_collider.enabled = false;
					((Component)rb).transform.SetParent(sticking.transform, true);
					((Component)rb).transform.localPosition = ExtDataTypes.ToVec(0f);
					((MonoBehaviourPun)this).photonView.RPC("BurnItemRPC", (RpcTarget)0, new object[1] { ((Component)componentInParent2).GetComponent<PhotonView>() });
				}
				else
				{
					UnnamedPlugin.Log.LogInfo((object)("Sticking Fireball " + ((Object)((Component)this).gameObject).name + " to " + ((Object)sticking).name + "..."));
					rb.isKinematic = true;
					m_collider.enabled = false;
					((Component)rb).transform.SetParent(sticking.transform, true);
				}
			}
			((MonoBehaviourPun)this).photonView.RPC("StickToSurfaceRPC", (RpcTarget)0, Array.Empty<object>());
		}

		[PunRPC]
		private void RPC_Extinguish()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			m_smokeParticles.Stop();
			m_fireParticles.Stop();
			((MonoBehaviourPun)this).photonView.RPC("CookItemRPC", (RpcTarget)0, Array.Empty<object>());
			ItemCooking val = default(ItemCooking);
			if (Object.op_Implicit((Object)(object)m_item) && m_item.view.IsMine && ((Component)m_item).TryGetComponent<ItemCooking>(ref val))
			{
				val.FinishCooking();
			}
			if (Object.op_Implicit((Object)(object)m_burningCharacter) && ((MonoBehaviourPun)m_burningCharacter).photonView.IsMine)
			{
				m_burningCharacter.DeRegisterFire(this);
			}
			for (int i = 0; i < extinguish.Length; i++)
			{
				extinguish[i].Play(((Component)this).transform.position);
			}
			m_loop.Stop();
			disableOnExtingush.SetActive(false);
			m_isBurning = false;
			if (((MonoBehaviourPun)this).photonView.IsMine)
			{
				((MonoBehaviour)this).StartCoroutine(DestroyWhenCleared());
			}
		}

		private IEnumerator DestroyWhenCleared()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => m_smokeParticles.particleCount == 0 && m_fireParticles.particleCount == 0));
			PhotonNetwork.Destroy(((Component)this).gameObject);
		}

		private IEnumerator DoExtinguish(float delay = 0f)
		{
			yield return (object)new WaitForSeconds(delay);
			((MonoBehaviourPun)this).photonView.RPC("RPC_Extinguish", (RpcTarget)0, Array.Empty<object>());
		}

		public static void Burn(Bodypart bodypart)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NetworkPrefabManager.SpawnNetworkPrefab(((Object)FireballPrefab).name, ((Component)bodypart.rig).transform.position, Quaternion.identity, (byte)0, (object[])null);
			UnnamedPlugin.Log.LogInfo((object)$"Setting {bodypart.character.characterName}'s {bodypart.partType} on fire!");
			StickyFireballController component = val.GetComponent<StickyFireballController>();
			component.StickTo(((Component)bodypart).gameObject);
		}

		[ConsoleCommand]
		public static void SetOnFire(int viewId)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)PhotonNetwork.GetPhotonView(viewId)).gameObject;
			GameObject val = NetworkPrefabManager.SpawnNetworkPrefab(((Object)FireballPrefab).name, gameObject.transform.position, Quaternion.identity, (byte)0, (object[])null);
			UnnamedPlugin.Log.LogInfo((object)("Setting " + ((Object)gameObject).name + " on fire!"));
			StickyFireballController component = val.GetComponent<StickyFireballController>();
			component.StickTo(gameObject);
		}
	}
	public class StickyItemRemover : MonoBehaviourPun
	{
		[PunRPC]
		public void RPC_WashOff(int viewId)
		{
			Character component = ((Component)PhotonNetwork.GetPhotonView(viewId)).GetComponent<Character>();
			foreach (StickyItemComponent aLL_STUCK_ITEM in StickyItemComponent.ALL_STUCK_ITEMS)
			{
				if ((Object)(object)aLL_STUCK_ITEM.stuckToCharacter == (Object)(object)component && aLL_STUCK_ITEM is CactusBall && ((ItemComponent)aLL_STUCK_ITEM).photonView.IsMine)
				{
					PhotonNetwork.Destroy(((Component)aLL_STUCK_ITEM).gameObject);
				}
			}
		}
	}
	public class UnnamedIndicator : MonoBehaviour
	{
		public bool original;
	}
	public class UnnamedSkeletonHandler : MonoBehaviourPun
	{
		public Character m_character;

		[PunRPC]
		public void RPC_ClearAllStatusesBones(bool excludeCurse, int[] otherExclusions)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			int num = Enum.GetNames(typeof(STATUSTYPE)).Length;
			for (int i = 0; i < num; i++)
			{
				STATUSTYPE val = (STATUSTYPE)i;
				if ((!excludeCurse || (int)val != 5) && !otherExclusions.Contains((int)val))
				{
					m_character.refs.afflictions.SubtractStatus(val, (float)Mathf.Abs(5), false, false);
				}
			}
		}

		[PunRPC]
		public void RPC_ChangeStatsBones(int statusInt, float changeAmount, bool ifSkeleton, int feederId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_0040: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			STATUSTYPE val = (STATUSTYPE)statusInt;
			Character val2 = default(Character);
			Character.GetCharacterWithPhotonID(feederId, ref val2);
			if (ifSkeleton && !m_character.data.isSkeleton)
			{
				return;
			}
			bool passedOut = m_character.data.passedOut;
			if (changeAmount < 0f)
			{
				if ((int)val == 3)
				{
					m_character.refs.afflictions.ClearPoisonAfflictions();
					int num = Mathf.RoundToInt(Mathf.Min(m_character.refs.afflictions.GetCurrentStatus((STATUSTYPE)3), Mathf.Abs(changeAmount)) * 100f);
					if ((Object)(object)val2 != (Object)null)
					{
						GameUtils.instance.IncrementFriendPoisonHealing(num, ((MonoBehaviourPun)val2).photonView.Owner);
					}
					else
					{
						Singleton<AchievementManager>.Instance.IncrementSteamStat((STEAMSTATTYPE)4, num);
					}
				}
				if ((int)val == 0 && (Object)(object)val2 != (Object)null)
				{
					int num2 = Mathf.RoundToInt(Mathf.Min(m_character.refs.afflictions.GetCurrentStatus((STATUSTYPE)0), Mathf.Abs(changeAmount)) * 100f);
					GameUtils.instance.IncrementFriendHealing(num2, ((MonoBehaviourPun)val2).photonView.Owner);
				}
				m_character.refs.afflictions.SubtractStatus(val, Mathf.Abs(changeAmount), false, false);
			}
			else
			{
				m_character.refs.afflictions.AddStatus(val, Mathf.Abs(changeAmount), false, true, true);
			}
			float statusSum = m_character.refs.afflictions.statusSum;
			if (passedOut && statusSum <= 1f)
			{
				Debug.Log((object)"LIFE WAS SAVED");
				if ((Object)(object)val2 != (Object)null)
				{
					GameUtils.instance.ThrowEmergencyPreparednessAchievement(((MonoBehaviourPun)val2).photonView.Owner);
				}
			}
		}
	}
	public class UnnamedSpawnRestriction : MonoBehaviour
	{
		public BiomeType[] biomeType = Array.Empty<BiomeType>();

		public bool whenNightIsCold;

		public bool hasColdNightRestrictions;

		public bool hasZombieRestrictions;

		public bool whenZombieSpawnGlobally;
	}
	public class UnnamedUIManager : MonoBehaviour
	{
		public UnnamedGarbageBagScreen m_garbageBagScreen;

		public static UnnamedUIManager Instance;

		public bool GarbageBagActive => ((Component)m_garbageBagScreen).gameObject.activeSelf;

		private void Awake()
		{
			Instance = this;
		}

		public void CloseGarbageBagScreen()
		{
			UnnamedPlugin.Log.LogDebug((object)"Close garbage bag screen");
			Character.localCharacter.data.usingBackpackWheel = false;
			((Component)m_garbageBagScreen).gameObject.SetActive(false);
		}

		public void OpenGarbageBagScreen(UnnamedGarbageBagReference backpackReference)
		{
			if (!GUIManager.instance.wheelActive && !GUIManager.instance.windowBlockingInput)
			{
				Character.localCharacter.data.usingBackpackWheel = true;
				m_garbageBagScreen.InitWheel(backpackReference);
			}
		}
	}
}
namespace UnnamedProducts.Behaviours.Item
{
	public class Action_Detergent : ItemAction
	{
		public override void RunAction()
		{
			((ItemActionBase)this).character.refs.afflictions.RemoveAffliction((AfflictionType)18);
			((ItemActionBase)this).character.refs.afflictions.RemoveAffliction((AfflictionType)13);
			((ItemActionBase)this).character.refs.afflictions.RemoveAffliction((AfflictionType)15);
			((ItemActionBase)this).character.refs.afflictions.RemoveAffliction((AfflictionType)4);
			((ItemActionBase)this).character.refs.afflictions.RemoveAllThorns();
			((ItemActionBase)this).character.refs.afflictions.SubtractStatus((STATUSTYPE)10, Mathf.Abs(5f), false, false);
			((ItemActionBase)this).character.refs.afflictions.SubtractStatus((STATUSTYPE)11, Mathf.Abs(5f), false, false);
			((ItemActionBase)this).character.view.RPC("RPC_WashOff", (RpcTarget)0, new object[1] { ((ItemActionBase)this).character.view.ViewID });
		}
	}
	public class UnnamedCampfire : Campfire
	{
		public UnnamedCampfireNetworkController networkController;

		public void Awake()
		{
			base.view = ((Component)this).GetComponent<PhotonView>();
			networkController = ExtensionMethods.GetOrAddComponent<UnnamedCampfireNetworkController>(((Component)this).gameObject);
			networkController.campfire = this;
			((Campfire)this).Awake();
		}

		public void Start()
		{
			if (base.view.IsMine)
			{
				float num = base.burnsFor * UnnamedPlugin.RandomUnnamedModifier;
				base.view.RPC("RPC_UpdateBurnsFor", (RpcTarget)0, new object[1] { num });
			}
		}

		[PunRPC]
		public void RPC_UpdateBurnsFor(float newBurnFor)
		{
			base.burnsFor = newBurnFor;
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} will burn for {2} seconds", "UnnamedCampfire", ((Object)((Component)this).gameObject).name, base.burnsFor));
		}

		[PunRPC]
		public void Extinguish_Rpc()
		{
			((Campfire)this).Extinguish_Rpc();
		}

		[PunRPC]
		public void Light_Rpc(bool updateSegment, float burningFor)
		{
			((Campfire)this).Light_Rpc(updateSegment, burningFor);
		}
	}
	public class UnnamedCampfireNetworkController : MonoBehaviourPunCallbacks
	{
		public UnnamedCampfire campfire;

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			if (((Campfire)campfire).view.IsMine && !newPlayer.IsLocal)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_UpdateBurnsFor", newPlayer, new object[1] { ((Campfire)campfire).burnsFor });
			}
		}
	}
	public class UnnamedClimbingSpikeComponent : ClimbingSpikeComponent
	{
		public GameObject hammeredGoodVersionPrefab;

		public GameObject hammeredBadVersionPrefab;

		public bool isBad;

		public override void OnInstanceDataSet()
		{
			((ClimbingSpikeComponent)this).OnInstanceDataSet();
			isBad = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)DefaultBadValue).Value;
			base.hammeredVersionPrefab = (isBad ? hammeredBadVersionPrefab : hammeredGoodVersionPrefab);
			UnnamedPlugin.Log.LogInfo((object)("UnnamedClimbingSpikeComponent " + ((Object)((ItemComponent)this).item).name + " is " + (isBad ? "bad" : "good")));
		}

		private static BoolItemData DefaultBadValue()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = (1f * Random.Range(0.5f, 1.5f) >= 1f)
			};
		}
	}
	public class UnnamedDynamite : Dynamite
	{
		public bool isDud;

		private float m_explosionScaleModifier = 1f;

		private bool m_extinguished;

		public float baseFuseTime;

		public bool IsADud
		{
			get
			{
				isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
				return isDud;
			}
		}

		public void Start()
		{
			isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
			m_explosionScaleModifier = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)16, (Func<FloatItemData>)SetupExplosionScaleModifier).Value;
			base.startingFuseTime = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)17, (Func<FloatItemData>)SetupDefaultFuseTime).Value;
			((Dynamite)this).Start();
			if (!isDud)
			{
				return;
			}
			ItemCooking component = ((Component)((ItemComponent)this).item).GetComponent<ItemCooking>();
			List<AdditionalCookingBehavior> list = new List<AdditionalCookingBehavior>();
			AdditionalCookingBehavior[] additionalCookingBehaviors = component.additionalCookingBehaviors;
			foreach (AdditionalCookingBehavior val in additionalCookingBehaviors)
			{
				if (!(val is CookingBehavior_Explode))
				{
					list.Add(val);
				}
			}
			component.additionalCookingBehaviors = list.ToArray();
			component.explosionPrefab = null;
		}

		public override void OnInstanceDataSet()
		{
			isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
			m_explosionScaleModifier = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)16, (Func<FloatItemData>)SetupExplosionScaleModifier).Value;
			if (isDud)
			{
				ItemCooking component = ((Component)((ItemComponent)this).item).GetComponent<ItemCooking>();
				List<AdditionalCookingBehavior> list = new List<AdditionalCookingBehavior>();
				AdditionalCookingBehavior[] additionalCookingBehaviors = component.additionalCookingBehaviors;
				foreach (AdditionalCookingBehavior val in additionalCookingBehaviors)
				{
					if (!(val is CookingBehavior_Explode))
					{
						list.Add(val);
					}
				}
				component.additionalCookingBehaviors = list.ToArray();
				component.explosionPrefab = null;
			}
			base.startingFuseTime = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)17, (Func<FloatItemData>)SetupDefaultFuseTime).Value;
			((Dynamite)this).OnInstanceDataSet();
			UnnamedPlugin.Log.LogInfo((object)("UnnamedDynamite " + ((Object)((ItemComponent)this).item).name + " is " + (isDud ? "a dud" : string.Format("not a dud and will be {0}% bigger with a {1} sec timer instead of {2}", string.Format(CultureInfo.InvariantCulture, "{0:+0%;-0%;0%}", m_explosionScaleModifier - 1f), base.startingFuseTime, baseFuseTime)) + "."));
		}

		private FloatItemData SetupExplosionScaleModifier()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = UnnamedPlugin.RandomUnnamedModifier
			};
		}

		private FloatItemData SetupDefaultFuseTime()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = baseFuseTime * UnnamedPlugin.RandomUnnamedModifier
			};
		}

		[PunRPC]
		public void RPC_Explode()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (base.DEBUG_PauseOnExplode)
			{
				Debug.Break();
			}
			GameObject val = Object.Instantiate<GameObject>(base.explosionPrefab, ((Component)this).transform.position, ((Component)this).transform.rotation);
			UnnamedPlugin.Log.LogInfo((object)"BIGGER BOOOOM!!!");
			AOE componentInChildren = val.GetComponentInChildren<AOE>(true);
			if (componentInChildren != null)
			{
				componentInChildren.range *= m_explosionScaleModifier;
				componentInChildren.knockback *= m_explosionScaleModifier;
				componentInChildren.fallTime *= m_explosionScaleModifier;
			}
			AudioSource[] componentsInChildren = val.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val2 in componentsInChildren)
			{
				val2.minDistance *= m_explosionScaleModifier;
				val2.maxDistance *= m_explosionScaleModifier;
			}
			Light componentInChildren2 = val.GetComponentInChildren<Light>(true);
			if (componentInChildren2 != null)
			{
				componentInChildren2.range *= m_explosionScaleModifier;
			}
			ExplosionEffect componentInChildren3 = val.GetComponentInChildren<ExplosionEffect>(true);
			if (componentInChildren3 != null)
			{
				componentInChildren3.baseScale *= m_explosionScaleModifier;
				componentInChildren3.explosionRadius *= m_explosionScaleModifier;
			}
			if (!val.activeSelf)
			{
				val.SetActive(true);
			}
			((Component)this).gameObject.SetActive(false);
			base._hasExploded = true;
		}

		private FloatItemData SetupDefaultFuel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = base.startingFuseTime * UnnamedPlugin.RandomUnnamedModifier
			};
		}

		[PunRPC]
		public void RPC_Extinguish()
		{
			m_extinguished = true;
			((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)3).Value = false;
			((Component)base.sparks).gameObject.SetActive(false);
			((Component)base.sparksPhotosensitive).gameObject.SetActive(false);
			Object.Destroy((Object)(object)((Component)base.trackable.currentTracker).gameObject);
		}

		private void Update()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if (m_extinguished)
			{
				return;
			}
			if (!((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)3).Value)
			{
				((Dynamite)this).TestLightWick();
				return;
			}
			if (!base.trackable.hasTracker)
			{
				((Dynamite)this).EnableFlareVisuals();
			}
			if ((int)((EnumSetting<OffOnMode>)(object)base.setting).Value != 1)
			{
				((Component)base.sparks).gameObject.SetActive(true);
			}
			else
			{
				((Component)base.sparksPhotosensitive).gameObject.SetActive(true);
			}
			base.fuseTime = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)10, (Func<FloatItemData>)SetupDefaultFuel).Value;
			((ItemComponent)this).item.SetUseRemainingPercentage(base.fuseTime / base.startingFuseTime);
			if (!((ItemComponent)this).photonView.IsMine)
			{
				return;
			}
			base.fuseTime -= Time.deltaTime;
			if (base.fuseTime <= 0f)
			{
				if (!isDud)
				{
					if ((Object)(object)Character.localCharacter.data.currentItem == (Object)(object)((ItemComponent)this).item)
					{
						Character.localCharacter.refs.afflictions.AddStatus((STATUSTYPE)0, 0.25f, false, true, true);
						Player.localPlayer.EmptySlot(Character.localCharacter.refs.items.currentSelectedSlot);
						Character.localCharacter.refs.afflictions.UpdateWeight();
					}
					((ItemComponent)this).photonView.RPC("RPC_Explode", (RpcTarget)0, Array.Empty<object>());
					PhotonNetwork.Destroy(((Component)this).gameObject);
					((ItemComponent)this).item.ClearDataFromBackpack();
				}
				else
				{
					((ItemComponent)this).photonView.RPC("RPC_Extinguish", (RpcTarget)0, Array.Empty<object>());
				}
				base.fuseTime = 0f;
			}
			((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)10, (Func<FloatItemData>)SetupDefaultFuel).Value = base.fuseTime;
		}

		private BoolItemData SetupDefaultDud()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = UnnamedPlugin.RandomUnnamedBool
			};
		}
	}
	public class UnnamedFlare : Flare
	{
		public bool isDud;

		public bool IsADud
		{
			get
			{
				isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
				return isDud;
			}
		}

		private void Start()
		{
			isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
			if (!isDud)
			{
				return;
			}
			ItemCooking component = ((Component)((ItemComponent)this).item).GetComponent<ItemCooking>();
			List<AdditionalCookingBehavior> list = new List<AdditionalCookingBehavior>();
			AdditionalCookingBehavior[] additionalCookingBehaviors = component.additionalCookingBehaviors;
			foreach (AdditionalCookingBehavior val in additionalCookingBehaviors)
			{
				if (!(val is CookingBehavior_Explode))
				{
					list.Add(val);
				}
			}
			component.additionalCookingBehaviors = list.ToArray();
			component.explosionPrefab = null;
		}

		public override void OnInstanceDataSet()
		{
			isDud = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultDud).Value;
			if (isDud)
			{
				ItemCooking component = ((Component)((ItemComponent)this).item).GetComponent<ItemCooking>();
				List<AdditionalCookingBehavior> list = new List<AdditionalCookingBehavior>();
				AdditionalCookingBehavior[] additionalCookingBehaviors = component.additionalCookingBehaviors;
				foreach (AdditionalCookingBehavior val in additionalCookingBehaviors)
				{
					if (!(val is CookingBehavior_Explode))
					{
						list.Add(val);
					}
				}
				component.additionalCookingBehaviors = list.ToArray();
				component.explosionPrefab = null;
			}
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} is {2}", "UnnamedFlare", ((ItemComponent)this).item, isDud ? "a dud" : "not a dud"));
			((Flare)this).OnInstanceDataSet();
		}

		public void LightFlare()
		{
			if (!isDud)
			{
				((Flare)this).LightFlare();
			}
		}

		private BoolItemData SetupDefaultDud()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = UnnamedPlugin.IsUnnamedLucky(1f / 3f)
			};
		}
	}
	public class UnnamedFrisbeeItem : MonoBehaviourPunCallbacks
	{
		public Frisbee frisbee;

		public float originalLiftForce = 10f;

		public float originalVelocityForLift = 10f;

		public void Start()
		{
			GlobalEvents.OnItemThrown = (Action<Item>)Delegate.Combine(GlobalEvents.OnItemThrown, new Action<Item>(RerollPhysicsStats));
		}

		private void RerollPhysicsStats(Item obj)
		{
			if ((Object)(object)obj == (Object)(object)frisbee.item && ((MonoBehaviourPun)this).photonView.IsMine)
			{
				((MonoBehaviourPun)this).photonView.RPC("RPC_SetNewFrisbeeStats", (RpcTarget)0, new object[2] { 0.5f, 0.5f });
			}
		}

		[PunRPC]
		public void RPC_SetNewFrisbeeStats(float liftMod, float velLiftMod)
		{
			frisbee.liftForce = (originalLiftForce *= liftMod);
			frisbee.velocityForLift = (originalVelocityForLift *= liftMod);
		}
	}
	[RequireComponent(typeof(PhotonView))]
	public class UnnamedParasol : Parasol
	{
		private float m_floatingTime;

		private float m_baseCloseTime;

		private float m_closeTime;

		private bool m_isInverted;

		public float CloseTimeModifier
		{
			set
			{
				m_closeTime = m_baseCloseTime * value;
			}
		}

		private void Start()
		{
			m_isInverted = base.item.GetData<BoolItemData>((DataEntryKey)16, (Func<BoolItemData>)DefaultInverted).Value;
			m_baseCloseTime = base.item.GetData<FloatItemData>((DataEntryKey)15, (Func<FloatItemData>)DefaultCloseTime).Value;
			UnnamedPlugin.Log.LogInfo((object)("UnnamedParasol " + ((Object)((Component)this).gameObject).name + " is " + (m_isInverted ? "inverted" : $"normal and will invert after {m_baseCloseTime} seconds floating")));
			CloseTimeModifier = UnnamedPlugin.RandomUnnamedModifier;
			if (m_isInverted)
			{
				InstantInvertParasol();
			}
		}

		private void InstantInvertParasol()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			Transform child = ((Component)base.item).transform.GetChild(2).GetChild(1).GetChild(0);
			Transform child2 = ((Component)base.item).transform.GetChild(2).GetChild(2).GetChild(0);
			Vector3 localScale = default(Vector3);
			((Vector3)(ref localScale))..ctor(child.localScale.x, child.localScale.y, 0f - Mathf.Abs(child.localScale.z));
			Vector3 localScale2 = default(Vector3);
			((Vector3)(ref localScale2))..ctor(child2.localScale.x, child2.localScale.y, 0f - Mathf.Abs(child2.localScale.z));
			Vector3 localPosition = default(Vector3);
			((Vector3)(ref localPosition))..ctor(child.localPosition.x, Mathf.Abs(child.localPosition.y), child.localPosition.z);
			Vector3 localPosition2 = default(Vector3);
			((Vector3)(ref localPosition2))..ctor(child2.localPosition.x, Mathf.Abs(child2.localPosition.y), child2.localPosition.z);
			child.localScale = localScale;
			child2.localScale = localScale2;
			child.localPosition = localPosition;
			child2.localPosition = localPosition2;
		}

		private BoolItemData DefaultInverted()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = false
			};
		}

		private FloatItemData DefaultCloseTime()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = 5f * UnnamedPlugin.RandomUnnamedModifier
			};
		}

		[PunRPC]
		public void ToggleOpenRPC(bool open)
		{
			((Parasol)this).ToggleOpenRPC(open);
			m_floatingTime = 0f;
		}

		[PunRPC]
		public void InvertParasolRPC()
		{
			m_isInverted = true;
			base.item.GetData<BoolItemData>((DataEntryKey)16, (Func<BoolItemData>)DefaultInverted).Value = m_isInverted;
			UnnamedPlugin.Log.LogInfo((object)("UnnamedParasol " + ((Object)((Component)this).gameObject).name + " just inverted!"));
			((MonoBehaviour)this).StartCoroutine(InvertParasolTop());
		}

		private IEnumerator InvertParasolTop(float inversionTime = 0.75f)
		{
			float time = 0f;
			Transform parasolOpen = ((Component)base.item).transform.GetChild(2).GetChild(1).GetChild(0);
			Transform parasolClosed = ((Component)base.item).transform.GetChild(2).GetChild(2).GetChild(0);
			Vector3 endLocalScaleOpen = new Vector3(parasolOpen.localScale.x, parasolOpen.localScale.y, 0f - Mathf.Abs(parasolOpen.localScale.z));
			Vector3 endLocalScaleClosed = new Vector3(parasolClosed.localScale.x, parasolClosed.localScale.y, 0f - Mathf.Abs(parasolClosed.localScale.z));
			Vector3 startLocalScaleOpen = parasolOpen.localScale;
			Vector3 startLocalScaleClosed = parasolClosed.localScale;
			Vector3 endLocalPositionOpen = new Vector3(parasolOpen.localPosition.x, Mathf.Abs(parasolOpen.localPosition.y), parasolOpen.localPosition.z);
			Vector3 endLocalPositionClosed = new Vector3(parasolClosed.localPosition.x, Mathf.Abs(parasolClosed.localPosition.y), parasolClosed.localPosition.z);
			Vector3 startLocalPositionOpen = parasolOpen.localPosition;
			Vector3 startLocalPositionClosed = parasolClosed.localPosition;
			while (time <= inversionTime)
			{
				time += Time.deltaTime;
				parasolOpen.localScale = Vector3.Lerp(startLocalScaleOpen, endLocalScaleOpen, time / inversionTime);
				parasolClosed.localScale = Vector3.Lerp(startLocalScaleClosed, endLocalScaleClosed, time / inversionTime);
				parasolOpen.localPosition = Vector3.Lerp(startLocalPositionOpen, endLocalPositionOpen, time / inversionTime);
				parasolClosed.localPosition = Vector3.Lerp(startLocalPositionClosed, endLocalPositionClosed, time / inversionTime);
				yield return null;
			}
			InstantInvertParasol();
		}

		public void InvertParasol()
		{
			if (((MonoBehaviourPun)base.item).photonView.IsMine)
			{
				m_floatingTime = 0f;
				CloseTimeModifier = UnnamedPlugin.RandomUnnamedModifier;
			}
			((MonoBehaviourPun)base.item).photonView.RPC("InvertParasolRPC", (RpcTarget)0, Array.Empty<object>());
		}

		public void FixedUpdate()
		{
			if (Object.op_Implicit((Object)(object)base.item.holderCharacter) && !base.item.holderCharacter.data.isGrounded && base.isOpen && !m_isInverted)
			{
				base.item.holderCharacter.refs.movement.ApplyParasolDrag(base.extraYDrag, base.extraXZDrag, false);
				m_floatingTime += Time.fixedDeltaTime;
				if (m_floatingTime >= m_closeTime)
				{
					InvertParasol();
				}
			}
		}
	}
	public class UnnamedRescueHook : RescueHook
	{
		public bool initilized;

		public float originalMaxWallHookTime = 1f;

		public float originalMaxScoutHookTime = 2f;

		public float originalMaxLiftDistance = 10f;

		public float originalStopPullDistance = 5f;

		public float originalExtraDragOther = 5f;

		public float originalExtraDragSelf = 5f;

		public float originalStopPullFriendDistance = 5f;

		public AnimationCurve originalPullStreightCurve;

		public float originalDragForce = 100f;

		public float originalLaunchForce = 100f;

		public static readonly AnimationCurve CheapPullCurve = new AnimationCurve((Keyframe[])(object)new Keyframe[25]
		{
			new Keyframe(0f, 0f, 0.7656035f, 0.7656035f, 1f / 3f, 1f / 3f),
			new Keyframe(0.061186537f, 0.12154554f, 2.260493f, 2.260493f, 1f / 3f, 1f / 3f),
			new Keyframe(0.08146797f, 0.055668898f, 1.804922f, 1.804922f, 1f / 3f, 1f / 3f),
			new Keyframe(0.101749524f, 0.18898553f, 0.18176766f, 0.18176766f, 1f / 3f, 1f / 3f),
			new Keyframe(0.1220309f, 0.2024113f, 0.3971367f, 0.3971367f, 1f / 3f, 1f / 3f),
			new Keyframe(0.22343849f, 0.36758855f, -0.23029839f, -0.23029839f, 1f / 3f, 1f / 3f),
			new Keyframe(0.26400137f, 0.30537274f, 0.15508865f, 0.15508865f, 1f / 3f, 1f / 3f),
			new Keyframe(0.3654089f, 0.37096834f, 0.004185795f, 0.004185795f, 1f / 3f, 1f / 3f),
			new Keyframe(0.44653487f, 0.4570219f, -0.23031577f, -0.23031577f, 1f / 3f, 1f / 3f),
			new Keyframe(0.46681643f, 0.43654317f, 0.39870247f, 0.39870247f, 1f / 3f, 1f / 3f),
			new Keyframe(0.50737935f, 0.4546563f, -0.03340112f, -0.03340112f, 1f / 3f, 1f / 3f),
			new Keyframe(0.63894075f, 0.5520424f, 0.43541637f, 0.43541637f, 1f / 3f, 1f / 3f),
			new Keyframe(0.706719f, 0.52970034f, 0.6874134f, 0.6874134f, 1f / 3f, 1f / 3f),
			new Keyframe(0.7507573f, 0.6159928f, 0.37300944f, 0.37300944f, 1f / 3f, 1f / 3f),
			new Keyframe(0.7710388f, 0.646866f, 0.90341717f, 0.90341717f, 1f / 3f, 1f / 3f),
			new Keyframe(0.81160176f, 0.73054355f, 0.12526514f, 0.12526514f, 1f / 3f, 1f / 3f),
			new Keyframe(0.83188325f, 0.7360053f, -0.13207354f, -0.13207354f, 1f / 3f, 1f / 3f),
			new Keyframe(0.85216475f, 0.7302468f, 1.2425476f, 1.2425476f, 1f / 3f, 1f / 3f),
			new Keyframe(0.87244624f, 0.784423f, 1.7651774f, 1.7651774f, 1f / 3f, 1f / 3f),
			new Keyframe(0.89272773f, 0.84738904f, -1.3040692f, -1.3040692f, 1f / 3f, 1f / 3f),
			new Keyframe(0.9130092f, 0.79053056f, 1.7999793f, 1.7999793f, 1f / 3f, 1f / 3f),
			new Keyframe(0.9332907f, 0.86901104f, 3.5420678f, 3.5420678f, 1f / 3f, 1f / 3f),
			new Keyframe(0.9535722f, 1.0234481f, -0.9682108f, -0.9682108f, 1f / 3f, 1f / 3f),
			new Keyframe(0.9738537f, MathF.E * 74f / 205f, -0.49087864f, -0.49087864f, 1f / 3f, 1f / 3f),
			new Keyframe(1f, 0.9923656f, 0.8811438f, 0.8811438f, 1f / 3f, 1f / 3f)
		});

		[PunRPC]
		public void RPCA_LetGo()
		{
			((RescueHook)this).RPCA_LetGo();
		}

		public void Fire()
		{
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			if (!initilized)
			{
				originalDragForce = base.dragForce;
				originalLaunchForce = base.launchForce;
				originalMaxLiftDistance = base.maxLiftDistance;
				originalMaxScoutHookTime = base.maxScoutHookTime;
				originalMaxWallHookTime = base.maxWallHookTime;
				originalExtraDragOther = base.extraDragOther;
				originalExtraDragSelf = base.extraDragSelf;
				originalStopPullDistance = base.stopPullDistance;
				originalStopPullFriendDistance = base.stopPullFriendDistance;
				originalPullStreightCurve = base.pulLStrengthCurve;
				CheapPullCurve.postWrapMode = (WrapMode)4;
				CheapPullCurve.preWrapMode = (WrapMode)4;
				initilized = true;
			}
			base.dragForce = originalDragForce * UnnamedPlugin.RandomModifier(0.125f);
			base.launchForce = Mathf.Clamp(originalLaunchForce * UnnamedPlugin.RandomUnnamedModifier, 0f, originalLaunchForce * 1.25f);
			base.maxLiftDistance = originalMaxLiftDistance * UnnamedPlugin.RandomUnnamedModifier;
			base.maxScoutHookTime = originalMaxScoutHookTime * UnnamedPlugin.RandomUnnamedModifier;
			base.maxWallHookTime = originalMaxWallHookTime * UnnamedPlugin.RandomUnnamedModifier;
			base.stopPullDistance = originalStopPullDistance * UnnamedPlugin.RandomUnnamedModifier;
			base.extraDragOther = originalExtraDragOther * UnnamedPlugin.RandomModifier(0.125f);
			base.extraDragSelf = originalExtraDragSelf * UnnamedPlugin.RandomModifier(0.125f);
			base.stopPullFriendDistance = originalStopPullFriendDistance * UnnamedPlugin.RandomUnnamedModifier;
			base.pulLStrengthCurve = (UnnamedPlugin.RandomUnnamedBool ? CheapPullCurve : originalPullStreightCurve);
			UnnamedPlugin.Log.LogInfo((object)"Fire");
			UnnamedPlugin.Log.LogInfo((object)string.Format("Launching {0} {1} with a launch force of {2} instead of {3}", "UnnamedRescueHook", base.pulLStrengthCurve.Equals(CheapPullCurve) ? "badly" : "correctly", base.launchForce, originalLaunchForce));
			base.sinceFire = 0f;
			int i = 0;
			for (int num = base.rescueShot.Length; i < num; i++)
			{
				base.rescueShot[i].Play(((Component)this).transform.position);
			}
			Vector3 val = default(Vector3);
			RaycastHit hit = ((RescueHook)this).GetHit(ref val);
			if (Object.op_Implicit((Object)(object)((RaycastHit)(ref hit)).transform))
			{
				Character componentInParent = ((Component)((RaycastHit)(ref hit)).transform).GetComponentInParent<Character>();
				UnnamedPlugin.Log.LogDebug((object)$"Hit: {((Object)((RaycastHit)(ref hit)).collider).name} Rig: {((RaycastHit)(ref hit)).rigidbody}, !hit.rigidbody: {!Object.op_Implicit((Object)(object)((RaycastHit)(ref hit)).rigidbody)}");
				UnnamedPlugin.Log.LogDebug((object)((Component)((RaycastHit)(ref hit)).collider).gameObject);
				bool randomUnnamedBool = UnnamedPlugin.RandomUnnamedBool;
				if (Object.op_Implicit((Object)(object)componentInParent) && randomUnnamedBool)
				{
					UnnamedPlugin.Log.LogInfo((object)$"Grabbing {componentInParent.characterName} for at most {base.maxScoutHookTime} seconds instead of {originalMaxWallHookTime}");
					((ItemComponent)this).photonView.RPC("RPCA_RescueCharacter", (RpcTarget)0, new object[1] { ((MonoBehaviourPun)componentInParent).photonView });
				}
				else
				{
					UnnamedPlugin.Log.LogInfo((object)$"Grabbing {((Object)((Component)((RaycastHit)(ref hit)).collider).gameObject).name} for at most {base.maxWallHookTime} seconds instead of {originalMaxWallHookTime}");
					((ItemComponent)this).photonView.RPC("RPCA_RescueWall", (RpcTarget)0, new object[2]
					{
						false,
						((RaycastHit)(ref hit)).point
					});
				}
			}
			else
			{
				UnnamedPlugin.Log.LogInfo((object)$"Grabbing at {val} for at most {base.maxWallHookTime} seconds instead of {originalMaxWallHookTime}");
				((ItemComponent)this).photonView.RPC("RPCA_RescueWall", (RpcTarget)0, new object[2] { true, val });
			}
		}
	}
	public class UnnamedRopeBreaker : OnNetworkStart, IPunOwnershipCallbacks
	{
		private static readonly int JitterAmount = Shader.PropertyToID("_JitterAmount");

		private static readonly int BreakAmount = Shader.PropertyToID("_RopeBreakAmount");

		private static readonly int AlphaClip = Shader.PropertyToID("_AlphaClip");

		public int maxPeople = 5;

		[Range(0f, 1f)]
		public float breakChance = 0.5f;

		public SFX_Instance[] breakSfx;

		public SFX_Instance startBreakSfx;

		public float shakeScale = 30f;

		public float fallTime = 5f;

		public float amount = 1f;

		public float startShakeDistance = 10f;

		public float startShakeAmount = 400f;

		public float climbingScreenShake = 240f;

		public float screenShakeTickTime = 0.2f;

		public Vector3 axisMul = new Vector3(1f, 1f, 1f);

		public bool debug;

		public bool isShaking;

		public float localTouchStamp;

		public int holdsPeople;

		public int peopleOnRope;

		public Transform fullMesh;

		public ParticleSystem breakParticles;

		private Renderer rend;

		private AudioSource source;

		private Rope rope;

		private float timeUntilBreak;

		private bool isBreaking;

		private bool isFallen;

		public bool LocalCharacterOnBridge => Time.time - localTouchStamp < 0.2f;

		private float SqrDistanceToLocalPlayer => Character.localCharacter.Center.SquareDistance(((Component)this).transform.position);

		public override void NetworkStart()
		{
			holdsPeople = Random.Range(1, maxPeople);
			UnnamedPlugin.Log.LogInfo((object)$"UnnamedRope {((Object)rope).name} can hold {holdsPeople} players");
			((MonoBehaviourPun)this).photonView.RPC("SyncHoldsPeopleRPC", (RpcTarget)0, new object[1] { holdsPeople });
		}

		private void Awake()
		{
			if (rope == null)
			{
				rope = ((Component)this).GetComponent<Rope>();
			}
			if (source == null)
			{
				source = ((Component)this).GetComponent<AudioSource>();
			}
			if (rend == null)
			{
				rend = ((Component)this).GetComponentInChildren<Renderer>();
			}
			rend.material.SetFloat(JitterAmount, 0f);
			rend.material.SetFloat(AlphaClip, 0.01f);
			if (holdsPeople == 0)
			{
				holdsPeople = 5;
			}
		}

		[PunRPC]
		public void SyncHoldsPeopleRPC(int newHoldsPeople)
		{
			holdsPeople = newHoldsPeople;
		}

		public void OnOwnershipRequest(PhotonView targetView, Player requestingPlayer)
		{
			UnnamedPlugin.Log.LogDebug((object)("OnOwnershipRequest received for " + ((Object)targetView).name + " from " + requestingPlayer.NickName + ". Granting ownership."));
			if ((Object)(object)targetView == (Object)(object)((MonoBehaviourPun)this).photonView)
			{
				((MonoBehaviourPun)this).photonView.TransferOwnership(requestingPlayer);
			}
		}

		public void OnOwnershipTransfered(PhotonView targetView, Player previousOwner)
		{
			UnnamedPlugin.Log.LogDebug((object)$"OnOwnershipTransferred for {((Object)targetView).name} from {previousOwner.NickName}. Is Local Player now owner: {object.Equals(PhotonNetwork.LocalPlayer, targetView.Owner)}.");
			if ((Object)(object)targetView == (Object)(object)((MonoBehaviourPun)this).photonView && object.Equals(PhotonNetwork.LocalPlayer, targetView.Owner))
			{
				UnnamedPlugin.Log.LogDebug((object)("OWNERSHIP TRANSFERRED TO ME for rope: " + ((Object)targetView).name + ". Please try pressing the cut key again."));
			}
		}

		public void OnOwnershipTransferFailed(PhotonView targetView, Player senderOfFailedRequest)
		{
			UnnamedPlugin.Log.LogWarning((object)("OnOwnershipTransferFailed for " + ((Object)targetView).name + " to " + senderOfFailedRequest.NickName + "."));
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			((MonoBehaviourPunCallbacks)this).OnPlayerEnteredRoom(newPlayer);
			if (!PhotonNetwork.IsMasterClient && !newPlayer.IsLocal)
			{
				((MonoBehaviourPun)this).photonView.RPC("SyncHoldsPeopleRPC", newPlayer, new object[1] { holdsPeople });
				if (isFallen)
				{
					((MonoBehaviourPun)this).photonView.RPC("BreakImmediateRPC", newPlayer, Array.Empty<object>());
				}
			}
		}

		public void BreakAnchorJoint()
		{
			UnnamedPlugin.Log.LogInfo((object)("Breaking " + ((Object)((Component)this).gameObject).name + " immediately."));
			if (((MonoBehaviourPun)this).photonView.IsMine)
			{
				Object.DestroyImmediate((Object)(object)((Component)rope.simulationSegments.First()).GetComponent<ConfigurableJoint>());
			}
			rope.ropeBoneVisualizer.StartTransform = null;
		}

		[PunRPC]
		private void BreakImmediateRPC()
		{
			isFallen = true;
			BreakAnchorJoint();
			rend.material.SetFloat(BreakAmount, 1f);
			rope.ropeBoneVisualizer.StartTransform = null;
			UnnamedPlugin.Log.LogDebug((object)$"Destroy: {((Component)this).gameObject}");
			UnnamedPlugin.Log.LogDebug((object)((Component)this).gameObject);
		}

		[PunRPC]
		private void Fall_Rpc()
		{
			((MonoBehaviour)this).StartCoroutine(DestroyRoutine());
			IEnumerator DestroyRoutine()
			{
				isFallen = true;
				BreakAnchorJoint();
				if ((Object)(object)breakParticles != (Object)null)
				{
					breakParticles.Play();
				}
				float normalizedTime = 0f;
				while (normalizedTime < 1f)
				{
					normalizedTime += Time.deltaTime * 0.7f;
					rend.material.SetFloat(BreakAmount, normalizedTime);
					yield return null;
				}
				UnnamedPlugin.Log.LogDebug((object)$"Broke: {((Component)this).gameObject}");
				UnnamedPlugin.Log.LogDebug((object)((Component)this).gameObject);
				yield return null;
			}
		}

		public void Update()
		{
			if (isShaking)
			{
				AudioSource obj = source;
				obj.pitch += 0.1f * Time.deltaTime;
				AudioSource obj2 = source;
				obj2.volume += 0.1f * Time.deltaTime;
				((Behaviour)source).enabled = true;
			}
			if (((MonoBehaviourPun)this).photonView.IsMine && isBreaking && !isShaking && !isFallen)
			{
				timeUntilBreak -= Time.deltaTime;
				if (timeUntilBreak < 0f)
				{
					((MonoBehaviourPun)this).photonView.RPC("ShakeRope_Rpc", (RpcTarget)0, Array.Empty<object>());
				}
			}
		}

		private void FixedUpdate()
		{
			peopleOnRope = 0;
			if (debug)
			{
				UnnamedPlugin.Log.LogDebug((object)$"FixedUpdate: {Time.frameCount}, peopleOnRope: {peopleOnRope}");
			}
			if (rope.charactersClimbing.Count <= 0)
			{
				return;
			}
			foreach (Character item in rope.charactersClimbing)
			{
				if (item.data.isRopeClimbing && (Object)(object)item.data.heldRope == (Object)(object)rope)
				{
					peopleOnRope = rope.charactersClimbing.Count;
				}
			}
		}

		[PunRPC]
		private void ShakeRope_Rpc()
		{
			UnnamedPlugin.Log.LogDebug((object)"start shake rock");
			isShaking = true;
			((Behaviour)source).enabled = true;
			source.Play();
			if (!isShaking)
			{
				source.volume = 0.125f;
			}
			if (SqrDistanceToLocalPlayer < startShakeDistance * startShakeDistance)
			{
				UnnamedPlugin.Log.LogDebug((object)$"start shake {startShakeAmount}");
				GamefeelHandler.instance.AddPerlinShake(startShakeAmount, 0.2f, 15f);
			}
			((MonoBehaviour)this).StartCoroutine(RockShake());
			IEnumerator RockShake()
			{
				UnnamedPlugin.Log.LogDebug((object)"Start shaking");
				startBreakSfx.Play(((Component)rope.attachedToAnchor).transform.position);
				float duration = 0f;
				float timeUntilShake = 0f;
				rend.material.SetFloat(JitterAmount, 1f);
				while (duration < fallTime)
				{
					timeUntilShake -= Time.deltaTime;
					if (LocalCharacterOnBridge && timeUntilShake <= 0f)
					{
						GamefeelHandler.instance.AddPerlinShake(climbingScreenShake, 0.2f, 15f);
						UnnamedPlugin.Log.LogDebug((object)"Climb shake");
						timeUntilShake = screenShakeTickTime;
					}
					duration += Time.deltaTime;
					yield return null;
				}
				rend.material.SetFloat(JitterAmount, 0f);
				UnnamedPlugin.Log.LogDebug((object)"Done shaking");
				if (isShaking)
				{
					Vector3 val = ExtTransform.FindClosest(((Component)Character.localCharacter).transform, rope.GetRopeSegments().ConvertAll((Transform t) => t.position));
					SFX_Instance[] array = breakSfx;
					foreach (SFX_Instance val2 in array)
					{
						val2.Play(val);
					}
				}
				isShaking = false;
				source.volume = 0f;
				source.Stop();
				if (((MonoBehaviourPun)this).photonView.IsMine)
				{
					((MonoBehaviourPun)this).photonView.RPC("Fall_Rpc", (RpcTarget)0, Array.Empty<object>());
				}
			}
		}

		public void AddPlayerToRope(Character character)
		{
			if (isBreaking)
			{
				return;
			}
			if (character.IsLocal)
			{
				localTouchStamp = Time.time;
			}
			if (((MonoBehaviourPun)this).photonView.IsMine)
			{
				UnnamedPlugin.Log.LogInfo((object)$"AddPlayerToRope: {character}. {rope.charactersClimbing.Count}, {holdsPeople} ");
				if (rope.charactersClimbing.Count >= holdsPeople && !isShaking && holdsPeople < rope.charactersClimbing.Count)
				{
					isBreaking = true;
					timeUntilBreak = Random.Range(2.5f, 7.5f);
				}
			}
		}

		public void RemovePlayerFromRope(Character character)
		{
		}
	}
	public class UnnamedRopeShooter : RopeShooter
	{
		public float baseShooterLength;

		public float baseReach;

		public override void OnInstanceDataSet()
		{
			base.maxLength = baseReach * UnnamedPlugin.RandomUnnamedModifier;
			base.length = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)15, (Func<FloatItemData>)GetNewLength).Value;
			((RopeShooter)this).OnInstanceDataSet();
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} will shoot a rope {2} m of length", "UnnamedRopeShooter", ((Object)((ItemComponent)this).item).name, base.length));
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} currently has a reach of {2} m", "UnnamedRopeShooter", ((Object)((ItemComponent)this).item).name, base.maxLength));
		}

		[PunRPC]
		public void Sync_Rpc(bool show)
		{
			((RopeShooter)this).Sync_Rpc(show);
		}

		private FloatItemData GetNewLength()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = baseShooterLength * UnnamedPlugin.RandomUnnamedModifier
			};
		}
	}
	public class UnnamedRopeSpool : RopeSpool
	{
		public float baseStartFuel;

		public override void OnInstanceDataSet()
		{
			base.ropeStartFuel = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)15, (Func<FloatItemData>)GetNew).Value;
			((RopeSpool)this).OnInstanceDataSet();
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} has {2} fuel instead of {3}.", "UnnamedRopeSpool", ((Object)((ItemComponent)this).item).name, base.ropeStartFuel, baseStartFuel));
		}

		private FloatItemData GetNew()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = baseStartFuel * UnnamedPlugin.RandomUnnamedModifier
			};
		}
	}
	public class UnnamedScoutCannon : ScoutCannon
	{
		private Vector3 UnnamedDir
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: 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_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: 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_0039: 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_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * UnnamedPlugin.RandomUnnamedModifier;
				Vector3 val2 = base.tube.up * val.y + base.tube.right * val.x;
				Vector3 val3 = base.tube.forward + val2 * 0.25f;
				return ((Vector3)(ref val3)).normalized;
			}
		}

		public void FireTargets()
		{
			UnnamedFireCannon();
		}

		public void LaunchItems(float force, Vector3 dir)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			List<Item> list = new List<Item>();
			Collider[] array = Physics.OverlapSphere(base.tube.position, 1f, LayerMask.op_Implicit(HelperFunctions.GetMask((LayerType)0)));
			int i = 0;
			for (int num = array.Length; i < num; i++)
			{
				Item componentInParent = ((Component)array[i]).GetComponentInParent<Item>();
				if (componentInParent != null && (int)componentInParent.itemState == 0)
				{
					RaycastHit val = HelperFunctions.LineCheck(base.tube.position, componentInParent.Center(), (LayerType)3, 0f, (QueryTriggerInteraction)1);
					if (!Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).transform) && !list.Contains(componentInParent))
					{
						list.Add(componentInParent);
					}
				}
			}
			foreach (Item item in list)
			{
				base.view.RPC("RPCA_UnnamedLaunchItem", (RpcTarget)0, new object[3]
				{
					((MonoBehaviourPun)item).photonView.ViewID,
					force,
					dir
				});
			}
		}

		[PunRPC]
		public void RPCA_SetTarget(int setTargetID)
		{
			((ScoutCannon)this).RPCA_SetTarget(setTargetID);
		}

		[PunRPC]
		public void RPCA_UnnamedLaunchItem(int targetID, float force, Vector3 dir)
		{
			//IL_0052: 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_0030: 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)
			PhotonView photonView = PhotonNetwork.GetPhotonView(targetID);
			if ((Object)(object)photonView == (Object)null)
			{
				return;
			}
			Item component = ((Component)photonView).GetComponent<Item>();
			if (!((Object)(object)component == (Object)null))
			{
				if (component is Backpack)
				{
					component.rig.AddForce(dir * (base.backpackLaunchForce * force / base.launchForce), (ForceMode)2);
				}
				else
				{
					component.rig.AddForce(dir * (base.itemLaunchForce * force / base.launchForce), (ForceMode)2);
				}
			}
		}

		[PunRPC]
		public void RPCA_UnnamedLaunchTarget(int targetID, float force, Vector3 dir)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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)
			PhotonView photonView = PhotonNetwork.GetPhotonView(targetID);
			Character characterTarget;
			if (!((Object)(object)photonView == (Object)null))
			{
				characterTarget = ((Component)photonView).GetComponent<Character>();
				if (!((Object)(object)characterTarget == (Object)null))
				{
					characterTarget.data.launchedByCannon = true;
					UnnamedPlugin.Log.LogInfo((object)string.Format("Launching {0} from {1} {2} with a force of {3} instead of {4} and at {5} instead of {6}.", characterTarget.characterName, "UnnamedScoutCannon", ((Object)((Component)this).gameObject).name, force, base.launchForce, dir, base.tube.forward));
					characterTarget.RPCA_Fall(force * base.fallFor / base.launchForce);
					characterTarget.AddForce(dir * force, 1f, 1f);
					((MonoBehaviour)this).StartCoroutine(ILaunch());
				}
			}
			IEnumerator ILaunch()
			{
				float c = 0f;
				while (c < base.fallFor)
				{
					c += Time.deltaTime;
					if (Object.op_Implicit((Object)(object)characterTarget))
					{
						characterTarget.ClampSinceGrounded(1f);
					}
					yield return null;
				}
				if (Object.op_Implicit((Object)(object)characterTarget))
				{
					characterTarget.data.fallSeconds = 0f;
				}
				c = 0f;
				while (c < 4f)
				{
					c += Time.deltaTime;
					if (Object.op_Implicit((Object)(object)characterTarget))
					{
						characterTarget.ClampSinceGrounded(1f);
					}
					yield return null;
				}
			}
		}

		public void LaunchPlayers(float force, Vector3 dir)
		{
			//IL_0035: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			List<Character> list = new List<Character>();
			if (Object.op_Implicit((Object)(object)base.target))
			{
				list.Add(base.target);
			}
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if ((double)allCharacter.Center.SquareDistance(base.entry.position) <= 0.5625 && (Object)(object)allCharacter != (Object)(object)base.target)
				{
					list.Add(allCharacter);
				}
			}
			foreach (Character allBotCharacter in Character.AllBotCharacters)
			{
				if ((double)allBotCharacter.Center.SquareDistance(base.entry.position) <= 0.5625 && (Object)(object)allBotCharacter != (Object)(object)base.target)
				{
					list.Add(allBotCharacter);
				}
			}
			foreach (Character item in list)
			{
				base.view.RPC("RPCA_UnnamedLaunchTarget", (RpcTarget)0, new object[3]
				{
					item.refs.view.ViewID,
					force,
					dir
				});
			}
		}

		public void UnnamedFireCannon()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			float force = base.launchForce * UnnamedPlugin.RandomUnnamedModifier;
			Vector3 unnamedDir = UnnamedDir;
			LaunchPlayers(force, unnamedDir);
			LaunchItems(force, unnamedDir);
		}
	}
	public class UnnamedScoutEffigy : ScoutEffigy
	{
		public bool isBad;

		public float revivalModifier;

		public override void OnInstanceDataSet()
		{
			isBad = ((ItemComponent)this).GetData<BoolItemData>((DataEntryKey)15, (Func<BoolItemData>)SetupDefaultIsBad).Value;
			revivalModifier = ((ItemComponent)this).GetData<FloatItemData>((DataEntryKey)16, (Func<FloatItemData>)SetupDefaultRevival).Value;
			((Constructable)this).OnInstanceDataSet();
			UnnamedPlugin.Log.LogInfo((object)("UnnamedScoutEffigy " + ((Object)((ItemComponent)this).item).name + " is " + (isBad ? "evil" : "not evil") + " and will revive " + string.Format(CultureInfo.InvariantCulture, "{0:+0%;-0%;0%}", revivalModifier) + "% of players"));
		}

		private BoolItemData SetupDefaultIsBad()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return new BoolItemData
			{
				Value = (1f * UnnamedPlugin.RandomUnnamedModifier < 1f)
			};
		}

		private FloatItemData SetupDefaultRevival()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return new FloatItemData
			{
				Value = 1f * UnnamedPlugin.RandomUnnamedModifier
			};
		}

		public override GameObject FinishConstruction()
		{
			//IL_01a4: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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)
			//IL_0117: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			int num = Character.AllCharacters.Sum((Character chara) => (chara.data.dead || chara.data.fullyPassedOut) ? 1 : 0);
			float num2 = 0f;
			if (num != 0)
			{
				num2 = 1f / (float)num * revivalModifier;
			}
			int num3 = Mathf.RoundToInt(num2 * (float)num);
			UnnamedPlugin.Log.LogInfo((object)$"Reviving {num3} players...");
			if (num3 > 1)
			{
				List<Character> list = new List<Character>();
				foreach (Character allCharacter in Character.AllCharacters)
				{
					if (allCharacter.data.dead || allCharacter.data.fullyPassedOut)
					{
						list.Add(allCharacter);
					}
				}
				for (int i = 1; (float)i < num2; i++)
				{
					Character val = Util.RandomSelection<Character>((IEnumerable<Character>)list, (Func<Character, int>)((Character _) => 1));
					((MonoBehaviourPun)val).photonView.RPC("RPCA_ReviveAtPosition", (RpcTarget)0, new object[2]
					{
						((RaycastHit)(ref ((Constructable)this).currentConstructHit)).point + Vector3.up * (1f * (float)(i + 1)),
						false
					});
					list.Remove(val);
					if (Object.op_Implicit((Object)(object)Singleton<AchievementManager>.Instance))
					{
						Singleton<AchievementManager>.Instance.AddToRunBasedInt((RUNBASEDVALUETYPE)2, 1);
					}
				}
			}
			((ScoutEffigy)this).FinishConstruction();
			if (isBad && GameHandler.IsOnIsland)
			{
				Character holderCharacter = ((ItemComponent)this).item.holderCharacter;
				Optionable<byte> currentSelectedSlot = holderCharacter.refs.items.currentSelectedSlot;
				holderCharacter.player.EmptySlot(currentSelectedSlot);
				holderCharacter.refs.items.EquipSlot(currentSelectedSlot);
				holderCharacter.DieInstantly();
			}
			return null;
		}
	}
	public class UnnamedSpawnable : MonoBehaviour
	{
		public GameObject prefabToSpawn;

		private void Start()
		{
			GameObject val = Object.Instantiate<GameObject>(prefabToSpawn);
			val.SetActive(true);
		}
	}
	public class UnnamedStatusField : StatusField
	{
		public void Update()
		{
			//IL_0014: 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_008c: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Character.localCharacter) && Character.localCharacter.Center.CompareDistanceFast(((Component)this).transform.position, base.radius))
			{
				if (base.doNotApplyIfStatusesMaxed && Character.localCharacter.refs.afflictions.statusSum >= 1f)
				{
					base.inflicting = false;
					return;
				}
				float num = base.statusAmountPerSecond * UnnamedPlugin.RandomUnnamedModifier;
				UnnamedPlugin.Log.LogInfo((object)$"Adjusting {Character.localCharacter.characterName}'s {base.statusType} by {num * Time.deltaTime} instead of {base.statusAmountPerSecond * Time.deltaTime} because {((Object)((Component)this).gameObject).name} is UNNAMED");
				Character.localCharacter.refs.afflictions.AdjustStatus(base.statusType, num * Time.deltaTime, false);
				foreach (StatusFieldStatus additionalStatus in base.additionalStatuses)
				{
					float num2 = additionalStatus.statusAmountPerSecond * UnnamedPlugin.RandomUnnamedModifier;
					UnnamedPlugin.Log.LogInfo((object)$"Adjusting {Character.localCharacter.characterName}'s {additionalStatus.statusType} by {num2 * Time.deltaTime} instead of {additionalStatus.statusAmountPerSecond * Time.deltaTime} because {((Object)((Component)this).gameObject).name} is UNNAMED");
					Character.localCharacter.refs.afflictions.AdjustStatus(additionalStatus.statusType, num2 * Time.deltaTime, false);
				}
				if (!base.inflicting && base.statusAmountOnEntry != 0f && Time.time - base.lastEnteredTime > base.entryCooldown)
				{
					float num3 = base.statusAmountOnEntry * UnnamedPlugin.RandomUnnamedModifier;
					UnnamedPlugin.Log.LogInfo((object)$"Adjusting {Character.localCharacter.characterName}'s {base.statusType} (on entry) by {num3} instead of {base.statusAmountOnEntry} because {((Object)((Component)this).gameObject).name} is UNNAMED");
					Character.localCharacter.refs.afflictions.AdjustStatus(base.statusType, num3, false);
					base.lastEnteredTime = Time.time;
				}
				base.inflicting = true;
			}
			else
			{
				base.inflicting = false;
			}
		}
	}
	public class UnnamedVine : OnNetworkStart
	{
		private static readonly int JitterAmount = Shader.PropertyToID("_JitterAmount");

		private static readonly int BreakAmount = Shader.PropertyToID("_BreakAmount");

		private static readonly int AlphaClip = Shader.PropertyToID("_AlphaClip");

		public int maxPeople = 5;

		public SFX_Instance[] breakSfx;

		[Range(0f, 1f)]
		public float breakPoint = 0.4f;

		[Range(0f, 1f)]
		public float breakChance = 0.5f;

		public Vector3 axisMul = new Vector3(1f, 1f, 1f);

		public float shakeScale = 30f;

		public float fallTime = 5f;

		public float amount = 1f;

		public float startShakeDistance = 10f;

		public float startShakeAmount = 400f;

		public float climbingScreenShake = 240f;

		public float screenShakeTickTime = 0.2f;

		public bool debug;

		public bool isShaking;

		public float localTouchStamp;

		public int holdsPeople;

		public int peopleOnVine;

		public Transform fullMesh;

		public ParticleSystem breakParticles;

		private readonly Dictionary<Character, float> peopleOnVineDict = new Dictionary<Character, float>();

		private PhotonView photonView;

		private Renderer rend;

		private AudioSource source;

		private JungleVine jungleVine;

		private List<Character> cachedPeopleOnVineList = new List<Character>();

		private float timeUntilBreak;

		private bool isBreaking;

		private bool isFallen;

		public bool LocalCharacterOnBridge => Time.time - localTouchStamp < 0.2f;

		private float DistanceToLocalPlayer => Vector3.Distance(Character.localCharacter.Center, ((Component)this).transform.position);

		public override void NetworkStart()
		{
			holdsPeople = Random.Range(1, maxPeople);
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} can hold {2} players", "UnnamedVine", ((Object)((Component)this).gameObject).name, holdsPeople));
			photonView.RPC("SyncHoldsPeopleRPC", (RpcTarget)0, new object[1] { holdsPeople });
			photonView.RPC("SyncBreakParticlesRPC", (RpcTarget)0, Array.Empty<object>());
		}

		private void Awake()
		{
			if (jungleVine == null)
			{
				jungleVine = ((Component)this).GetComponent<JungleVine>();
			}
			if (photonView == null)
			{
				photonView = ((Component)this).GetComponent<PhotonView>();
			}
			if (source == null)
			{
				source = ((Component)this).GetComponent<AudioSource>();
			}
			if (rend == null)
			{
				rend = ((Component)this).GetComponentInChildren<Renderer>();
			}
			rend.material.SetFloat(JitterAmount, 0f);
			rend.material.SetFloat(AlphaClip, 0.01f);
			if (holdsPeople == 0)
			{
				holdsPeople = 5;
			}
		}

		public void Update()
		{
			if (isShaking)
			{
				AudioSource obj = source;
				obj.pitch += 0.1f * Time.deltaTime;
				AudioSource obj2 = source;
				obj2.volume += 0.1f * Time.deltaTime;
				((Behaviour)source).enabled = true;
			}
			if (photonView.IsMine && isBreaking && !isShaking && !isFallen)
			{
				timeUntilBreak -= Time.deltaTime;
				if (timeUntilBreak < 0f)
				{
					photonView.RPC("ShakeVine_Rpc", (RpcTarget)0, Array.Empty<object>());
				}
			}
		}

		public void AddPlayerToVine(Character character)
		{
			if (isBreaking)
			{
				return;
			}
			if (character.IsLocal)
			{
				localTouchStamp = Time.time;
			}
			if (photonView.IsMine)
			{
				if (!peopleOnVineDict.TryAdd(character, 0f))
				{
					peopleOnVineDict[character] = 0f;
				}
				UpdatePeopleOnVine();
				UnnamedPlugin.Log.LogInfo((object)$"AddPlayerToRope: {character}. {peopleOnVineDict.Keys.Count}, {holdsPeople}");
				if (peopleOnVine >= holdsPeople && !isShaking && holdsPeople < peopleOnVine)
				{
					isBreaking = true;
					timeUntilBreak = Random.Range(2.5f, 7.5f);
				}
			}
		}

		private void FixedUpdate()
		{
			peopleOnVine = 0;
			if (debug)
			{
				UnnamedPlugin.Log.LogDebug((object)$"FixedUpdate: {Time.frameCount}, People on Vine: {peopleOnVine}");
			}
			UpdatePeopleOnVine();
		}

		private void UpdatePeopleOnVine()
		{
			if (peopleOnVineDict.Keys.Count <= 0)
			{
				return;
			}
			cachedPeopleOnVineList = peopleOnVineDict.Keys.ToList();
			foreach (Character cachedPeopleOnVine in cachedPeopleOnVineList)
			{
				if (cachedPeopleOnVine.data.isVineClimbing && (Object)(object)cachedPeopleOnVine.data.heldVine == (Object)(object)jungleVine)
				{
					peopleOnVine++;
				}
			}
		}

		public void RemovePlayerFromVine(Character character)
		{
			if (!isBreaking && photonView.IsMine)
			{
				peopleOnVineDict.Remove(character);
				UnnamedPlugin.Log.LogInfo((object)$"RemovedPlayerToRope: {character}. {peopleOnVineDict.Keys.Count}, {holdsPeople}");
			}
		}

		[PunRPC]
		public void SyncHoldsPeopleRPC(int holdsPeople)
		{
			this.holdsPeople = holdsPeople;
		}

		[PunRPC]
		public void SyncBreakParticlesRPC()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			((Component)breakParticles).transform.position = jungleVine.GetPosition(0.5f, 0, 0);
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			((MonoBehaviourPunCallbacks)this).OnPlayerEnteredRoom(newPlayer);
			if (!PhotonNetwork.IsMasterClient && !newPlayer.IsLocal)
			{
				photonView.RPC("SyncHoldsPeopleRPC", newPlayer, new object[1] { holdsPeople });
				if (isFallen)
				{
					photonView.RPC("BreakImmediateRPC", newPlayer, Array.Empty<object>());
				}
			}
		}

		[PunRPC]
		private void BreakImmediateRPC()
		{
			isFallen = true;
			Object.DestroyImmediate((Object)(object)((Component)jungleVine.colliderRoot).gameObject);
			rend.material.SetFloat(BreakAmount, 1f);
			UnnamedPlugin.Log.LogDebug((object)$"Destroy: {((Component)this).gameObject}");
			UnnamedPlugin.Log.LogDebug((object)((Component)this).gameObject);
		}

		[PunRPC]
		private void ShakeVine_Rpc()
		{
			UnnamedPlugin.Log.LogDebug((object)"start shake rock");
			isShaking = true;
			((Behaviour)source).enabled = true;
			source.Play();
			if (!isShaking)
			{
				source.volume = 0.125f;
			}
			if (DistanceToLocalPlayer < startShakeDistance)
			{
				UnnamedPlugin.Log.LogDebug((object)$"start shake {startShakeAmount}");
				GamefeelHandler.instance.AddPerlinShake(startShakeAmount, 0.2f, 15f);
			}
			((MonoBehaviour)this).StartCoroutine(RockShake());
			IEnumerator RockShake()
			{
				UnnamedPlugin.Log.LogDebug((object)"Start shaking");
				float duration = 0f;
				float timeUntilShake = 0f;
				rend.material.SetFloat(JitterAmount, 1f);
				while (duration < fallTime)
				{
					timeUntilShake -= Time.deltaTime;
					if (LocalCharacterOnBridge && timeUntilShake <= 0f)
					{
						GamefeelHandler.instance.AddPerlinShake(climbingScreenShake, 0.2f, 15f);
						UnnamedPlugin.Log.LogDebug((object)"Clime shake");
						timeUntilShake = screenShakeTickTime;
					}
					duration += Time.deltaTime;
					yield return null;
				}
				rend.material.SetFloat(JitterAmount, 0f);
				UnnamedPlugin.Log.LogDebug((object)"Done shaking");
				if (isShaking)
				{
					Vector3 position = ((Component)this).transform.position;
					if (Object.op_Implicit((Object)(object)jungleVine.colliderRoot))
					{
						position = jungleVine.GetPosition(jungleVine.GetPercentFromSegmentIndex(jungleVine.GetClosestChild(Character.localCharacter.Center)), 0, 0);
					}
					SFX_Instance[] array = breakSfx;
					foreach (SFX_Instance val in array)
					{
						val.Play(position);
					}
				}
				isShaking = false;
				fullMesh.localPosition = ExtDataTypes.ToVec(0);
				source.volume = 0f;
				source.Stop();
				if (photonView.IsMine)
				{
					photonView.RPC("Fall_Rpc", (RpcTarget)0, Array.Empty<object>());
				}
			}
		}

		[PunRPC]
		private void Fall_Rpc()
		{
			((MonoBehaviour)this).StartCoroutine(DestroyRoutine());
			IEnumerator DestroyRoutine()
			{
				isFallen = true;
				Object.DestroyImmediate((Object)(object)((Component)jungleVine.colliderRoot).gameObject);
				foreach (Character allCharacter in Character.AllCharacters)
				{
					if (allCharacter.data.isVineClimbing && (Object)(object)((Component)allCharacter.data.heldVine).gameObject == (Object)(object)((Component)this).gameObject)
					{
						allCharacter.refs.vineClimbing.Stop();
						allCharacter.Fall(1f, 0.25f);
					}
				}
				if (Object.op_Implicit((Object)(object)breakParticles))
				{
					breakParticles.Play();
				}
				float normalizedTime = 0f;
				while (normalizedTime < 1f)
				{
					normalizedTime += Time.deltaTime * 0.7f;
					rend.material.SetFloat(BreakAmount, normalizedTime);
					yield return null;
				}
				UnnamedPlugin.Log.LogDebug((object)$"Destroy: {((Component)this).gameObject}");
				UnnamedPlugin.Log.LogDebug((object)((Component)this).gameObject);
				yield return null;
			}
		}
	}
	public class UnnamedVineShooter : VineShooter
	{
		public float baseReach;

		public override void OnInstanceDataSet()
		{
			base.maxLength = baseReach * UnnamedPlugin.RandomUnnamedModifier;
			((VineShooter)this).OnInstanceDataSet();
			UnnamedPlugin.Log.LogInfo((object)string.Format("{0} {1} currently has a reach of {2} m", "UnnamedVineShooter", ((Object)((ItemComponent)this).item).name, base.maxLength));
		}
	}
}
namespace UnnamedProducts.Behaviours.Item.GarbageBag
{
	public class CookingBehavior_DestroyAndReleaseGarbageBagItems : CookingBehavior_Explode
	{
		public override void TriggerBehaviour(int cookedAmount)
		{
			if (((ItemComponent)((AdditionalCookingBehavior)this).itemCooking).item is UnnamedGarbageBagController unnamedGarbageBagController)
			{
				BackpackData data = ((Item)unnamedGarbageBagController).GetData<BackpackData>((DataEntryKey)7);
				bool flag = false;
				ItemSlot[] itemSlots = data.itemSlots;
				foreach (ItemSlot val in itemSlots)
				{
					if (!val.IsEmpty())
					{
						flag = true;
						((Item)unnamedGarbageBagController).view.RPC("RPC_TakeItemOut", (RpcTarget)2, new object[1] { val.itemSlotID });
					}
				}
				if (flag)
				{
					((Item)unnamedGarbageBagController).view.RPC("RPC_ItemSlipped", (RpcTarget)0, Array.Empty<object>());
				}
			}
			((CookingBehavior_Explode)this).TriggerBehaviour(cookedAmount);
		}
	}
	public class UnnamedGarbageBagAudio : MonoBehaviour
	{
		public UnnamedGarbageBagController bag;

		public SFX_Instance[] holdSFX;

		private bool holdTransition;

		public SFX_Instance[] dropSFX;

		private bool dropTransition;

		private void Start()
		{
			if (bag == null)
			{
				bag = ((Component)this).GetComponent<UnnamedGarbageBagController>();
			}
		}

		private void Update()
		{
			//IL_0045: 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 (!Object.op_Implicit((Object)(object)bag))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)((Item)bag).holderCharacter))
			{
				if (!holdTransition)
				{
					int i = 0;
					for (int num = holdSFX.Length; i < num; i++)
					{
						holdSFX[i].Play(((Component)this).transform.position);
					}
					holdTransition = true;
				}
			}
			else
			{
				holdTransition = false;
			}
			if (((Item)bag).rig.useGravity)
			{
				if (!dropTransition)
				{
					int j = 0;
					for (int num2 = dropSFX.Length; j < num2; j++)
					{
						dropSFX[j].Play(((Component)this).transform.position);
					}
				}
				dropTransition = true;
			}
			else
			{
				dropTransition = false;
			}
		}
	}
	public class UnnamedGarbageBagController : Item
	{
		public float openRadialMenuTime = 0.25f;

		private bool m_justSetActive = true;

		public UnnamedGarbageBagVisuals m_unnamedGarbageBagVisuals;

		public GameObject emptyBagGameObject;

		public GameObject fullBagGameObject;

		public float fullBagRadius;

		private bool m_isEmpty = true;

		public Vector3 rightHandEmptyPosition;

		public Vector3 leftHandEmptyPosition;

		public Vector3 rightHandFullPosition;

		public Vector3 leftHandFullPosition;

		public GameObject rightHandGameObject;

		public GameObject leftHandGameObject;

		private Character lastInteractor;

		private Renderer emptyBagRenderer;

		private Renderer fullBagRenderer;

		public Renderer[] allBagRenderers;

		public SFX_Instance[] slipSDSfxInstances;

		public Vector3 defaultPosFilled;

		public Vector3 defaultPosEmpty;

		public bool holdOnFinish => false;

		public bool shouldSlip
		{
			get
			{
				if (!UnnamedPlugin.IsUnnamedLucky(0.25f))
				{
					return FilledSlotCount() > 0;
				}
				return false;
			}
		}

		public override void Awake()
		{
			((Item)this).Awake();
			if (emptyBagGameObject == null)
			{
				emptyBagGameObject = ((Component)((Component)this).transform.Find("GarbageBag/empty")).gameObject;
			}
			if (fullBagGameObject == null)
			{
				fullBagGameObject = ((Component)((Component)this).transform.Find("GarbageBag/empty")).gameObject;
			}
			emptyBagRenderer = emptyBagGameObject.GetComponent<Renderer>();
			fullBagRenderer = fullBagGameObject.GetComponent<Renderer>();
			allBagRenderers = (Renderer[])(object)new Renderer[2] { emptyBagRenderer, fullBagRenderer };
			if (leftHandGameObject == null)
			{
				leftHandGameObject = ((Component)((Component)this).transform.Find("Hand_L")).gameObject;
			}
			if (rightHandGameObject == null)
			{
				rightHandGameObject = ((Component)((Component)this).transform.Find("Hand_R")).gameObject;
			}
			if (m_unnamedGarbageBagVisuals == null)
			{
				m_unnamedGarbageBagVisuals = ((Component)this).GetComponent<UnnamedGarbageBagVisuals>();
			}
			fullBagRadius = 0.599735f;
			base.OnStateChange = (Action<ItemState>)Delegate.Combine(base.OnStateChange, new Action<ItemState>(StateChanged));
			fullBagGameObject.SetActive(!m_isEmpty);
			emptyBagGameObject.SetActive(m_isEmpty);
			RefreshVisualReferences();
		}

		public override void AddPhysics()
		{
			((Item)this).AddPhysics();
			base.colliders = CollectionExtensions.AddRangeToArray<Collider>(emptyBagGameObject.GetComponentsInChildren<Collider>(true), fullBagGameObject.GetComponentsInChildren<Collider>(true));
		}

		private void RefreshVisualReferences()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (m_isEmpty)
			{
				rightHandGameObject.transform.localPosition = rightHandEmptyPosition;
				leftHandGameObject.transform.localPosition = leftHandEmptyPosition;
				base.defaultPos = defaultPosEmpty;
			}
			else
			{
				rightHandGameObject.transform.localPosition = rightHandFullPosition;
				leftHandGameObject.transform.localPosition = leftHandFullPosition;
				base.defaultPos = defaultPosFilled;
			}
		}

		private void StateChanged(ItemState obj)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)obj == 1 && m_justSetActive && ((MonoBehaviourPun)this).photonView.IsMine)
			{
				m_justSetActive = true;
				if (shouldSlip)
				{
					((MonoBehaviourPun)this).photonView.RPC("RPC_DropRandomBaggedItem", (RpcTarget)2, Array.Empty<object>());
				}
			}
		}

		public override void Interact(Character interactor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)((Item)this).itemState == 2)
			{
				((Item)this).Interact(interactor);
				return;
			}
			if (interactor.input.interactIsPressed)
			{
				UnnamedUIManager.Instance.OpenGarbageBagScreen(UnnamedGarbageBagReference.GetFromBackpackItem((Item)(object)this));
			}
			else
			{
				((Item)this).Interact(interactor);
			}
			lastInteractor = interactor;
		}

		public void ReleaseInteract(Character interactor)
		{
		}

		public void PickUpGarbageBag(Character interactor)
		{
			((Item)this).Interact(interactor);
		}

		private void DisableVisuals()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Renderer obj = fullBagRenderer;
			Renderer obj2 = emptyBagRenderer;
			ShadowCastingMode shadowCastingMode = (ShadowCastingMode)3;
			obj2.shadowCastingMode = (ShadowCastingMode)3;
			obj.shadowCastingMode = shadowCastingMode;
		}

		private void EnableVisuals()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Renderer obj = fullBagRenderer;
			Renderer obj2 = emptyBagRenderer;
			ShadowCastingMode shadowCastingMode = (ShadowCastingMode)1;
			obj2.shadowCastingMode = (ShadowCastingMode)1;
			obj.shadowCastingMode = shadowCastingMode;
		}

		public override string GetInteractionText()
		{
			return LocalizedText.GetText("open", true);
		}

		public bool IsConstantlyInteractable(Character interactor)
		{
			return false;
		}

		public float GetInteractTime(Character interactor)
		{
			return openRadialMenuTime;
		}

		public void Interact_CastFinished(Character interactor)
		{
		}

		public void CancelCast(Character interactor)
		{
		}

		[PunRPC]
		public void RPC_SetGarbageBagFilled(bool isEmpty)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0075: 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)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			if (m_isEmpty == isEmpty)
			{
				return;
			}
			if (!isEmpty)
			{
				if ((int)((Item)this).itemState == 0 && base.view.IsMine)
				{
					Transform transform = ((Component)this).transform;
					Vector3 position = ((Component)this).transform.position;
					Vector3 gravity = Physics.gravity;
					transform.position = position + -((Vector3)(ref gravity)).normalized * fullBagRadius;
					Rigidbody rig = base.rig;
					Vector3 position2 = base.rig.position;
					gravity = Physics.gravity;
					rig.MovePosition(position2 + -((Vector3)(ref gravity)).normalized * fullBagRadius);
				}
				emptyBagGameObject.SetActive(false);
				fullBagGameObject.SetActive(true);
			}
			else
			{
				fullBagGameObject.SetActive(false);
				emptyBagGameObject.SetActive(true);
			}
			m_isEmpty = isEmpty;
			RefreshVisualReferences();
		}

		private bool HasSpace()
		{
			return ((Item)this).GetData<BackpackData>((DataEntryKey)7).FilledSlotCount() < 2;
		}

		public int FilledSlotCount()
		{
			return ((Item)this).GetData<BackpackData>((DataEntryKey)7).FilledSlotCount();
		}

		public void Stash(Character interactor, byte garbageBagSlotID)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)interactor.data.currentItem) || !HasSpace())
			{
				return;
			}
			CharacterItems items = interactor.refs.items;
			if (items.currentSelectedSlot.IsNone)
			{
				UnnamedPlugin.Log.LogError((object)"Need item slot selected to stash item in backpack!");
				return;
			}
			ItemSlot itemSlot = interactor.player.GetItemSlot(items.currentSelectedSlot.Value);
			if (itemSlot == null)
			{
				UnnamedPlugin.Log.LogError((object)$"Failed to get a non-null item slot for {items.currentSelectedSlot.Value}");
				return;
			}
			if (itemSlot.IsEmpty())
			{
				UnnamedPlugin.Log.LogError((object)$"Item slot {itemSlot.itemSlotID} is empty!");
				return;
			}
			base.view.RPC("RPCAddItemToGarbageBag", (RpcTarget)0, new object[3]
			{
				((Component)interactor.player).GetComponent<PhotonView>(),
				items.currentSelectedSlot.Value,
				garbageBagSlotID
			});
			interactor.player.EmptySlot(items.currentSelectedSlot);
			Optionable<byte> currentSelectedSlot = items.currentSelectedSlot;
			if (currentSelectedSlot.IsSome && currentSelectedSlot.Value == 250)
			{
				((MonoBehaviourPun)interactor).photonView.RPC("DestroyHeldItemRpc", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				items.EquipSlot(Optionable<byte>.None);
			}
		}

		[ConsoleCommand]
		public static void PrintGarbageBags()
		{
			UnnamedGarbageBagController[] array = Object.FindObjectsByType<UnnamedGarbageBagController>((FindObjectsInactive)0, (FindObjectsSortMode)1);
			UnnamedGarbageBagController[] array2 = array;
			foreach (UnnamedGarbageBagController unnamedGarbageBagController in array2)
			{
				List<ItemSlot> list = ((Item)unnamedGarbageBagController).GetData<BackpackData>((DataEntryKey)7).itemSlots.Where((ItemSlot slot) => !slot.IsEmpty()).ToList();
				UnnamedPlugin.Log.LogInfo((object)$"Garbage Bag: {((Object)unnamedGarbageBagController).GetInstanceID()}, Full Slots: {list.Count}");
				foreach (ItemSlot item in list)
				{
					UnnamedPlugin.Log.LogInfo((object)$"Slot: {item.GetPrefabName()}, data entries: {item.data.data.Count}");
				}
			}
		}

		public override void OnInstanceDataRecieved()
		{
			((Item)this).OnInstanceDataRecieved();
			m_unnamedGarbageBagVisuals.RefreshVisuals();
		}

		[PunRPC]
		public void RPC_DropRandomBaggedItem()
		{
			DropRandomBaggedItem();
		}

		[PunRPC]
		public void RPC_SlipItem(Vector3 linearVelocity, Vector3 angularVelocity)
		{
			//IL_000d: 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)
			Item val = DropRandomBaggedItem();
			val.rig.linearVelocity = linearVelocity;
			val.rig.angularVelocity = angularVelocity;
		}

		public Item DropRandomBaggedItem()
		{
			BackpackData data = ((Item)this).GetData<BackpackData>((DataEntryKey)7);
			ItemSlot random;
			do
			{
				random = ArrayExtensions.GetRandom<ItemSlot>(data.itemSlots);
			}
			while (random.IsEmpty());
			((MonoBehaviourPun)this).photonView.RPC("RPC_ItemSlipped", (RpcTarget)0, Array.Empty<object>());
			return TakeItemOut(random);
		}

		[PunRPC]
		public void RPC_TakeItemOut(byte slotID)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				TakeItemOut(((Item)this).GetData<BackpackData>((DataEntryKey)7).itemSlots[slotID]);
			}
		}

		[PunRPC]
		public void RPC_TakeAndGrabItem(byte slotID, PhotonView characterView)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				ItemSlot slot = ((Item)this).GetData<BackpackData>((DataEntryKey)7).itemSlots[slotID];
				Character component = ((Component)characterView).GetComponent<Character>();
				Bodypart bodypart = component.GetBodypart((BodypartType)0);
				component.refs.items.lastEquippedSlotTime = 0f;
				Item val = TakeItemOut(slot, bodypart);
				if (val != null)
				{
					val.Interact(component);
				}
			}
		}

		[PunRPC]
		public void RPC_ItemSlipped()
		{
			PlaySlipSFX();
		}

		[PunRPC]
		public void RPC_EmptySlot(byte slotId)
		{
			ItemSlot val = ((Item)this).GetData<BackpackData>((DataEntryKey)7).itemSlots[slotId];
			val.EmptyOut();
			if (base.view.IsMine)
			{
				m_unnamedGarbageBagVisuals.RefreshVisuals();
			}
		}

		public void PlaySlipSFX()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			int i = 0;
			for (int num = slipSDSfxInstances.Length; i < num; i++)
			{
				slipSDSfxInstances[i].Play(((Component)this).transform.position);
			}
		}

		public Item? TakeItemOut(ItemSlot slot, Bodypart? part = null)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			Vector3 val;
			if ((int)((Item)this).itemState != 1)
			{
				Vector3 gravity = Physics.gravity;
				val = -((Vector3)(ref gravity)).normalized;
			}
			else
			{
				val = transform.up;
			}
			Vector3 val2 = val;
			Vector3 val3 = (((Object)(object)part != (Object)null) ? (((Component)part).transform.position + ((Component)part).transform.forward * 0.5f) : (transform.position + val2 * fullBagRadius));
			GameObject val4 = PhotonNetwork.InstantiateItemRoom(slot.GetPrefabName(), val3, transform.rotation);
			if ((Object)(object)val4 == (Object)null)
			{
				return null;
			}
			val4.GetComponent<PhotonView>().RPC("SetItemInstanceDataRPC", (RpcTarget)0, new object[1] { slot.data });
			Rigidbody val5 = default(Rigidbody);
			if (val4.TryGetComponent<Rigidbody>(ref val5) && val5.isKinematic)
			{
				val4.GetComponent<Item>().SetKinematicNetworked(false);
			}
			base.view.RPC("RPC_EmptySlot", (RpcTarget)0, new object[1] { slot.itemSlotID });
			((MonoBehaviourPun)this).photonView.RPC("SetItemInstanceDataRPC", (RpcTarget)0, new object[1] { base.data });
			return val4.GetComponent<Item>();
		}

		[PunRPC]
		public void RPCAddItemToGarbageBag(PhotonView playerView, byte slotID, byte garbageBagSlotID)
		{
			BackpackData data = ((Item)this).GetData<BackpackData>((DataEntryKey)7);
			ItemSlot itemSlot = ((Component)playerView).GetComponent<Player>().GetItemSlot(slotID);
			if (itemSlot == null)
			{
				UnnamedPlugin.Log.LogError((object)$"Can't add item because slot ID {slotID} is not valid.");
				return;
			}
			data.AddItem(itemSlot.prefab, itemSlot.data, garbageBagSlotID);
			if (base.view.IsMine)
			{
				m_unnamedGarbageBagVisuals.RefreshVisuals();
			}
		}
	}
	public struct UnnamedGarbageBagReference : IBinarySerializable
	{
		public Transform locationTransform;

		public PhotonView view;

		public void Serialize(BinarySerializer serializer)
		{
			serializer.WriteInt(view.ViewID);
		}

		public void Deserialize(BinaryDeserializer deserializer)
		{
			view = PhotonView.Find(deserializer.ReadInt());
		}

		public BackpackData GetData()
		{
			return ((Component)view).GetComponent<Item>().GetData<BackpackData>((DataEntryKey)7);
		}

		public static UnnamedGarbageBagReference GetFromBackpackItem(Item item)
		{
			UnnamedGarbageBagReference result = default(UnnamedGarbageBagReference);
			result.view = ((Component)item).GetComponent<PhotonView>();
			result.locationTransform = ((Component)item).transform;
			return result;
		}

		public bool TryGetGarbageBagItem(out UnnamedGarbageBagController garbageBag)
		{
			return ((Component)view).TryGetComponent<UnnamedGarbageBagController>(ref garbageBag);
		}
	}
	[RequireComponent(typeof(PhotonView))]
	public class UnnamedGarbageBagSlips : MonoBehaviour
	{
		public UnnamedGarbageBagController garbageBag;

		public bool slipOnCollision;

		public float minSlipVelocity;

		public bool ragdollCharacterOnSlip;

		public Rigidbody rig;

		private Vector3 m_lastVelocity;

		public float pushForce = 2f;

		public float wholeBodyPushForce = 1f;

		private bool m_justSlipped;

		private bool m_justThrown;

		private void Awake()
		{
			if (garbageBag == null)
			{
				garbageBag = ((Component)this).GetComponent<UnnamedGarbageBagController>();
			}
			if (rig == null)
			{
				rig = ((Component)this).GetComponent<Rigidbody>();
			}
			GlobalEvents.OnItemThrown = (Action<Item>)Delegate.Combine(GlobalEvents.OnItemThrown, new Action<Item>(OnItemThrown));
		}

		private void OnItemThrown(Item obj)
		{
			if ((Object)(object)obj == (Object)(object)garbageBag)
			{
				m_justThrown = true;
			}
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_00d5: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			if (((MonoBehaviourPun)garbageBag).photonView.IsMine && (int)((Item)garbageBag).itemState == 0 && slipOnCollision && Object.op_Implicit((Object)(object)((Item)garbageBag).rig))
			{
				Vector3 relativeVelocity = collision.relativeVelocity;
				if (((Vector3)(ref relativeVelocity)).magnitude > minSlipVelocity)
				{
					if (((!m_justThrown || !(Time.time - ((Item)garbageBag).lastThrownTime > 0.15f)) && m_justThrown) || !garbageBag.shouldSlip)
					{
						return;
					}
					((Item)garbageBag).view.RPC("RPC_SlipItem", (RpcTarget)2, new object[2]
					{
						((Item)garbageBag).rig.linearVelocity,
						((Item)garbageBag).rig.angularVelocity
					});
					m_justSlipped = true;
					garbageBag.m_unnamedGarbageBagVisuals.RefreshVisuals();
					if (ragdollCharacterOnSlip)
					{
						Character componentInParent = ((Component)collision.transform).GetComponentInParent<Character>();
						if (componentInParent != null)
						{
							Rigidbody componentInParent2 = ((Component)collision.transform).GetComponentInParent<Rigidbody>();
							Vector3 val = ((Vector3)(ref m_lastVelocity)).normalized * pushForce;
							componentInParent.AddForceToBodyPart(componentInParent2, val * pushForce, val * wholeBodyPushForce);
							componentInParent.Fall(2f, 15f);
						}
					}
					return;
				}
			}
			m_justThrown = false;
		}

		private void FixedUpdate()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (((MonoBehaviourPun)garbageBag).photonView.IsMine && Object.op_Implicit((Object)(object)rig) && !rig.isKinematic)
			{
				m_lastVelocity = rig.linearVelocity;
				if ((double)((Vector3)(ref m_lastVelocity)).sqrMagnitude <= 0.0001)
				{
					m_justSlipped = false;
				}
			}
		}
	}
	public class UnnamedGarbageBagVisuals : MonoBehaviour
	{
		public Item item;

		protected bool m_shuttingDown;

		private void Awake()
		{
			if (item == null)
			{
				item = ((Component)this).GetComponent<Item>();
			}
			if (item.view.IsMine)
			{
				item.view.RPC("RPC_SetGarbageBagFilled", (RpcTarget)0, new object[1] { GetBackpackData().FilledSlotCount() <= 0 });
			}
		}

		public BackpackData GetBackpackData()
		{
			return item.GetData<BackpackData>((DataEntryKey)7);
		}

		public void RefreshVisuals()
		{
			if (item.view.IsMine)
			{
				item.view.RPC("RPC_SetGarbageBagFilled", (RpcTarget)0, new object[1] { GetBackpackData().FilledSlotCount() <= 0 });
			}
		}

		public void OnApplicationQuit()
		{
			m_shuttingDown = true;
		}
	}
}
namespace UnnamedProducts.Behaviours.Item.GarbageBag.GUI
{
	public class UnnamedGarbageBagScreen : UIWheel
	{
		public UnnamedGarbageBagZone[] garbageBagZones;

		public UnnamedGarbageBagZone pickupZone;

		public TextMeshProUGUI chosenItemText;

		public Optionable<UnnamedGarbageBagZone.ZoneData> chosenZone;

		public UnnamedGarbageBagReference garbageBag;

		public RawImage currentlyHeldItem;

		private int currentlyHeldItemCookedAmount;

		private void Awake()
		{
			((TMP_Text)chosenItemText).font = UnnamedPlugin.DarumaDropOne;
			((TMP_Text)chosenItemText).lineSpacing = -50f;
			TextMeshProUGUI obj = chosenItemText;
			TextMeshProUGUI obj2 = chosenItemText;
			Material val = (((Graphic)chosenItemText).material = UnnamedPlugin.DarumaDropOneShadowMaterial);
			Material fontSharedMaterial = (((TMP_Text)obj2).fontMaterial = val);
			((TMP_Text)obj).fontSharedMaterial = fontSharedMaterial;
		}

		public void InitWheel(UnnamedGarbageBagReference gb)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			garbageBag = gb;
			chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.None;
			((TMP_Text)chosenItemText).text = "";
			ItemSlot[] itemSlots = garbageBag.GetData().itemSlots;
			int num = Mathf.Min(itemSlots.Length, 2);
			for (byte b = 0; b < num; b++)
			{
				garbageBagZones[b].InitItemSlot((gb, b), this);
			}
			((Component)this).gameObject.SetActive(true);
			pickupZone.InitPickupGarbageBag(gb, this);
			if ((Object)(object)Character.localCharacter.data.currentItem != (Object)null && Character.localCharacter.data.currentItem.UIData.canBackpack)
			{
				currentlyHeldItem.texture = (Texture)(object)Character.localCharacter.data.currentItem.UIData.GetIcon();
				UpdateCookedAmount(Character.localCharacter.data.currentItem);
				((Behaviour)currentlyHeldItem).enabled = true;
			}
			else
			{
				UpdateCookedAmount(null);
				((Behaviour)currentlyHeldItem).enabled = false;
			}
		}

		private void UpdateCookedAmount(Item item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			IntItemData val = default(IntItemData);
			if ((Object)(object)item == (Object)null || item.data == null)
			{
				currentlyHeldItemCookedAmount = 0;
				((Graphic)currentlyHeldItem).color = Color.white;
			}
			else if (item.data.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val) && currentlyHeldItemCookedAmount != val.Value)
			{
				((Graphic)currentlyHeldItem).color = Color.white;
				((Graphic)currentlyHeldItem).color = ItemCooking.GetCookColor(val.Value);
				currentlyHeldItemCookedAmount = val.Value;
			}
		}

		public override void Update()
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			if (!Character.localCharacter.input.interactIsPressed)
			{
				Choose();
				UnnamedUIManager.Instance.CloseGarbageBagScreen();
				return;
			}
			if ((Object)(object)garbageBag.view == (Object)null || !garbageBag.TryGetGarbageBagItem(out UnnamedGarbageBagController _))
			{
				UnnamedPlugin.Log.LogInfo((object)"Garbage Bag got removed. Closing UI...");
				UnnamedUIManager.Instance.CloseGarbageBagScreen();
				return;
			}
			if ((Object)(object)garbageBag.locationTransform != (Object)null && garbageBag.locationTransform.position.SquareDistance(Character.localCharacter.Center) > 36f)
			{
				UnnamedPlugin.Log.LogInfo((object)"Garbage Bag got too far away. Closing UI...");
				UnnamedUIManager.Instance.CloseGarbageBagScreen();
				return;
			}
			Optionable<UnnamedGarbageBagZone.ZoneData> val = chosenZone;
			if (val.IsSome && !val.Value.isGarbageBagPickup && !((Behaviour)garbageBagZones[chosenZone.Value.slotID].image).enabled)
			{
				((Component)currentlyHeldItem).transform.position = Vector3.Lerp(((Component)currentlyHeldItem).transform.position, ((Component)garbageBagZones[chosenZone.Value.slotID]).transform.GetChild(0).GetChild(0).position, Time.deltaTime * 20f);
			}
			else
			{
				((Component)currentlyHeldItem).transform.localPosition = Vector3.Lerp(((Component)currentlyHeldItem).transform.localPosition, Vector3.zero, Time.deltaTime * 20f);
			}
			((UIWheel)this).Update();
		}

		public void Choose()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Invalid comparison between Unknown and I4
			if (!chosenZone.IsSome)
			{
				return;
			}
			UnnamedPlugin.Log.LogDebug((object)$"Chose zone {chosenZone.Value.slotID}");
			if (chosenZone.Value.isGarbageBagPickup)
			{
				if (chosenZone.Value.garbageBagReference.TryGetGarbageBagItem(out UnnamedGarbageBagController unnamedGarbageBagController) && (int)((Item)unnamedGarbageBagController).itemState != 1)
				{
					unnamedGarbageBagController.PickUpGarbageBag(Character.localCharacter);
				}
				return;
			}
			if (chosenZone.Value.isStashZone)
			{
				TryStash(chosenZone.Value.slotID);
				return;
			}
			ItemSlot val = chosenZone.Value.garbageBagReference.GetData().itemSlots[chosenZone.Value.slotID];
			if (!val.IsEmpty() && chosenZone.Value.garbageBagReference.TryGetGarbageBagItem(out UnnamedGarbageBagController unnamedGarbageBagController2) && (int)((Item)unnamedGarbageBagController2).itemState != 1)
			{
				((MonoBehaviourPun)unnamedGarbageBagController2).photonView.RPC("RPC_TakeAndGrabItem", (RpcTarget)0, new object[2]
				{
					val.itemSlotID,
					((MonoBehaviourPun)Character.localCharacter).photonView
				});
			}
			else if (Object.op_Implicit((Object)(object)Character.localCharacter.data.currentItem))
			{
				TryStash(chosenZone.Value.slotID);
			}
		}

		private void TryStash(byte backpackSlotID)
		{
			if (garbageBag.TryGetGarbageBagItem(out UnnamedGarbageBagController unnamedGarbageBagController))
			{
				unnamedGarbageBagController.Stash(Character.localCharacter, backpackSlotID);
			}
		}

		public void Hover(UnnamedGarbageBagZone.ZoneData zoneData)
		{
			//IL_0066: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			if (zoneData.isGarbageBagPickup)
			{
				if (zoneData.garbageBagReference.TryGetGarbageBagItem(out UnnamedGarbageBagController unnamedGarbageBagController) && (int)((Item)unnamedGarbageBagController).itemState != 1)
				{
					((TMP_Text)chosenItemText).text = LocalizedText.GetText("CARRY", true).Replace("#", ((Item)unnamedGarbageBagController).GetItemName((ItemInstanceData)null));
					chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.Some(zoneData);
				}
				else
				{
					((TMP_Text)chosenItemText).text = "";
					chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.None;
				}
				return;
			}
			if (zoneData.isStashZone)
			{
				Item currentItem = Character.localCharacter.data.currentItem;
				if ((Object)(object)currentItem != (Object)null)
				{
					((TMP_Text)chosenItemText).text = LocalizedText.GetText("STASHITEM", true).Replace("#", currentItem.GetItemName((ItemInstanceData)null));
					chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.Some(zoneData);
				}
				else
				{
					((TMP_Text)chosenItemText).text = "";
					chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.None;
				}
				return;
			}
			ItemSlot val = garbageBag.GetData().itemSlots[zoneData.slotID];
			bool flag = false;
			if (val.IsEmpty() && Object.op_Implicit((Object)(object)Character.localCharacter.data.currentItem))
			{
				if (Object.op_Implicit((Object)(object)Character.localCharacter.data.currentItem))
				{
					((TMP_Text)chosenItemText).text = LocalizedText.GetText("STASHITEM", true).Replace("#", Character.localCharacter.data.currentItem.GetItemName((ItemInstanceData)null));
					flag = true;
				}
			}
			else
			{
				Item prefab = val.prefab;
				if ((Object)(object)prefab != (Object)null)
				{
					((TMP_Text)chosenItemText).text = LocalizedText.GetText("TAKEITEM", true).Replace("#", prefab.GetItemName(val.data));
					flag = true;
				}
			}
			if (flag)
			{
				chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.Some(zoneData);
			}
		}

		public void Dehover(UnnamedGarbageBagZone.ZoneData zoneData)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (chosenZone.IsSome && chosenZone.Value.Equals(zoneData))
			{
				((TMP_Text)chosenItemText).text = "";
				chosenZone = Optionable<UnnamedGarbageBagZone.ZoneData>.None;
			}
		}

		public override void TestSelectSliceGamepad(Vector2 gamepadVector)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			UnnamedGarbageBagZone unnamedGarbageBagZone = null;
			if (!(((Vector2)(ref gamepadVector)).sqrMagnitude < 0.5f))
			{
				float num2 = Vector3.Angle(Vector2.op_Implicit(gamepadVector), ((UIWheelSlice)pickupZone).GetUpVector());
				if ((Object)(object)unnamedGarbageBagZone == (Object)null || num2 < num)
				{
					unnamedGarbageBagZone = pickupZone;
					num = num2;
				}
				num2 = Vector3.Angle(Vector2.op_Implicit(gamepadVector), ((UIWheelSlice)pickupZone).GetUpVector());
				if ((Object)(object)unnamedGarbageBagZone == (Object)null || num2 < num)
				{
					unnamedGarbageBagZone = pickupZone;
					num = num2;
				}
			}
			if ((Object)(object)unnamedGarbageBagZone != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)((UIWheelSlice)unnamedGarbageBagZone).button).gameObject);
				unnamedGarbageBagZone.Hover();
			}
			else
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
				Dehover(chosenZone.Value);
			}
		}
	}
	public class UnnamedGarbageBagZone : UIWheelSlice, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public struct ZoneData : IEquatable<ZoneData>
		{
			public bool isStashZone;

			public bool isGarbageBagPickup;

			public UnnamedGarbageBagReference garbageBagReference;

			public byte slotID;

			public bool Equals(ZoneData other)
			{
				if (isGarbageBagPickup == other.isGarbageBagPickup)
				{
					return slotID == other.slotID;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is ZoneData other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(isGarbageBagPickup, garbageBagReference, slotID);
			}
		}

		public RawImage image;

		private int cookedAmount;

		private bool hasItem;

		private bool isDepositZone;

		private BackpackData garbageBagData;

		private ItemSlot itemSlot;

		private UnnamedGarbageBagReference garbageBag;

		private UnnamedGarbageBagScreen garbageBagScreen;

		public byte garbageBagSlot { get; private set; }

		private bool canInteract
		{
			get
			{
				if (isGarbageBagPickup)
				{
					return true;
				}
				if (isDepositZone)
				{
					return true;
				}
				if (!hasItem)
				{
					if ((Object)(object)Character.localCharacter.data.currentItem != (Object)null)
					{
						return Character.localCharacter.data.currentItem.UIData.canBackpack;
					}
					return false;
				}
				return true;
			}
		}

		public bool isGarbageBagPickup => garbageBagSlot == byte.MaxValue;

		public void OnPointerEnter(PointerEventData eventData)
		{
			Hover();
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			Dehover();
		}

		private void UpdateInteractable()
		{
			((Selectable)base.button).interactable = canInteract;
		}

		private void SharedInit(UnnamedGarbageBagReference gbRef, UnnamedGarbageBagScreen screen)
		{
			garbageBag = gbRef;
			garbageBagScreen = screen;
			if (garbageBagSlot == byte.MaxValue)
			{
				((Component)this).gameObject.SetActive(true);
			}
			SetExplicitIcon(UnnamedPlugin.GarbageBagIcon);
		}

		public void InitItemSlot((UnnamedGarbageBagReference, byte slotID) slot, UnnamedGarbageBagScreen wheel)
		{
			SharedInit(slot.Item1, wheel);
			garbageBagSlot = slot.slotID;
			garbageBagData = garbageBag.GetData();
			itemSlot = garbageBagData.itemSlots[garbageBagSlot];
			SetItemIcon(itemSlot.prefab, itemSlot.data);
			UpdateInteractable();
		}

		private void UpdateCookedAmount(Item? item, ItemInstanceData? itemInstanceData)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			IntItemData val = default(IntItemData);
			if ((Object)(object)item == (Object)null || itemInstanceData == null)
			{
				cookedAmount = 0;
				if ((Object)(object)image != (Object)null)
				{
					((Graphic)image).color = Color.white;
				}
			}
			else if (itemInstanceData.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val) && cookedAmount != val.Value)
			{
				if ((Object)(object)image != (Object)null)
				{
					((Graphic)image).color = Color.white;
					((Graphic)image).color = ItemCooking.GetCookColor(val.Value);
				}
				cookedAmount = val.Value;
			}
		}

		public void Hover()
		{
			if (canInteract)
			{
				ZoneData zoneData = default(ZoneData);
				zoneData.isStashZone = isDepositZone;
				zoneData.isGarbageBagPickup = isGarbageBagPickup;
				zoneData.garbageBagReference = garbageBag;
				zoneData.slotID = garbageBagSlot;
				ZoneData zoneData2 = zoneData;
				garbageBagScreen.Hover(zoneData2);
			}
		}

		public void Dehover()
		{
			ZoneData zoneData = default(ZoneData);
			zoneData.isStashZone = isDepositZone;
			zoneData.isGarbageBagPickup = garbageBagSlot == byte.MaxValue;
			zoneData.garbageBagReference = garbageBag;
			zoneData.slotID = garbageBagSlot;
			ZoneData zoneData2 = zoneData;
			garbageBagScreen.Dehover(zoneData2);
		}

		public void InitPickupGarbageBag(UnnamedGarbageBagReference gb, UnnamedGarbageBagScreen gbs)
		{
			garbageBagSlot = byte.MaxValue;
			SharedInit(gb, gbs);
			UpdateInteractable();
		}

		private void SetItemIcon(Item iconHolder, ItemInstanceData itemInstanceData)
		{
			object explicitIcon;
			if (iconHolder == null)
			{
				explicitIcon = null;
			}
			else
			{
				ItemUIData uIData = iconHolder.UIData;
				explicitIcon = ((uIData != null) ? uIData.GetIcon() : null);
			}
			SetExplicitIcon((Texture2D?)explicitIcon);
			UpdateCookedAmount(iconHolder, itemInstanceData);
		}

		private void SetExplicitIcon(Texture2D? icon)
		{
			if ((Object)(object)icon == (Object)null)
			{
				if ((Object)(object)image != (Object)null)
				{
					((Behaviour)image).enabled = false;
				}
				hasItem = false;
				return;
			}
			if ((Object)(object)image != (Object)null)
			{
				((Behaviour)image).enabled = true;
				image.texture = (Texture)(object)icon;
			}
			hasItem = true;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}