using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using FishNet;
using FishNet.Managing;
using FishNet.Managing.Object;
using FishNet.Object;
using Flatline;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ScheduleOne;
using ScheduleOne.Audio;
using ScheduleOne.AvatarFramework;
using ScheduleOne.Building.Doors;
using ScheduleOne.Combat;
using ScheduleOne.Core.Items.Framework;
using ScheduleOne.DevUtilities;
using ScheduleOne.Dialogue;
using ScheduleOne.Doors;
using ScheduleOne.EntityFramework;
using ScheduleOne.Equipping;
using ScheduleOne.FX;
using ScheduleOne.GameTime;
using ScheduleOne.Interaction;
using ScheduleOne.ItemFramework;
using ScheduleOne.Map;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.CharacterClasses;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.PlayerScripts.Health;
using ScheduleOne.Product;
using ScheduleOne.Property;
using ScheduleOne.Temperature;
using ScheduleOne.UI;
using ScheduleOne.UI.MainMenu;
using ScheduleOne.UI.Phone;
using ScheduleOne.UI.Phone.Messages;
using ScheduleOne.VoiceOver;
using ScheduleOne.Weather;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(global::Flatline.Flatline), "Flatline", "1.0.1", "XOWithSauce", "https://github.com/XOWithSauce/schedule-flatline")]
[assembly: MelonColor]
[assembly: MelonOptionalDependencies(new string[] { "FishNet.Runtime" })]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: VerifyLoaderVersion("0.7.0", true)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ScheduleOne.Core")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("XOWithSauce")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright XOWithSauce 2026 Source MIT")]
[assembly: AssemblyDescription("Schedule I Flatline Mod")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("Flatline")]
[assembly: AssemblyTitle("Flatline")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/XOWithSauce/schedule-flatline")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Flatline
{
	public static class BedRotSimulator
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public NetworkManager instance;

			internal bool <InitBedRotModule>b__1()
			{
				return instance.Initialized;
			}
		}

		[CompilerGenerated]
		private sealed class <BedRotSimulatorRunner>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InteractableObject intObj;

			public Bed bed;

			private Transform <playerTrRoot>5__2;

			private Vector3 <originalStandPoint>5__3;

			private Quaternion <originalRotation>5__4;

			private Vector3 <targetLocalPosition>5__5;

			private Quaternion <targetRotation>5__6;

			private float <animationDuration>5__7;

			private float <elapsed>5__8;

			private float <maxY>5__9;

			private Quaternion <currentRotation>5__10;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <BedRotSimulatorRunner>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<playerTrRoot>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: 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_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0351: 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_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: 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_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_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Behaviour)intObj).enabled = false;
					((Behaviour)bed.intObj).enabled = false;
					Player.Local.CurrentBed = ((NetworkBehaviour)bed).NetworkObject;
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(false);
					PlayerSingleton<PlayerMovement>.Instance.CanMove = false;
					((Behaviour)PlayerSingleton<PlayerMovement>.Instance).enabled = false;
					((Collider)Player.Local.CapCol).enabled = false;
					<playerTrRoot>5__2 = ((Component)Player.Local).transform.root;
					<playerTrRoot>5__2.parent = ((Component)bed).transform;
					<originalStandPoint>5__3 = <playerTrRoot>5__2.localPosition;
					<originalRotation>5__4 = <playerTrRoot>5__2.localRotation;
					<targetLocalPosition>5__5 = new Vector3(0.009f, 0.24f, 0.012f);
					<targetRotation>5__6 = Quaternion.Euler(270f, 0f, 0f);
					<animationDuration>5__7 = 3f;
					<elapsed>5__8 = 0f;
					goto IL_0193;
				case 1:
					<>1__state = -1;
					goto IL_0193;
				case 2:
					<>1__state = -1;
					if (Quaternion.Angle(<playerTrRoot>5__2.localRotation, <targetRotation>5__6) > <maxY>5__9)
					{
						<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<playerTrRoot>5__2.localRotation, <targetRotation>5__6, 0.05f);
					}
					if ((PlayerSingleton<Phone>.Instance.IsOpen || (!Input.GetKey((KeyCode)32) && !Input.GetKey((KeyCode)119) && !Input.GetKey((KeyCode)97) && !Input.GetKey((KeyCode)115) && !Input.GetKey((KeyCode)100))) && !FlatlinePlayer.isPassedOut && !FlatlinePlayer.isQueuedForDeath)
					{
						goto IL_028e;
					}
					goto IL_0298;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_028e:
					if (Flatline.registered)
					{
						<>2__current = Flatline.WaitFrame;
						<>1__state = 2;
						return true;
					}
					goto IL_0298;
					IL_0193:
					if (<elapsed>5__8 < <animationDuration>5__7 && Flatline.registered)
					{
						float num = <elapsed>5__8 / <animationDuration>5__7;
						<playerTrRoot>5__2.localPosition = Vector3.Lerp(<originalStandPoint>5__3, <targetLocalPosition>5__5, num);
						<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<originalRotation>5__4, <targetRotation>5__6, num);
						<elapsed>5__8 += Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<playerTrRoot>5__2.localPosition = <targetLocalPosition>5__5;
					<playerTrRoot>5__2.localRotation = <targetRotation>5__6;
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(true);
					<maxY>5__9 = 20f;
					goto IL_028e;
					IL_0298:
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(false);
					<elapsed>5__8 = 0f;
					<currentRotation>5__10 = <playerTrRoot>5__2.localRotation;
					break;
				}
				if (<elapsed>5__8 < <animationDuration>5__7 && Flatline.registered)
				{
					float num2 = <elapsed>5__8 / <animationDuration>5__7;
					<playerTrRoot>5__2.localPosition = Vector3.Lerp(<targetLocalPosition>5__5, <originalStandPoint>5__3, num2);
					<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<currentRotation>5__10, <originalRotation>5__4, num2);
					<elapsed>5__8 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<playerTrRoot>5__2.localPosition = <originalStandPoint>5__3;
				<playerTrRoot>5__2.localRotation = <originalRotation>5__4;
				<playerTrRoot>5__2.parent = null;
				((Collider)Player.Local.CapCol).enabled = true;
				PlayerSingleton<PlayerCamera>.Instance.SetCanLook(true);
				((Behaviour)PlayerSingleton<PlayerMovement>.Instance).enabled = true;
				PlayerSingleton<PlayerMovement>.Instance.CanMove = true;
				((Behaviour)intObj).enabled = true;
				((Behaviour)bed.intObj).enabled = true;
				isBedrotting = false;
				Player.Local.CurrentBed = null;
				AfterBedrotEnd();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EvaluateBedState>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InteractableObject intObj;

			public Bed bed;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EvaluateBedState>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (Player.Local.IsSkating)
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot while skateboarding";
					}
					else if ((Object)(object)bed.AssignedEmployee != (Object)null)
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot in an employee's bed";
					}
					else if (NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(359, 700))
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot at late night";
					}
					else if (Player.PlayerList.Count > 1)
					{
						foreach (Player player in Player.PlayerList)
						{
							if ((Object)(object)player.CurrentBed == (Object)(object)((NetworkBehaviour)bed).NetworkObject)
							{
								intObj.SetInteractableState((EInteractableState)1);
								intObj.message = "Someone is already bedrotting here";
							}
						}
					}
					else
					{
						intObj.SetInteractableState((EInteractableState)0);
						intObj.message = "Rot in the bed";
					}
					<>2__current = Flatline.Wait1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					isEvaluatingBedState = false;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <InitBedRotModule>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass6_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitBedRotModule>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass6_0();
					WaitUntil val2 = new WaitUntil((Func<bool>)(() => NetworkManager.Instances != null && NetworkManager.Instances.Count > 0));
					<>2__current = val2;
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					<>8__1.instance = NetworkManager.Instances.ToList()[0];
					WaitUntil val = new WaitUntil((Func<bool>)(() => <>8__1.instance.Initialized));
					<>2__current = val;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					PrepareBedRotInteractable();
					DebugModule.Log("Bed prefab changed succesfully", "InitBedRotModule");
					isInitialized = true;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool isBedrotting = false;

		public static bool isInitialized = false;

		public static bool isEvaluatingBedState = false;

		public static readonly float energyRegenPerMinute = FlatlinePlayer.DefaultEnergyConsumption + 0.003f;

		public static readonly float healthRegenPerMinuteTarget = FlatlinePlayer.DefaultHealthRegeneration * 5f;

		public static readonly float healthRegenT = FlatlinePlayer.SystematicHomeostasisSpeed * 10f;

		[IteratorStateMachine(typeof(<InitBedRotModule>d__6))]
		public static IEnumerator InitBedRotModule()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitBedRotModule>d__6(0);
		}

		public static void ResetBedRotModule()
		{
			isBedrotting = false;
			isEvaluatingBedState = false;
		}

		public static void PrepareBedRotInteractable()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			PrefabObjects spawnablePrefabs = Object.FindObjectOfType<NetworkManager>(true).SpawnablePrefabs;
			for (int i = 0; i < spawnablePrefabs.GetObjectCount(); i++)
			{
				NetworkObject @object = spawnablePrefabs.GetObject(true, i);
				if (((@object != null) ? ((Object)((Component)@object).gameObject).name : null).Contains("SingleBed"))
				{
					((Component)@object).GetComponent<Bed>();
					GameObject val = new GameObject("BedRotIntObj");
					val.transform.parent = ((Component)@object).transform;
					((Object)val.gameObject).name = "BedRotIntObj";
					val.transform.position = new Vector3(0f, 0.264f, 0.8f);
					BoxCollider val2 = val.AddComponent<BoxCollider>();
					((Collider)val2).isTrigger = true;
					InteractableObject obj = val.AddComponent<InteractableObject>();
					obj.message = "Rot in the bed";
					obj.SetInteractableState((EInteractableState)0);
					val.SetActive(true);
					((Collider)val2).enabled = true;
					((Behaviour)obj).enabled = true;
				}
			}
		}

		public static void BedRotInteracted(InteractableObject intObj, Bed bed)
		{
			if (!isBedrotting)
			{
				isBedrotting = true;
				Flatline.coros.Add(MelonCoroutines.Start(BedRotSimulatorRunner(intObj, bed)));
			}
		}

		public static void BedRotInteractableHovered(InteractableObject intObj, Bed bed)
		{
			if (!isEvaluatingBedState)
			{
				isEvaluatingBedState = true;
				Flatline.coros.Add(MelonCoroutines.Start(EvaluateBedState(intObj, bed)));
			}
		}

		[IteratorStateMachine(typeof(<EvaluateBedState>d__11))]
		public static IEnumerator EvaluateBedState(InteractableObject intObj, Bed bed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EvaluateBedState>d__11(0)
			{
				intObj = intObj,
				bed = bed
			};
		}

		[IteratorStateMachine(typeof(<BedRotSimulatorRunner>d__12))]
		public static IEnumerator BedRotSimulatorRunner(InteractableObject intObj, Bed bed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BedRotSimulatorRunner>d__12(0)
			{
				intObj = intObj,
				bed = bed
			};
		}

		public static void MinPassBedrotting()
		{
			if (!Flatline.registered || Flatline.isSaving || !isBedrotting || FlatlinePlayer.isQueuedForDeath || Flatline.haltExecution)
			{
				return;
			}
			if (Flatline.loadedPlayerData.State.Energy < 1f)
			{
				FlatlinePlayer.SetEnergy(Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy + energyRegenPerMinute));
			}
			if (Flatline.loadedPlayerData.State.healthData.CurrentHP < Flatline.loadedPlayerData.State.healthData.MaxHP)
			{
				if (FlatlinePlayer.HealthRegenPerMinute < healthRegenPerMinuteTarget)
				{
					FlatlinePlayer.HealthRegenPerMinute = Mathf.Lerp(FlatlinePlayer.HealthRegenPerMinute, healthRegenPerMinuteTarget, healthRegenT);
				}
				if (Random.Range(0f, 1f) > 0.9f)
				{
					Player.Local.Health.CurrentHealth = Mathf.Clamp(Player.Local.Health.CurrentHealth + 1f, 0f, Flatline.loadedPlayerData.State.healthData.MaxHP);
					if (Flatline.loadedPlayerData.State.Energy < 1f)
					{
						Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy + energyRegenPerMinute * 8f);
					}
				}
			}
			if (Flatline.loadedPlayerData.State.Hunger < 1f && Flatline.loadedPlayerData.State.Hunger > 0.1f && FlatlinePlayer.FoodConsumptionPerMinute > FlatlinePlayer.DefaultFoodConsumption / 2f)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption / 2f, FlatlinePlayer.SystematicHomeostasisSpeed * 1.55f);
			}
			if (Flatline.loadedPlayerData.State.Thirst < 1f && Flatline.loadedPlayerData.State.Thirst > 0.1f && FlatlinePlayer.ThirstConsumptionPerMinute > FlatlinePlayer.DefaultThirstConsumption / 2f)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption / 2f, FlatlinePlayer.SystematicHomeostasisSpeed * 1.55f);
			}
		}

		public static void AfterBedrotEnd()
		{
			if (FlatlinePlayer.HealthRegenPerMinute > FlatlinePlayer.DefaultHealthRegeneration)
			{
				FlatlinePlayer.HealthRegenPerMinute = Mathf.Lerp(FlatlinePlayer.HealthRegenPerMinute, FlatlinePlayer.DefaultHealthRegeneration, 0.5f);
			}
			if (FlatlinePlayer.FoodConsumptionPerMinute < FlatlinePlayer.DefaultFoodConsumption)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.ThirstConsumptionPerMinute < FlatlinePlayer.DefaultThirstConsumption)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption, 0.5f);
			}
		}
	}
	[HarmonyPatch(typeof(Bed), "Awake")]
	public static class Bed_Awake_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(Bed __instance)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			Transform val = ((Component)__instance).transform.Find("BedRotIntObj");
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			InteractableObject bedRotInt = ((Component)val).gameObject.GetComponent<InteractableObject>();
			bedRotInt.onInteractStart.AddListener(new UnityAction(OnBedRotInteraction));
			bedRotInt.onHovered.AddListener(new UnityAction(OnBedRotHovered));
			return true;
			void OnBedRotHovered()
			{
				if (Flatline.registered)
				{
					BedRotSimulator.BedRotInteractableHovered(bedRotInt, __instance);
				}
			}
			void OnBedRotInteraction()
			{
				if (Flatline.registered)
				{
					BedRotSimulator.BedRotInteracted(bedRotInt, __instance);
				}
			}
		}
	}
	public static class DepressionSimulator
	{
		[CompilerGenerated]
		private sealed class <DepressionBlandWorld>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private float <duration>5__2;

			private float <current>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DepressionBlandWorld>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Lerp(0.95f, 0.75f, depression.data.Severity / 0.3f);
						if (!(Random.Range(0f, 1f) < num))
						{
							<duration>5__2 = Mathf.Lerp(Depression.minBlandEffectDuration, Depression.maxBlandEffectDuration, depression.data.Severity / 0.3f);
							<current>5__3 = 0f;
							Singleton<PostProcessingManager>.Instance.SaturationController.AddOverride(-56f, 25, "Depression");
							goto IL_010b;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__3 += 1f;
						if (<current>5__3 >= <duration>5__2 || !depression.data.Active || depression.isTemporaryCurePresent)
						{
							Singleton<PostProcessingManager>.Instance.SaturationController.RemoveOverride("Depression");
							goto IL_0022;
						}
						goto IL_010b;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_010b:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DepressionDoorDisabler>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private PropertyDoorController[] <doors>5__2;

			private float <duration>5__3;

			private float <current>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DepressionDoorDisabler>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<doors>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Invalid comparison between Unknown and I4
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && (int)Player.Local.CrimeData.CurrentPursuitLevel == 0 && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Clamp01(((float)depression.data.Progression / 5f + depression.data.Severity / 0.3f) / 2f);
						float num2 = Mathf.Lerp(0.95f, 0.75f, num);
						if (!(Random.Range(0f, 1f) < num2) && (Object)(object)Player.Local.CurrentProperty != (Object)null && Player.Local.CurrentProperty.IsOwned)
						{
							if (PropertyTemperatureController.propertyDoors.TryGetValue(Player.Local.CurrentProperty.propertyCode, out <doors>5__2))
							{
								PropertyDoorController[] array = <doors>5__2;
								foreach (PropertyDoorController val2 in array)
								{
									if (!((DoorController)val2).IsOpen)
									{
										((DoorController)val2).PlayerAccess = (EDoorAccess)1;
										((DoorController)val2).noAccessErrorMessage = "You are too depressed right now";
									}
								}
								<duration>5__3 = Mathf.Lerp(Depression.minDisablerEffectDuration, Depression.maxDisablerEffectDuration, num);
								<current>5__4 = 0f;
								goto IL_019a;
							}
							goto IL_024d;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__4 += 1f;
						if (!(<current>5__4 >= <duration>5__3) && depression.data.Active && !depression.isTemporaryCurePresent)
						{
							goto IL_019a;
						}
						PropertyDoorController[] array = <doors>5__2;
						foreach (PropertyDoorController val in array)
						{
							if ((int)((DoorController)val).PlayerAccess == 1 && ((DoorController)val).noAccessErrorMessage == "You are too depressed right now")
							{
								((DoorController)val).PlayerAccess = (EDoorAccess)0;
								((DoorController)val).noAccessErrorMessage = "";
							}
						}
						goto IL_024d;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_024d:
					<doors>5__2 = null;
					goto IL_0022;
					IL_019a:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DepressionMessagerDisabler>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private float <duration>5__2;

			private float <current>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DepressionMessagerDisabler>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Lerp(0.95f, 0.75f, depression.data.Severity / 0.3f);
						if (!(Random.Range(0f, 1f) < num))
						{
							<duration>5__2 = Mathf.Lerp(Depression.minDisablerEffectDuration, Depression.maxDisablerEffectDuration, depression.data.Severity / 0.3f);
							<current>5__3 = 0f;
							disabledOverlay.SetActive(true);
							goto IL_00fb;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__3 += 1f;
						if (<current>5__3 >= <duration>5__2 || !depression.data.Active || depression.isTemporaryCurePresent)
						{
							disabledOverlay.SetActive(false);
							goto IL_0022;
						}
						goto IL_00fb;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_00fb:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static GameObject disabledOverlay;

		public static void InitiateDepressionSimulatorModule()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_003e: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00af: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			disabledOverlay = new GameObject("DisableOverlay");
			disabledOverlay.transform.SetParent(((Component)PlayerSingleton<MessagesApp>.Instance).transform, false);
			RectTransform obj = disabledOverlay.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(800f, 1200f);
			((Transform)obj).localScale = Vector3.one;
			((Transform)obj).localPosition = Vector3.zero;
			((Transform)obj).localRotation = Quaternion.identity;
			((Graphic)disabledOverlay.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f, 0.93f);
			GameObject val = new GameObject("Text");
			val.transform.SetParent(disabledOverlay.transform);
			val.transform.localScale = Vector3.one;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.AddComponent<RectTransform>().sizeDelta = new Vector2(600f, 1200f);
			TextMeshProUGUI obj2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = "You are too depressed right now";
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj2).fontSize = 52f;
			disabledOverlay.SetActive(false);
			DebugModule.Log("Initiated depression simulator", "InitiateDepressionSimulatorModule");
		}

		public static void ResetDepressionSimulatorModule()
		{
			disabledOverlay = null;
		}

		public static bool ShouldSkip()
		{
			if (Player.PlayerList.Count > 1 && !Player.Local.Health.IsAlive)
			{
				return true;
			}
			if (NetworkSingleton<TimeManager>.Instance.CurrentTime < 659 && NetworkSingleton<TimeManager>.Instance.CurrentTime > 400)
			{
				return true;
			}
			if (Flatline.isSaving)
			{
				return true;
			}
			if (Flatline.haltExecution)
			{
				return true;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<DepressionBlandWorld>d__4))]
		public static IEnumerator DepressionBlandWorld(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionBlandWorld>d__4(0)
			{
				depression = depression
			};
		}

		[IteratorStateMachine(typeof(<DepressionMessagerDisabler>d__5))]
		public static IEnumerator DepressionMessagerDisabler(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionMessagerDisabler>d__5(0)
			{
				depression = depression
			};
		}

		[IteratorStateMachine(typeof(<DepressionDoorDisabler>d__6))]
		public static IEnumerator DepressionDoorDisabler(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionDoorDisabler>d__6(0)
			{
				depression = depression
			};
		}
	}
	public static class AudioLoader
	{
		public static AudioClip ToAudioClip(byte[] fileBytes, string name = "wav")
		{
			int num = 0;
			int num2 = 16000;
			ushort num3 = 1;
			int dataSize = fileBytes.Length;
			bool flag = true;
			byte[] array = new byte[4];
			Array.Copy(fileBytes, 0, array, 0, 4);
			if (!Encoding.ASCII.GetString(array).Equals("RIFF"))
			{
				flag = false;
			}
			if (flag)
			{
				int num4 = BitConverter.ToInt32(fileBytes, 16);
				BitConverter.ToUInt16(fileBytes, 20);
				num3 = BitConverter.ToUInt16(fileBytes, 22);
				num2 = BitConverter.ToInt32(fileBytes, 24);
				BitConverter.ToUInt16(fileBytes, 34);
				num = 20 + num4 + 4;
				dataSize = BitConverter.ToInt32(fileBytes, num);
			}
			float[] array2 = Convert16BitByteArrayToAudioClipData(fileBytes, num, dataSize);
			AudioClip obj = AudioClip.Create(name, array2.Length / num3, (int)num3, num2, false);
			obj.SetData(array2, 0);
			return obj;
		}

		private static float[] Convert16BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
		{
			int num = dataSize;
			if (headerOffset != 0)
			{
				num = BitConverter.ToInt32(source, headerOffset);
				headerOffset += 4;
			}
			int num2 = 2;
			int num3 = num / num2;
			float[] array = new float[num3];
			short num4 = short.MaxValue;
			int num5 = 0;
			for (int i = 0; i < num3; i++)
			{
				num5 = i * num2 + headerOffset;
				array[i] = (float)BitConverter.ToInt16(source, num5) / (float)num4;
			}
			return array;
		}
	}
	[Serializable]
	public class FlatlinePlayerData
	{
		public FlatlinePlayerState State = new FlatlinePlayerState();

		public List<DiseaseData> DiseaseData = new List<DiseaseData>();

		public FlatlinePlayerData()
		{
		}

		public FlatlinePlayerData(FlatlinePlayerData original)
		{
			State = new FlatlinePlayerState(original.State);
			DiseaseData = new List<DiseaseData>();
			foreach (DiseaseData diseaseDatum in original.DiseaseData)
			{
				DiseaseData.Add(new DiseaseData(diseaseDatum));
			}
		}
	}
	[Serializable]
	public class FlatlinePlayerState
	{
		public Dictionary<string, ConsumptionData> consumptionDatas = new Dictionary<string, ConsumptionData>();

		public HealthData healthData = new HealthData();

		public float Thirst = 1f;

		public float Hunger = 1f;

		public float Energy = 1f;

		public float Temperature = 1f;

		public FlatlinePlayerState()
		{
		}

		public FlatlinePlayerState(FlatlinePlayerState original)
		{
			Thirst = original.Thirst;
			Hunger = original.Hunger;
			Energy = original.Energy;
			Temperature = original.Temperature;
			foreach (KeyValuePair<string, ConsumptionData> consumptionData in original.consumptionDatas)
			{
				consumptionDatas.Add(consumptionData.Key, new ConsumptionData(consumptionData.Value));
			}
			healthData = new HealthData(original.healthData);
		}
	}
	[Serializable]
	public class ConsumptionData
	{
		public float overtimeLungDamage;

		public float overtimeLiverDamage;

		public float currentAmountInSystem;

		public ConsumptionData()
		{
		}

		public ConsumptionData(ConsumptionData original)
		{
			overtimeLungDamage = original.overtimeLungDamage;
			overtimeLiverDamage = original.overtimeLiverDamage;
			currentAmountInSystem = original.currentAmountInSystem;
		}
	}
	[Serializable]
	public class HealthData
	{
		public float MaxHP = 100f;

		public float CurrentHP = 100f;

		public float MoveSpeedScale = 1f;

		public float Predisposition;

		public float Gluttony;

		public int TimesSmoked;

		public bool IsLegBoneBroken;

		public int daysSinceFlu;

		public HealthData()
		{
		}

		public HealthData(HealthData original)
		{
			MaxHP = original.MaxHP;
			CurrentHP = original.CurrentHP;
			MoveSpeedScale = original.MoveSpeedScale;
			Predisposition = original.Predisposition;
			Gluttony = original.Gluttony;
			TimesSmoked = original.TimesSmoked;
			IsLegBoneBroken = original.IsLegBoneBroken;
			daysSinceFlu = original.daysSinceFlu;
		}
	}
	[Serializable]
	public class DiseaseData
	{
		public string DiseaseID = "";

		public bool Active;

		public int MinsSinceDiseaseStart;

		public int Progression = 1;

		public float Severity;

		public float HealState;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, float> DiseaseStates;

		public DiseaseData()
		{
		}

		public DiseaseData(DiseaseData original)
		{
			DiseaseID = original.DiseaseID;
			Active = original.Active;
			MinsSinceDiseaseStart = original.MinsSinceDiseaseStart;
			Progression = original.Progression;
			Severity = original.Severity;
			HealState = original.HealState;
			if (original.DiseaseStates != null)
			{
				DiseaseStates = new Dictionary<string, float>(original.DiseaseStates);
			}
		}
	}
	public class FlatlineModConfig
	{
		public bool PermanentDeath = true;

		public bool DrugSideEffects = true;

		public bool PropertyTemperatureChanges = true;

		public bool WorldTemperatureChanges = true;

		public bool FahrenheitTemp;

		public bool DiseasesEnabled = true;

		public bool BleedingEnabled = true;

		public bool BoneBreakEnabled = true;

		public bool CancerEnabled = true;

		public bool DepressionEnabled = true;

		public bool FeverEnabled = true;

		public bool WaterRequired = true;

		public bool FoodRequired = true;

		public bool EnergyRequired = true;

		public bool TemperatureRequired = true;

		public float WaterConsumption = 0.00087958f;

		public float FoodConsumption = 0.0015f;

		public float EnergyConsumption = 0.0007f;

		public float TemperatureConsumption = 0.00022f;
	}
	public static class ConfigLoader
	{
		private static readonly string BASE_USERDATA_NAME = "XO_WithSauce-Flatline";

		private static readonly string TS_PACKAGE_NAME = "XO_WithSauce-Flatline_";

		private static readonly string packagePathUserData = Path.Combine(MelonEnvironment.UserDataDirectory, TS_PACKAGE_NAME + "MONO", BASE_USERDATA_NAME);

		private static readonly string manualPathUserData = Path.Combine(MelonEnvironment.UserDataDirectory, BASE_USERDATA_NAME);

		private static readonly string pathPlayerData = Path.Combine(packagePathUserData, "PlayerData");

		private static readonly string pathModImageResources = Path.Combine(packagePathUserData, "ModResources", "Images");

		private static readonly string pathModAudioResources = Path.Combine(packagePathUserData, "ModResources", "Audio");

		private static readonly string pathManualPlayerData = Path.Combine(manualPathUserData, "PlayerData");

		private static readonly string pathManualModImageResources = Path.Combine(manualPathUserData, "ModResources", "Images");

		private static readonly string pathManualModAudioResources = Path.Combine(manualPathUserData, "ModResources", "Audio");

		public static readonly List<string> imageResources = new List<string> { "bleed", "bonebreak", "cancer", "depression", "energy", "fever", "meat", "temperature", "water" };

		public static readonly List<string> audioResources = new List<string> { "malecough", "malesneeze", "femalecough", "femalesneeze", "bonebreak", "flatline", "singleheartbeat" };

		public static object playerDataLock = new object();

		public static Dictionary<string, Sprite> loadedSprites = new Dictionary<string, Sprite>();

		public static Dictionary<string, AudioClip> loadedAudios = new Dictionary<string, AudioClip>();

		public static FlatlinePlayerData LoadPlayerData()
		{
			string organisationName = Singleton<LoadManager>.Instance.ActiveSaveInfo.OrganisationName;
			int saveSlotNumber = Singleton<LoadManager>.Instance.ActiveSaveInfo.SaveSlotNumber;
			string path = $"{saveSlotNumber}_{SanitizeAndFormatName(organisationName)}";
			string text = "";
			if (Directory.Exists(pathPlayerData))
			{
				text = pathPlayerData;
			}
			else
			{
				if (!Directory.Exists(pathManualPlayerData))
				{
					MelonLogger.Error("Failed to locate Flatline PlayerData from the UserData folder!");
					return null;
				}
				text = pathManualPlayerData;
			}
			FlatlinePlayerData flatlinePlayerData;
			if (File.Exists(Path.Combine(text, path)))
			{
				try
				{
					flatlinePlayerData = JsonConvert.DeserializeObject<FlatlinePlayerData>(File.ReadAllText(Path.Combine(text, path)));
				}
				catch (Exception ex)
				{
					flatlinePlayerData = new FlatlinePlayerData();
					MelonLogger.Warning("Failed to read flatline player data: " + ex);
				}
			}
			else
			{
				flatlinePlayerData = new FlatlinePlayerData();
				flatlinePlayerData.State.healthData.Predisposition = Random.Range(0.0005f, 0.02f);
				Save(flatlinePlayerData);
			}
			return flatlinePlayerData;
		}

		public static void Save(FlatlinePlayerData playerData)
		{
			lock (playerDataLock)
			{
				FlatlinePlayerData flatlinePlayerData = new FlatlinePlayerData(playerData);
				try
				{
					string organisationName = Singleton<LoadManager>.Instance.ActiveSaveInfo.OrganisationName;
					int saveSlotNumber = Singleton<LoadManager>.Instance.ActiveSaveInfo.SaveSlotNumber;
					string path = $"{saveSlotNumber}_{SanitizeAndFormatName(organisationName)}";
					string text = "";
					text = (Directory.Exists(pathPlayerData) ? pathPlayerData : ((!Directory.Exists(pathManualPlayerData)) ? pathPlayerData : pathManualPlayerData));
					string path2 = Path.Combine(text, path);
					string contents = JsonConvert.SerializeObject((object)flatlinePlayerData, (Formatting)1);
					Directory.CreateDirectory(Path.GetDirectoryName(path2));
					File.WriteAllText(path2, contents);
				}
				catch (Exception ex)
				{
					MelonLogger.Warning("Failed to save Flatline player data: " + ex);
				}
			}
		}

		public static void RemoveSaveAssociatedData(string orgName, int slotNum)
		{
			string path = $"{slotNum}_{SanitizeAndFormatName(orgName)}";
			string text = "";
			if (Directory.Exists(pathPlayerData))
			{
				text = pathPlayerData;
			}
			else
			{
				if (!Directory.Exists(pathManualPlayerData))
				{
					MelonLogger.Error("Failed to locate Flatline PlayerData from the UserData folder!");
					return;
				}
				text = pathManualPlayerData;
			}
			if (File.Exists(Path.Combine(text, path)))
			{
				try
				{
					File.Delete(Path.Combine(text, path));
				}
				catch (Exception ex)
				{
					MelonLogger.Warning("Failed to remove save associated flatline player data: " + ex);
				}
			}
		}

		public static void LoadModResources()
		{
			//IL_0097: 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_00a4: Expected O, but got Unknown
			//IL_00a5: 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_00b3: 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)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			string text = "";
			string text2 = "";
			if (Directory.Exists(packagePathUserData))
			{
				text = pathModImageResources;
				text2 = pathModAudioResources;
			}
			else
			{
				if (!Directory.Exists(manualPathUserData))
				{
					MelonLogger.Error("Failed to locate Flatline mod resources from UserData!");
					return;
				}
				text = pathManualModImageResources;
				text2 = pathManualModAudioResources;
			}
			if (Directory.Exists(text))
			{
				foreach (string imageResource in imageResources)
				{
					string path = Path.Combine(text, imageResource + ".png");
					if (File.Exists(path))
					{
						byte[] array = File.ReadAllBytes(path);
						Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
						ImageConversion.LoadImage(val, array);
						((Object)val).name = imageResource;
						((Texture)val).anisoLevel = 1;
						val.Apply();
						Sprite value = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
						loadedSprites.Add(imageResource, value);
					}
					else
					{
						MelonLogger.Error("Flatline mod expected to find file '" + imageResource + "' but it's missing!");
					}
				}
			}
			else
			{
				MelonLogger.Error("Flatline mod expected to find directory '" + text + "' but it's missing!");
			}
			if (Directory.Exists(text2))
			{
				foreach (string audioResource in audioResources)
				{
					string path2 = Path.Combine(text2, audioResource + ".wav");
					if (File.Exists(path2))
					{
						AudioClip value2 = AudioLoader.ToAudioClip(File.ReadAllBytes(path2));
						loadedAudios.Add(audioResource, value2);
					}
					else
					{
						MelonLogger.Error("Flatline mod expected to find file '" + audioResource + "' but it's missing!");
					}
				}
				return;
			}
			MelonLogger.Error("Flatline mod expected to find directory '" + text2 + "' but it's missing!");
		}

		public static string SanitizeAndFormatName(string orgName)
		{
			string text = orgName;
			if (text != null)
			{
				text = text.Replace(" ", "_").ToLower();
				text = text.Replace(",", "");
				text = text.Replace(".", "");
				text = text.Replace("<", "");
				text = text.Replace(">", "");
				text = text.Replace(":", "");
				text = text.Replace("\"", "");
				text = text.Replace("/", "");
				text = text.Replace("\\", "");
				text = text.Replace("|", "");
				text = text.Replace("?", "");
				text = text.Replace("*", "");
			}
			return text + ".json";
		}
	}
	public class Bleeding : Disease
	{
		[CompilerGenerated]
		private sealed class <RunBleedDamage>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Bleeding <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RunBleedDamage>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Bleeding bleeding = <>4__this;
				float num2;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0029;
				case 1:
					<>1__state = -1;
					num2 = 0.5f;
					goto IL_0081;
				case 2:
					{
						<>1__state = -1;
						num2 = 1f;
						goto IL_0081;
					}
					IL_0081:
					if (!Flatline.registered || !bleeding.data.Active || bleeding.data.Progression >= 5)
					{
						return false;
					}
					if (!Flatline.haltExecution && !Flatline.isSaving && !FlatlinePlayer.isPassedOut && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress)
					{
						if (FlatlinePlayer.isQueuedForDeath)
						{
							return false;
						}
						if (bleeding.maxHPReduced >= bleeding.MaximumMaxHPReduction)
						{
							return false;
						}
						if (!(bleeding.data.HealState > 0.9f) && !PlayerDiseaseDamage.isBleedingStemmed)
						{
							float num3 = (float)bleeding.minsRequiredForProgression * (1f + bleeding.data.Severity);
							float num4 = num3 * 5f / 1440f;
							float num5 = num3 * 1f / 1440f;
							float num6 = num4 - num5;
							float num7 = bleeding.MaximumMaxHPReduction / 1440f * num6 / num2;
							float num8 = Mathf.Lerp(Mathf.Approximately(bleeding.data.HealState, 0f) ? 0.015f : bleeding.data.HealState, 0.001f, (float)bleeding.data.Progression / 5f - 0.2f);
							num7 = Mathf.Clamp01(Mathf.Lerp(num7, 0f, num8)) * (float)bleeding.data.Progression;
							DebugModule.Log("Calc bleed reduction: " + num7, "RunBleedDamage");
							if (Random.Range(0f, 1f) > 0.33f)
							{
								Player.Local.Health.PlayBloodMist();
							}
							if (Flatline.loadedPlayerData.State.healthData.MaxHP - num7 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
							{
								float num9 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num7);
								if (Player.Local.Health.CurrentHealth - num9 <= 0f)
								{
									FlatlineUIModule.causeOfDeath = "Bleeding";
								}
								Player.Local.Health.TakeDamage(num9, Random.Range(0, 10) == 0, false);
								FlatlinePlayer.AppendDamageSource($"Bleeding damage (-{num9}HP)");
							}
							else
							{
								DebugModule.Log("Bleed amount not smaller than current hp", "RunBleedDamage");
							}
							bleeding.maxHPReduced += num7;
							Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num7, 0f, 100f);
						}
					}
					goto IL_0029;
					IL_0029:
					num2 = 0f;
					if (bleeding.data.Progression >= 3)
					{
						<>2__current = Flatline.Wait05;
						<>1__state = 1;
						return true;
					}
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly float passiveDiseaseHealingMax = 0.0055f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public float MaximumMaxHPReduction = 100f;

		private float maxHPReduced;

		public Bleeding(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "bleed";
			base.minsRequiredForProgression = 240;
			onDiseaseStarted = BleedingStarted;
			MaximumMaxHPReduction = Mathf.Lerp(40f, 150f, base.data.Severity / 0.3f);
			if (base.data.DiseaseStates == null)
			{
				base.data.DiseaseStates = new Dictionary<string, float>();
			}
			if (base.data.DiseaseStates.ContainsKey("maxHPReduced"))
			{
				maxHPReduced = base.data.DiseaseStates["maxHPReduced"];
			}
			else
			{
				base.data.DiseaseStates.Add("maxHPReduced", 0f);
			}
		}

		private void BleedingStarted()
		{
			PlayerDiseaseDamage.isBleedingStemmed = false;
			if (!PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(true);
			}
			Flatline.coros.Add(MelonCoroutines.Start(RunBleedDamage()));
		}

		[IteratorStateMachine(typeof(<RunBleedDamage>d__6))]
		private IEnumerator RunBleedDamage()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RunBleedDamage>d__6(0)
			{
				<>4__this = this
			};
		}

		public override void DiseaseEffect()
		{
			float num = data.MinsSinceDiseaseStart;
			if (!PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(true);
			}
			if (PlayerDiseaseDamage.isBleedingStemmed)
			{
				num *= 0.33f;
			}
			if (Mathf.Round(num * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5 && maxHPReduced >= MaximumMaxHPReduction && !PlayerDiseaseDamage.isBleedingStemmed)
			{
				DebugModule.Log("Player died of bleeding", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Bleeding";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (data.Progression >= 4 && Flatline.loadedPlayerData.State.Thirst > 0.15f)
			{
				Flatline.loadedPlayerData.State.Thirst -= 0.0015f;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (maxHPReduced >= MaximumMaxHPReduction)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin * 3f, passiveDiseaseHealingMax * 3f);
			}
			float num2 = Mathf.Lerp(12f, 50f, Mathf.Clamp01(data.HealState));
			float num3 = Mathf.Lerp(1f, 3f, Mathf.Clamp01((float)data.Progression / 5f));
			if (PlayerDiseaseDamage.isBleedingStemmed)
			{
				data.HealState += passiveDiseaseHealingMax * num2;
				DebugModule.Log($"Stem heal: {data.HealState} +{passiveDiseaseHealingMax * num2}", "DiseaseEffect");
			}
			else
			{
				data.HealState = Mathf.Clamp01(data.HealState - passiveDiseaseHealingMax * num3);
				DebugModule.Log($"No stem: {data.HealState} -{passiveDiseaseHealingMax * num3}", "DiseaseEffect");
			}
			DebugModule.Log("Bleeding Max HP reduction total so far: " + maxHPReduced, "DiseaseEffect");
		}

		public override void DiseaseHealed()
		{
			if (PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(false);
			}
			PlayerDiseaseDamage.isBleedingStemmed = false;
			DebugModule.Log("Healed bleeding succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
			if (data.DiseaseStates == null)
			{
				data.DiseaseStates = new Dictionary<string, float>();
			}
			if (data.DiseaseStates.ContainsKey("maxHPReduced"))
			{
				data.DiseaseStates["maxHPReduced"] = maxHPReduced;
			}
			else
			{
				data.DiseaseStates.Add("maxHPReduced", maxHPReduced);
			}
		}
	}
	public class BoneBreak : Disease
	{
		public static readonly float passiveDiseaseHealingMax = 0.001f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public static readonly float healingReductionWhileSprinting = 0.008f;

		public static readonly float baseMoveSpeedReduction = 0.03f;

		public static readonly float minMoveSpeedScaleValue = 0.65f;

		private bool hasDisabledJump;

		public BoneBreak(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "bonebreak";
			base.minsRequiredForProgression = 4320;
		}

		public override void DiseaseEffect()
		{
			if (Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of a broken bone", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Broken bone";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
			{
				data.HealState = Mathf.Clamp01(data.HealState - healingReductionWhileSprinting * (float)data.Progression);
			}
			if (BedRotSimulator.isBedrotting)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			}
			if (data.Progression >= 1)
			{
				float num = Mathf.Lerp(minMoveSpeedScaleValue, 1f, data.HealState);
				if (Flatline.loadedPlayerData.State.healthData.MoveSpeedScale > num)
				{
					float num2 = Mathf.Lerp(baseMoveSpeedReduction * (float)data.Progression * (1f + data.Severity), 0f, data.HealState);
					float moveSpeedScale = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MoveSpeedScale - num2, minMoveSpeedScaleValue, 1f);
					Flatline.loadedPlayerData.State.healthData.MoveSpeedScale = moveSpeedScale;
				}
			}
			if (data.Progression < 3 || !(data.HealState < 0.5f) || !Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken)
			{
				return;
			}
			if (PlayerSingleton<PlayerMovement>.Instance.CanJump && !hasDisabledJump)
			{
				if (Random.Range(0f, 1f) > 0.95f)
				{
					PlayerSingleton<PlayerMovement>.Instance.CanJump = false;
					hasDisabledJump = true;
				}
			}
			else if (!PlayerSingleton<PlayerMovement>.Instance.CanJump && hasDisabledJump)
			{
				PlayerSingleton<PlayerMovement>.Instance.CanJump = true;
				hasDisabledJump = false;
			}
		}

		public override void DiseaseHealed()
		{
			Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = false;
			DebugModule.Log("Healed bone break succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Cancer : Disease
	{
		public static readonly float MaximumMaxHPReduction = 100f;

		public Cancer(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "cancer";
			base.minsRequiredForProgression = 10080;
		}

		public override void DiseaseEffect()
		{
			float num = Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity));
			float num2 = (float)base.minsRequiredForProgression * (1f + data.Severity);
			if (num / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of cancer", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Cancer";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (data.Progression >= 3)
			{
				float num3 = num2 * 5f / 1440f;
				float num4 = num2 * 3f / 1440f;
				float num5 = num3 - num4;
				float num6 = MaximumMaxHPReduction / 1440f * num5 / 10f;
				DebugModule.Log("Cancer Max HP reduction: " + num6, "DiseaseEffect");
				if (Flatline.loadedPlayerData.State.healthData.MaxHP - num6 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
				{
					float num7 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num6);
					if (Player.Local.Health.CurrentHealth - num7 <= 0f)
					{
						FlatlineUIModule.causeOfDeath = "Cancer";
					}
					Player.Local.Health.TakeDamage(num7, true, false);
					FlatlinePlayer.AppendDamageSource($"Cancer damage (-{num7}HP)");
				}
				Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num6, 0f, 100f);
			}
			if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
			{
				AudioClip val = null;
				val = ((Player.Local.Avatar.CurrentSettings.Gender > 0.5f) ? ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["femalesneeze"] : ConfigLoader.loadedAudios["femalecough"]) : ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["malesneeze"] : ConfigLoader.loadedAudios["malecough"]));
				if (data.Progression == 2 && Random.Range(0f, 1f) > 0.99f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression >= 3 && Random.Range(0f, 1f) > 0.95f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
			}
		}

		public override void DiseaseHealed()
		{
			DebugModule.Log("Healed cancer succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Depression : Disease
	{
		public static readonly float passiveDiseaseHealingMax = 0.0025f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public static readonly float baseEnergyConsumptionIncrease = 0.002f;

		public static readonly float baseFoodConsumptionIncrease = 0.0008f;

		public static readonly int maxTemporaryCureMins = 120;

		public static readonly float maxBlandEffectDuration = 180f;

		public static readonly float minBlandEffectDuration = 80f;

		public static readonly float maxDisablerEffectDuration = 120f;

		public static readonly float minDisablerEffectDuration = 50f;

		private static int minsSpentBedrotting = 0;

		public bool isTemporaryCurePresent;

		private int minsSinceTemporaryCureStarted;

		public static readonly List<string> temporaryDepressionCures = new List<string> { "weed", "shroom", "cocaine", "meth" };

		public Depression(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "depression";
			base.minsRequiredForProgression = 4320;
			onDiseaseStarted = RunDepressionCoros;
		}

		private void RunDepressionCoros()
		{
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionBlandWorld(this)));
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionDoorDisabler(this)));
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionMessagerDisabler(this)));
		}

		public override void DiseaseEffect()
		{
			if (Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of depression", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Depression";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (BedRotSimulator.isBedrotting)
			{
				minsSpentBedrotting += 10;
				float num = Mathf.Lerp(0f, 1f, Mathf.Clamp01((float)minsSpentBedrotting / 1440f));
				if (num > data.HealState)
				{
					data.HealState = num;
				}
				else
				{
					data.HealState += num / 10f;
				}
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (isTemporaryCurePresent)
			{
				minsSinceTemporaryCureStarted += 10;
				if (minsSinceTemporaryCureStarted >= maxTemporaryCureMins)
				{
					isTemporaryCurePresent = false;
				}
			}
			if (Flatline.loadedPlayerData.State.healthData.TimesSmoked > 0 && Flatline.loadedPlayerData.State.consumptionDatas.Count > 0)
			{
				Dictionary<string, ConsumptionData> dictionary = new Dictionary<string, ConsumptionData>(Flatline.loadedPlayerData.State.consumptionDatas);
				float num2 = 0f;
				int num3 = 0;
				foreach (KeyValuePair<string, ConsumptionData> item in dictionary)
				{
					if (temporaryDepressionCures.Contains(item.Key))
					{
						num2 += item.Value.currentAmountInSystem;
						if (num2 > 0.15f && !isTemporaryCurePresent)
						{
							isTemporaryCurePresent = true;
							minsSinceTemporaryCureStarted = 0;
						}
						num3++;
					}
				}
				if (num3 > 0)
				{
					num2 = Mathf.Clamp01(num2 / (float)num3);
					float num4 = passiveDiseaseHealingMax * (1f + num2);
					float num5 = Random.Range(passiveDiseaseHealingMin * (1f + num2), num4);
					num5 = Mathf.Lerp(num5, num4, num2);
					data.HealState += Mathf.Clamp(num5, 0f, 0.01f);
				}
			}
			if (!BedRotSimulator.isBedrotting)
			{
				float num6 = Mathf.Lerp(3f, 5f, (float)data.Progression / 5f - 0.2f);
				float num7 = Mathf.Clamp(baseEnergyConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.01f);
				float num8 = Mathf.Clamp(baseFoodConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0052f);
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.EnergyConsumptionPerMinute + num7, MaximumSystematicPropertyChangePerTick * num6);
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.FoodConsumptionPerMinute + num8, MaximumSystematicPropertyChangePerTick * num6);
			}
		}

		public override void DiseaseHealed()
		{
			if (FlatlinePlayer.FoodConsumptionPerMinute > FlatlinePlayer.DefaultFoodConsumption)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.EnergyConsumptionPerMinute > FlatlinePlayer.DefaultEnergyConsumption)
			{
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.DefaultEnergyConsumption, 0.5f);
			}
			DebugModule.Log("Healed depression succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Fever : Disease
	{
		[CompilerGenerated]
		private sealed class <BlurShort>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Fever <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <BlurShort>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Fever fever = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!Flatline.registered || FlatlinePlayer.isPassedOut || FlatlinePlayer.isQueuedForDeath)
					{
						return false;
					}
					DebugModule.Log("Start blur", "BlurShort");
					Mathf.Lerp(2f, 5f, (float)fever.data.Progression / 5f);
					PlayerSingleton<PlayerCamera>.Instance.FoVChangeSmoother.AddOverride(-8f, 5, "fever");
					PlayerSingleton<PlayerCamera>.Instance.SmoothLookSmoother.AddOverride(0.8f, 5, "fever");
					if (fever.data.Progression > 3)
					{
						Player.Local.Disoriented = true;
					}
					Player.Local.Seizure = true;
					Singleton<PostProcessingManager>.Instance.SetBlur(1f);
					<>2__current = Flatline.Wait5;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					Player.Local.Seizure = false;
					if (fever.data.Progression > 3 && Player.Local.Disoriented)
					{
						Player.Local.Disoriented = false;
					}
					Singleton<PostProcessingManager>.Instance.SetBlur(0f);
					PlayerSingleton<PlayerCamera>.Instance.FoVChangeSmoother.RemoveOverride("fever");
					PlayerSingleton<PlayerCamera>.Instance.SmoothLookSmoother.RemoveOverride("fever");
					DebugModule.Log("End blur", "BlurShort");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly float baseEnergyConsumptionIncrease = 7E-05f;

		public static readonly float baseTemperatureConsumptionIncrease = 0.00025f;

		public static readonly float baseThirstConsumptionIncrease = 0.00012f;

		public static readonly float passiveDiseaseHealingMax = 0.0055f;

		public static readonly float passiveDiseaseHealingMin = 0.0003f;

		public static readonly float MaximumMaxHPReduction = 33f;

		private int minsSinceLastFeverShiver;

		private int minsUntilNextFeverShiver = 120;

		public Fever(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "fever";
			base.minsRequiredForProgression = 1080;
			onDiseaseStarted = FeverStarted;
		}

		private void FeverStarted()
		{
			Player.Local.Avatar.Effects.SetSicklySkinColor(true);
			Player.Local.Avatar.EmotionManager.AddEmotionOverride("Concerned", "Sickly", 0f, 5);
		}

		public override void DiseaseEffect()
		{
			minsSinceLastFeverShiver += 10;
			DebugModule.Log("Mins until next fever jitter " + (minsUntilNextFeverShiver - minsSinceLastFeverShiver), "DiseaseEffect");
			float num = Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity));
			float num2 = (float)base.minsRequiredForProgression * (1f + data.Severity);
			if (num / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of fever", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Fever";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (BedRotSimulator.isBedrotting)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin * 5f, passiveDiseaseHealingMax * 5f);
			}
			if (PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
			{
				data.HealState = Mathf.Clamp01(data.HealState - Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax * 2f));
			}
			if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
			{
				AudioClip val = null;
				val = ((Player.Local.Avatar.CurrentSettings.Gender > 0.5f) ? ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["femalesneeze"] : ConfigLoader.loadedAudios["femalecough"]) : ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["malesneeze"] : ConfigLoader.loadedAudios["malecough"]));
				if (data.Progression == 1 && Random.Range(0f, 1f) > 0.96f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression == 2 && Random.Range(0f, 1f) > 0.94f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression == 3 && Random.Range(0f, 1f) > 0.92f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression >= 4 && Random.Range(0f, 1f) > 0.87f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
			}
			if (data.Progression >= 1)
			{
				float num3 = Mathf.Clamp(FlatlinePlayer.EnergyConsumptionPerMinute + Mathf.Clamp(baseEnergyConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0009f), 0f, FlatlinePlayer.DefaultEnergyConsumption * 3f);
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, num3, MaximumSystematicPropertyChangePerTick * 2f);
				float num4 = Mathf.Clamp(FlatlinePlayer.TemperatureConsumption + Mathf.Clamp(baseTemperatureConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0015f), 0f, FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff * 3f);
				FlatlinePlayer.TemperatureConsumption = Mathf.Lerp(FlatlinePlayer.TemperatureConsumption, num4, MaximumSystematicPropertyChangePerTick * 3f);
				float num5 = Mathf.Clamp(FlatlinePlayer.ThirstConsumptionPerMinute + Mathf.Clamp(baseThirstConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0015f), 0f, FlatlinePlayer.DefaultThirstConsumption * 3f);
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, num5, MaximumSystematicPropertyChangePerTick * 3f);
			}
			if (data.Progression >= 2 && data.HealState < 0.8f && Flatline.loadedPlayerData.State.healthData.MaxHP > 100f - MaximumMaxHPReduction)
			{
				float num6 = num2 * 5f / 1440f;
				float num7 = num2 * 2f / 1440f;
				float num8 = num6 - num7;
				float num9 = MaximumMaxHPReduction / 1440f * num8 / 10f;
				num9 = Mathf.Clamp01(Mathf.Lerp(num9, 0f, data.HealState));
				DebugModule.Log("Fever Max HP reduction: " + num9, "DiseaseEffect");
				if (Flatline.loadedPlayerData.State.healthData.MaxHP - num9 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
				{
					float num10 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num9);
					if (Player.Local.Health.CurrentHealth - num10 <= 0f)
					{
						FlatlineUIModule.causeOfDeath = "Fever";
					}
					Player.Local.Health.TakeDamage(num10, false, false);
					FlatlinePlayer.AppendDamageSource($"Fever damage (-{num10}HP)");
				}
				Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num9, 10f, 100f);
			}
			if (minsSinceLastFeverShiver >= minsUntilNextFeverShiver)
			{
				Flatline.coros.Add(MelonCoroutines.Start(BlurShort()));
				minsSinceLastFeverShiver = 0;
				switch (data.Progression)
				{
				case 1:
					minsUntilNextFeverShiver = Random.Range(100, 200);
					break;
				case 2:
					minsUntilNextFeverShiver = Random.Range(80, 180);
					break;
				case 3:
					minsUntilNextFeverShiver = Random.Range(70, 120);
					break;
				case 4:
					minsUntilNextFeverShiver = Random.Range(50, 100);
					break;
				default:
					minsUntilNextFeverShiver = Random.Range(80, 360);
					break;
				}
			}
		}

		[IteratorStateMachine(typeof(<BlurShort>d__11))]
		public IEnumerator BlurShort()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BlurShort>d__11(0)
			{
				<>4__this = this
			};
		}

		public override void DiseaseHealed()
		{
			if (FlatlinePlayer.EnergyConsumptionPerMinute > FlatlinePlayer.DefaultEnergyConsumption)
			{
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.ThirstConsumptionPerMinute > FlatlinePlayer.DefaultThirstConsumption)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption, 0.5f);
			}
			if (FlatlinePlayer.TemperatureConsumption > FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff)
			{
				FlatlinePlayer.TemperatureConsumption = Mathf.Lerp(FlatlinePlayer.TemperatureConsumption, FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff, 0.5f);
			}
			Player.Local.Avatar.Effects.SetSicklySkinColor(false);
			Player.Local.Avatar.EmotionManager.RemoveEmotionOverride("Sickly");
			DebugModule.Log("Healed fever succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public abstract class Disease
	{
		[CompilerGenerated]
		private sealed class <DiseaseEvaluator>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Disease <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DiseaseEvaluator>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Disease disease = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!FlatlinePlayer.isQueuedForDeath || Flatline.currentConfig.PermanentDeath || Player.PlayerList.Count <= 1)
					{
						if (!Flatline.registered || FlatlinePlayer.isQueuedForDeath)
						{
							return false;
						}
						if (!Flatline.isSaving && !FlatlinePlayer.isPassedOut && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && !Flatline.haltExecution && (Player.PlayerList.Count <= 1 || Player.Local.Health.IsAlive) && (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 659 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 400))
						{
							if (disease.data.DiseaseID != "cancer" && Flatline.loadedPlayerData.State.Hunger > 0.9f)
							{
								disease.data.HealState += disease.ParasympatheticHealing;
							}
							if (disease.data.HealState >= 1f)
							{
								goto IL_01bd;
							}
							if (HospitalHealing.hospitalChoiceInitialized)
							{
								disease.UpdateChoiceState((NPC)(object)HospitalHealing.lisaNPC, HospitalHealing.lisaCureChoices);
								disease.UpdateChoiceState((NPC)(object)HospitalHealing.ireneNPC, HospitalHealing.ireneCureChoices);
							}
							disease.data.MinsSinceDiseaseStart += 10;
							disease.DiseaseEffect();
						}
					}
				}
				else
				{
					<>1__state = -1;
					FlatlineUIModule.diseaseIcons[disease.data.DiseaseID].SetActive(true);
					if (disease.onDiseaseStarted != null)
					{
						disease.onDiseaseStarted();
					}
				}
				if (disease.data.Active)
				{
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
				}
				goto IL_01bd;
				IL_01bd:
				disease.data.Active = false;
				FlatlineUIModule.diseaseIcons[disease.data.DiseaseID].SetActive(false);
				disease.DiseaseHealed();
				if (HospitalHealing.hospitalChoiceInitialized)
				{
					disease.UpdateChoiceState((NPC)(object)HospitalHealing.lisaNPC, HospitalHealing.lisaCureChoices);
					disease.UpdateChoiceState((NPC)(object)HospitalHealing.ireneNPC, HospitalHealing.ireneCureChoices);
				}
				disease.diseaseCoroutine = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public readonly float ParasympatheticHealing = 0.0002f;

		public readonly float MaximumSystematicPropertyChangePerTick = 1f / 144f;

		public DiseaseData data;

		public object diseaseCoroutine;

		public Action onDiseaseStarted;

		public int minsRequiredForProgression { get; set; }

		public abstract void DiseaseEffect();

		public abstract void DiseaseHealed();

		public abstract void UpdateDiseaseData();

		[IteratorStateMachine(typeof(<DiseaseEvaluator>d__12))]
		public IEnumerator DiseaseEvaluator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DiseaseEvaluator>d__12(0)
			{
				<>4__this = this
			};
		}

		private void UpdateChoiceState(NPC npc, Dictionary<string, DialogueChoice> choices)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)npc != (Object)null && choices.TryGetValue(data.DiseaseID, out var value))
			{
				value.Enabled = Vector3.Distance(npc.CenterPoint, HospitalHealing.hospitalDoorPoint) <= 7f && data.Active && data.HealState < 1f;
			}
		}
	}
	public static class PlayerConsumeDamage
	{
		public enum EConsumeType
		{
			None,
			Weed,
			Meth,
			Cocaine,
			Shroom,
			Paracetamol,
			Addy,
			Chili
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_0
		{
			public ProductItemInstance current;

			internal bool <CurrentProductMonitor>g__CanContinue|0()
			{
				if (Flatline.registered && !FlatlinePlayer.isQueuedForDeath && Player.Local.ConsumedProduct != null && Player.Local.ConsumedProduct == current)
				{
					return Flatline.haltExecution;
				}
				return true;
			}

			internal bool <CurrentProductMonitor>b__1()
			{
				return <CurrentProductMonitor>g__CanContinue|0();
			}
		}

		[CompilerGenerated]
		private sealed class <CurrentProductMonitor>d__31 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass31_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CurrentProductMonitor>d__31(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass31_0();
					if (ProductEffectRunning)
					{
						return false;
					}
					ProductEffectRunning = true;
					<>2__current = Flatline.Wait025;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>8__1.current = Player.Local.ConsumedProduct;
					if (<>8__1.current != null)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => <>8__1.<CurrentProductMonitor>g__CanContinue|0()));
						<>2__current = val;
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				DebugModule.Log("Current product has ended, disable", "CurrentProductMonitor");
				ProductEffectRunning = false;
				IsWeedEffectRunning = false;
				IsShroomEffectRunning = false;
				IsMethEffectRunning = false;
				IsCocaineEffectRunning = false;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <HeartPumpOverride>d__34 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string consumedID;

			private ConsumptionData <data>5__2;

			private float <maxTotalElapsed>5__3;

			private float <totalElapsed>5__4;

			private int <maxBeatsPerMinute>5__5;

			private int <minBeatsPerMinute>5__6;

			private float <elapsedSinceLast>5__7;

			private float <secondsForBeat>5__8;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HeartPumpOverride>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<data>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<totalElapsed>5__4 += 0.1f;
					<elapsedSinceLast>5__7 += 0.1f;
					if (<elapsedSinceLast>5__7 >= <secondsForBeat>5__8)
					{
						if ((Object)(object)heartBeatSource != (Object)null && !heartBeatSource.isPlaying)
						{
							heartBeatSource.PlayOneShot(ConfigLoader.loadedAudios["singleheartbeat"]);
						}
						if (Mathf.RoundToInt(<totalElapsed>5__4) % 5 == 0)
						{
							int num2 = Mathf.RoundToInt(Mathf.Lerp((float)<minBeatsPerMinute>5__6, (float)<maxBeatsPerMinute>5__5, Mathf.Clamp01(<data>5__2.currentAmountInSystem)));
							float num3 = (float)num2 / 60f;
							<secondsForBeat>5__8 = 1f / num3;
						}
					}
				}
				else
				{
					<>1__state = -1;
					if (heartPumpOverrideActive)
					{
						return false;
					}
					heartPumpOverrideActive = true;
					DebugModule.Log("Starting heart pump override", "HeartPumpOverride");
					if (!Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue(consumedID, out <data>5__2))
					{
						DebugModule.Log("No match for id in consumption data", "HeartPumpOverride");
						heartPumpOverrideActive = false;
						return false;
					}
					if (!<HeartPumpOverride>g__CanContinue|34_0(<data>5__2))
					{
						heartPumpOverrideActive = false;
						return false;
					}
					<maxTotalElapsed>5__3 = 120f;
					<totalElapsed>5__4 = 0f;
					<maxBeatsPerMinute>5__5 = 200;
					<minBeatsPerMinute>5__6 = 70;
					int num2 = Mathf.RoundToInt(Mathf.Lerp((float)<minBeatsPerMinute>5__6, (float)<maxBeatsPerMinute>5__5, Mathf.Clamp01(<data>5__2.currentAmountInSystem)));
					DebugModule.Log("Setting bpm to " + num2, "HeartPumpOverride");
					<elapsedSinceLast>5__7 = 0f;
					float num3 = (float)num2 / 60f;
					<secondsForBeat>5__8 = 1f / num3;
				}
				if (!Flatline.registered)
				{
					return false;
				}
				if (<HeartPumpOverride>g__CanContinue|34_0(<data>5__2) && !(<totalElapsed>5__4 >= <maxTotalElapsed>5__3))
				{
					<>2__current = Flatline.Wait01;
					<>1__state = 1;
					return true;
				}
				DebugModule.Log("Finished heart pump override", "HeartPumpOverride");
				heartPumpOverrideActive = false;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ShroomEffectChanger>d__32 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <amplitudeMax>5__2;

			private float <amplitudeMin>5__3;

			private float <blendMax>5__4;

			private float <blendMin>5__5;

			private float <noiseScaleMax>5__6;

			private float <noiseScaleMin>5__7;

			private float <targetAmp>5__8;

			private float <targetBld>5__9;

			private float <targetNoi>5__10;

			private MaterialProperties <activeProperties>5__11;

			private MaterialProperties <source>5__12;

			private MaterialProperties <targetMaterialProperties>5__13;

			private float <easeInTime>5__14;

			private float <currentEase>5__15;

			private float <sleepTime>5__16;

			private float <sleepCurrent>5__17;

			private bool <shouldBreak>5__18;

			private MaterialProperties <temp>5__19;

			private bool <useBlend>5__20;

			private bool <useNoise>5__21;

			private bool <useAmplitude>5__22;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ShroomEffectChanger>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<activeProperties>5__11 = null;
				<source>5__12 = null;
				<targetMaterialProperties>5__13 = null;
				<temp>5__19 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				ConsumptionData value2;
				float num2;
				float num3;
				float num4;
				float num5;
				List<int> list;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (IsShroomEffectRunning)
					{
						return false;
					}
					IsShroomEffectRunning = true;
					<amplitudeMax>5__2 = 0.5f;
					<amplitudeMin>5__3 = 0.19f;
					<blendMax>5__4 = 0.4f;
					<blendMin>5__5 = 0.016f;
					<noiseScaleMax>5__6 = 50f;
					<noiseScaleMin>5__7 = 15f;
					float num = 0f;
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("shroom", out var value))
					{
						num = Mathf.Clamp01(value.currentAmountInSystem);
					}
					<targetAmp>5__8 = Mathf.Lerp(<amplitudeMin>5__3, <amplitudeMax>5__2, num) * Random.Range(0.95f, 1.05f);
					<targetBld>5__9 = Mathf.Lerp(<blendMin>5__5, <blendMax>5__4, num) * Random.Range(0.95f, 1.05f);
					<targetNoi>5__10 = Mathf.Lerp(<noiseScaleMin>5__7, <noiseScaleMax>5__6, num) * Random.Range(0.95f, 1.05f);
					<activeProperties>5__11 = Singleton<PostProcessingManager>.Instance.GetActivePsychedelicEffectProperties();
					<source>5__12 = <activeProperties>5__11.Clone();
					PsychedelicFullScreenData psychedelicEffectDataPreset = Singleton<PostProcessingManager>.Instance.GetPsychedelicEffectDataPreset("Active");
					<targetMaterialProperties>5__13 = psychedelicEffectDataPreset.ConvertToMaterialProperties();
					<targetMaterialProperties>5__13.Blend = <targetBld>5__9;
					<targetMaterialProperties>5__13.NoiseScale = <targetNoi>5__10;
					<targetMaterialProperties>5__13.Amplitude = <targetAmp>5__8;
					Singleton<EnvironmentFX>.Instance.SetEnvironmentScrollingActive(true);
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectActive(true);
					<easeInTime>5__14 = 2f;
					<currentEase>5__15 = 0f;
					goto IL_0243;
				}
				case 1:
					<>1__state = -1;
					goto IL_0243;
				case 2:
					<>1__state = -1;
					goto IL_02d7;
				case 3:
					{
						<>1__state = -1;
						goto IL_06be;
					}
					IL_0281:
					if (<shouldBreak>5__18)
					{
						break;
					}
					goto IL_02d7;
					IL_02d7:
					if (<sleepCurrent>5__17 < <sleepTime>5__16)
					{
						<sleepCurrent>5__17 += Time.deltaTime;
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsShroomEffectRunning)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<shouldBreak>5__18 = true;
					}
					<sleepCurrent>5__17 = 0f;
					if (<shouldBreak>5__18)
					{
						break;
					}
					if (Flatline.isSaving || !Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("shroom", out value2))
					{
						goto IL_0281;
					}
					num2 = Mathf.Clamp01(value2.currentAmountInSystem);
					if (num2 > 0.75f && Random.Range(0f, 1f) > 0.98f)
					{
						Player.Local.Avatar.Effects.TriggerSick(false);
						FlatlinePlayer.SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger - 0.05f));
						FlatlinePlayer.SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - 0.02f));
					}
					<targetAmp>5__8 = Mathf.Lerp(<amplitudeMin>5__3, <amplitudeMax>5__2, num2);
					<targetBld>5__9 = Mathf.Lerp(<blendMin>5__5, <blendMax>5__4, num2);
					<targetNoi>5__10 = Mathf.Lerp(<noiseScaleMin>5__7, <noiseScaleMax>5__6, num2);
					<temp>5__19 = Singleton<PostProcessingManager>.Instance.GetActivePsychedelicEffectProperties().Clone();
					<targetAmp>5__8 = Mathf.Clamp(<targetAmp>5__8, <temp>5__19.Amplitude - <amplitudeMax>5__2 / 10f, <temp>5__19.Amplitude + <amplitudeMax>5__2 / 10f);
					<targetBld>5__9 = Mathf.Clamp(<targetBld>5__9, <temp>5__19.Blend - <blendMax>5__4 / 10f, <temp>5__19.Blend + <blendMax>5__4 / 10f);
					<targetNoi>5__10 = Mathf.Clamp(<targetNoi>5__10, <temp>5__19.NoiseScale - <noiseScaleMax>5__6 / 10f, <temp>5__19.NoiseScale + <noiseScaleMax>5__6 / 10f);
					num3 = Random.Range(0f, 1f);
					num4 = Random.Range(0f, 1f);
					num5 = Random.Range(0f, 1f);
					<useBlend>5__20 = false;
					<useNoise>5__21 = false;
					<useAmplitude>5__22 = false;
					list = new List<int> { 0, 1, 2 };
					ListExtensions.Shuffle<int>((IList<int>)list, -1);
					for (int i = 0; i < 2; i++)
					{
						if (list[i] == 0 && (double)num3 > 0.33)
						{
							<useBlend>5__20 = true;
						}
						if (list[i] == 1 && (double)num4 > 0.33)
						{
							<useNoise>5__21 = true;
						}
						if (list[i] == 2 && (double)num5 > 0.33)
						{
							<useAmplitude>5__22 = true;
						}
					}
					if (<useBlend>5__20 | <useNoise>5__21 | <useAmplitude>5__22)
					{
						<currentEase>5__15 = 0f;
						goto IL_06be;
					}
					goto IL_0722;
					IL_06be:
					if (<currentEase>5__15 < <easeInTime>5__14)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsShroomEffectRunning)
						{
							<currentEase>5__15 += Time.deltaTime;
							float num6 = <currentEase>5__15 / <easeInTime>5__14;
							float num7 = Mathf.SmoothStep(0f, 1f, num6);
							if (<useBlend>5__20)
							{
								<activeProperties>5__11.Blend = Mathf.Lerp(<temp>5__19.Blend, <targetBld>5__9, num7);
							}
							if (<useNoise>5__21)
							{
								<activeProperties>5__11.NoiseScale = Mathf.Lerp(<temp>5__19.NoiseScale, <targetNoi>5__10, num7);
							}
							if (<useAmplitude>5__22)
							{
								<activeProperties>5__11.Amplitude = Mathf.Lerp(<temp>5__19.Amplitude, <targetAmp>5__8, num7);
							}
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						<shouldBreak>5__18 = true;
					}
					if (<shouldBreak>5__18)
					{
						break;
					}
					<targetMaterialProperties>5__13 = <activeProperties>5__11.Clone();
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectProperties(<targetMaterialProperties>5__13);
					<sleepTime>5__16 = Random.Range(5f, 10f);
					<easeInTime>5__14 = Random.Range(2f, 6f);
					goto IL_0722;
					IL_0722:
					<temp>5__19 = null;
					goto IL_0281;
					IL_0243:
					if (<currentEase>5__15 < <easeInTime>5__14)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						<currentEase>5__15 += Time.deltaTime;
						float num8 = <currentEase>5__15 / <easeInTime>5__14;
						<activeProperties>5__11.Blend = Mathf.Lerp(<source>5__12.Blend, <targetMaterialProperties>5__13.Blend, num8);
						Singleton<EnvironmentFX>.Instance.SetEnvironmentScrollingSpeedByPercentage(Mathf.Lerp(0f, 1f, num8));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectProperties(<targetMaterialProperties>5__13);
					<sleepTime>5__16 = 5f;
					<sleepCurrent>5__17 = 0f;
					<shouldBreak>5__18 = false;
					goto IL_0281;
				}
				DebugModule.Log("Shroom effect changer ended", "ShroomEffectChanger");
				IsShroomEffectRunning = false;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <StimulantEffectChanger>d__33 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <sleepTime>5__2;

			private float <sleepCurrent>5__3;

			private bool <shouldBreak>5__4;

			private float <rotAmount>5__5;

			private int <i>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <StimulantEffectChanger>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0334: Unknown result type (might be due to invalid IL or missing references)
				//IL_033b: 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_0355: Unknown result type (might be due to invalid IL or missing references)
				ConsumptionData value;
				ConsumptionData value2;
				float num5;
				float num6;
				float num7;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (IsCocaineEffectRunning || IsMethEffectRunning)
					{
						return false;
					}
					IsCocaineEffectRunning = true;
					IsMethEffectRunning = true;
					<>2__current = Flatline.Wait2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					<sleepTime>5__2 = 2f;
					<sleepCurrent>5__3 = 0f;
					<shouldBreak>5__4 = false;
					goto IL_0083;
				case 2:
					<>1__state = -1;
					goto IL_00e0;
				case 3:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						if (!ProductEffectRunning || !IsMethEffectRunning || !IsCocaineEffectRunning)
						{
							<shouldBreak>5__4 = true;
							goto IL_0426;
						}
						if (Random.Range(0f, 1f) > 0.55f)
						{
							float num = 0.5f;
							float num2 = 0f;
							Quaternion rotation = ((Component)Player.Local).transform.root.rotation;
							while (num2 < num)
							{
								if (!Flatline.registered)
								{
									return false;
								}
								if (!ProductEffectRunning || !IsMethEffectRunning || !IsCocaineEffectRunning)
								{
									<shouldBreak>5__4 = true;
									break;
								}
								num2 += Time.deltaTime;
								float num3 = num2 / num;
								((Component)Player.Local).transform.root.rotation = Quaternion.Lerp(rotation, Quaternion.Euler(0f, rotation.y + <rotAmount>5__5, 0f), num3);
							}
							if (<shouldBreak>5__4)
							{
								goto IL_0426;
							}
						}
						if (<i>5__6 % 2 == 0)
						{
							PlayerInventory instance = PlayerSingleton<PlayerInventory>.Instance;
							if (!GameInput.IsTyping && !Singleton<PauseMenu>.Instance.IsPaused && instance.HotbarEnabled)
							{
								int num4 = Random.Range(0, 8);
								if (num4 != instance.EquippedSlotIndex)
								{
									if (instance.EquippedSlotIndex != -1)
									{
										instance.IndexAllSlots(instance.EquippedSlotIndex).Unequip();
									}
									instance.PreviousEquippedSlotIndex = instance.EquippedSlotIndex;
									instance.EquippedSlotIndex = num4;
									instance.Equip(instance.IndexAllSlots(num4));
									PlayerSingleton<ViewmodelSway>.Instance.RefreshViewmodel();
								}
							}
						}
						<i>5__6++;
						goto IL_0414;
					}
					IL_0426:
					if (<shouldBreak>5__4)
					{
						break;
					}
					goto IL_0083;
					IL_0414:
					if (<i>5__6 < Random.Range(4, 8))
					{
						<>2__current = Flatline.Wait05;
						<>1__state = 3;
						return true;
					}
					goto IL_0426;
					IL_0083:
					if (<shouldBreak>5__4)
					{
						break;
					}
					goto IL_00e0;
					IL_00e0:
					if (<sleepCurrent>5__3 < <sleepTime>5__2)
					{
						<sleepCurrent>5__3 += Time.deltaTime;
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsMethEffectRunning && IsCocaineEffectRunning)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<shouldBreak>5__4 = true;
					}
					<sleepCurrent>5__3 = 0f;
					if (<shouldBreak>5__4)
					{
						break;
					}
					num5 = 0f;
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("meth", out value) && value.currentAmountInSystem > 0.001f)
					{
						num5 = value.currentAmountInSystem;
					}
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("cocaine", out value2) && value2.currentAmountInSystem > 0.001f && value2.currentAmountInSystem > num5)
					{
						num5 = value2.currentAmountInSystem;
					}
					num5 = Mathf.Clamp01(num5);
					if (num5 > 0.75f && Random.Range(0f, 1f) > 0.98f)
					{
						Player.Local.Avatar.Effects.TriggerSick(false);
						FlatlinePlayer.SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger - 0.05f));
						FlatlinePlayer.SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - 0.02f));
					}
					num6 = Mathf.Lerp(0.9f, 0.75f, num5);
					if (Random.Range(0f, 1f) < num6)
					{
						goto IL_0083;
					}
					num7 = Mathf.Lerp(1.15f, 2f, num5);
					<rotAmount>5__5 = Random.Range(2f, 6f) * num7;
					<rotAmount>5__5 = ((Random.Range(0, 2) == 0) ? (0f - <rotAmount>5__5) : <rotAmount>5__5);
					<i>5__6 = 0;
					goto IL_0414;
				}
				IsCocaineEffectRunning = false;
				IsMethEffectRunning = false;
				DebugModule.Log("Stimulant effect changer ended", "StimulantEffectChanger");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SystemicDecay>d__29 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SystemicDecay>d__29(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (Flatline.isSaving)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.isSaving));
						<>2__current = val;
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				foreach (string item in new List<string>(Flatline.loadedPlayerData.State.consumptionDatas.Keys))
				{
					float currentAmountInSystem = Flatline.loadedPlayerData.State.consumptionDatas[item].currentAmountInSystem;
					if (currentAmountInSystem > 0f)
					{
						int lifeTimeHrs = lifeTimeHours[item];
						float num = DecayHalfLife(currentAmountInSystem, lifeTimeHrs);
						if (num < 0.0001f)
						{
							num = 0f;
						}
						Flatline.loadedPlayerData.State.consumptionDatas[item].currentAmountInSystem = num;
					}
				}
				if (Flatline.loadedPlayerData.State.consumptionDatas.Any((KeyValuePair<string, ConsumptionData> x) => x.Value.currentAmountInSystem >= 1f))
				{
					KeyValuePair<string, ConsumptionData> keyValuePair = Flatline.loadedPlayerData.State.consumptionDatas.First((KeyValuePair<string, ConsumptionData> x) => x.Value.currentAmountInSystem >= 1f);
					DebugModule.Log("Player consumed lethal dose of: " + keyValuePair.Key, "SystemicDecay");
					FlatlineUIModule.causeOfDeath = "Lethal dose of " + keyValuePair.Key;
					Player.Local.Avatar.Effects.TriggerSick(false);
					Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
					if (Player.PlayerList.Count > 1)
					{
						Flatline.loadedPlayerData.State.consumptionDatas[keyValuePair.Key].currentAmountInSystem = 0f;
					}
					return false;
				}
				if (Flatline.loadedPlayerData.State.consumptionDatas.Any((KeyValuePair<string, ConsumptionData> x) => x.Value.overtimeLiverDamage >= 1f))
				{
					KeyValuePair<string, ConsumptionData> keyValuePair2 = Flatline.loadedPlayerData.State.consumptionDatas.First((KeyValuePair<string, ConsumptionData> x) => x.Value.overtimeLiverDamage >= 1f);
					DebugModule.Log("Players liver failed due to: " + keyValuePair2.Key, "SystemicDecay");
					FlatlineUIModule.causeOfDeath = "Liver failure from consumption of " + keyValuePair2.Key;
					Player.Local.Avatar.Effects.TriggerSick(false);
					Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
					if (Player.PlayerList.Count > 1)
					{
						Flatline.loadedPlayerData.State.consumptionDatas[keyValuePair2.Key].overtimeLiverDamage = 0f;
					}
					return false;
				}
				if (Flatline.loadedPlayerData.State.consumptionDatas.Any((KeyValuePair<string, ConsumptionData> x) => x.Value.overtimeLungDamage >= 1f))
				{
					KeyValuePair<string, ConsumptionData> keyValuePair3 = Flatline.loadedPlayerData.State.consumptionDatas.First((KeyValuePair<string, ConsumptionData> x) => x.Value.overtimeLungDamage >= 1f);
					DebugModule.Log("Players lungs failed due to: " + keyValuePair3.Key, "SystemicDecay");
					FlatlineUIModule.causeOfDeath = "Pulmonary embolism from smoking " + keyValuePair3.Key;
					Player.Local.Avatar.Effects.TriggerSick(false);
					Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
					if (Player.PlayerList.Count > 1)
					{
						Flatline.loadedPlayerData.State.consumptionDatas[keyValuePair3.Key].overtimeLungDamage = 0f;
					}
					return false;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WaitRandomAfterConsume>d__27 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public EConsumeType type;

			public EQuality quality;

			private int <randomWaitMins>5__2;

			private int <i>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitRandomAfterConsume>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Invalid comparison between Unknown and I4
				//IL_0251: 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_01c5: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<randomWaitMins>5__2 = Random.Range(3, 6);
					<i>5__3 = 0;
					goto IL_007a;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || FlatlinePlayer.isQueuedForDeath || Flatline.haltExecution)
					{
						return false;
					}
					<i>5__3++;
					goto IL_007a;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_007a:
					if (<i>5__3 < <randomWaitMins>5__2)
					{
						<>2__current = Flatline.Wait60;
						<>1__state = 1;
						return true;
					}
					if (Flatline.isSaving)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.isSaving));
						<>2__current = val;
						<>1__state = 2;
						return true;
					}
					break;
				}
				if (!Flatline.registered || FlatlinePlayer.isQueuedForDeath || Flatline.haltExecution)
				{
					return false;
				}
				DebugModule.Log("Evaluate after effects for drug", "WaitRandomAfterConsume");
				if ((type == EConsumeType.Meth || type == EConsumeType.Cocaine) && (int)quality < 4 && Random.Range(0f, 1f) > 0.8f)
				{
					Player.Local.Avatar.Effects.TriggerSick(false);
					if (Flatline.loadedPlayerData.State.Hunger > 0.1f)
					{
						FlatlinePlayer.SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger * 0.95f));
					}
					if (Flatline.loadedPlayerData.State.Thirst > 0.1f)
					{
						FlatlinePlayer.SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst * 0.92f));
					}
				}
				else if (type == EConsumeType.Weed && (int)quality >= 2 && Random.Range(0f, 1f) > 0.2f)
				{
					if (Flatline.loadedPlayerData.State.Hunger > 0.1f)
					{
						FlatlinePlayer.SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger * 0.75f));
					}
					if (Flatline.loadedPlayerData.State.Thirst > 0.1f)
					{
						FlatlinePlayer.SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst * 0.75f));
					}
				}
				PlayerDiseaseDamage.CalculateDepressionAfterConsumeProbability(type, quality);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly List<string> trackedKeys = new List<string> { "cocaine", "meth", "shroom", "weed", "paracetamol", "addy", "chili" };

		public static readonly int CocaineLifeTimeHrs = 8;

		public static readonly float cocaineSystemicAmountPerDose = 0.08f;

		public static readonly float cocaineConsumeLungDamage = 0.004f;

		public static readonly int MethLifeTimeHrs = 12;

		public static readonly float methSystemicAmountPerDose = 0.11f;

		public static readonly float methConsumeLungDamage = 0.0005f;

		public static readonly int ShroomsLifeTimeHrs = 6;

		public static readonly float shroomSystemicAmountPerDose = 0.06f;

		public static readonly float weedConsumeLungDamage = 0.009f;

		public static readonly float paracetamolLiverDamage = 0.005f;

		public static readonly int ParacetamolLifeTimeHrs = 18;

		public static readonly int AddyLifeTimeHrs = 14;

		public static readonly int ChiliLifeTimeHrs = 50;

		public static readonly Dictionary<string, int> lifeTimeHours = new Dictionary<string, int>
		{
			{ "cocaine", CocaineLifeTimeHrs },
			{ "meth", MethLifeTimeHrs },
			{ "shroom", ShroomsLifeTimeHrs },
			{ "paracetamol", ParacetamolLifeTimeHrs },
			{ "addy", AddyLifeTimeHrs },
			{ "chili", ChiliLifeTimeHrs }
		};

		public static bool ProductEffectRunning = false;

		public static bool IsWeedEffectRunning = false;

		public static bool IsShroomEffectRunning = false;

		public static bool IsMethEffectRunning = false;

		public static bool IsCocaineEffectRunning = false;

		public static AudioSource heartBeatSource = null;

		public static bool heartPumpOverrideActive = false;

		public static void InitConsumeDamageModule()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FlatlineHeartAudio");
			val.transform.parent = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform;
			val.transform.localPosition = Vector3.zero;
			heartBeatSource = val.AddComponent<AudioSource>();
			heartBeatSource.volume = 0.7f;
			heartBeatSource.loop = false;
			val.SetActive(true);
			((Behaviour)heartBeatSource).enabled = true;
		}

		public static void ResetConsumeDamageModule()
		{
			ProductEffectRunning = false;
			IsWeedEffectRunning = false;
			IsShroomEffectRunning = false;
			IsMethEffectRunning = false;
			IsCocaineEffectRunning = false;
			heartBeatSource = null;
			heartPumpOverrideActive = false;
		}

		public static EConsumeType TypeFromID(string id)
		{
			return id switch
			{
				"weed" => EConsumeType.Weed, 
				"meth" => EConsumeType.Meth, 
				"cocaine" => EConsumeType.Cocaine, 
				"shroom" => EConsumeType.Shroom, 
				"paracetamol" => EConsumeType.Paracetamol, 
				"addy" => EConsumeType.Addy, 
				"chili" => EConsumeType.Chili, 
				_ => EConsumeType.None, 
			};
		}

		public static void OnProductConsumed(EConsumeType type, EQuality quality = 0, bool useQuality = false)
		{
			//IL_003e: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!Flatline.currentConfig.DrugSideEffects || type == EConsumeType.None)
			{
				return;
			}
			float num = 1f;
			float num2 = 1f;
			if (useQuality)
			{
				int num3 = Enum.GetNames(typeof(EQuality)).Length - 1;
				num = Mathf.Lerp(1f, 2f, (float)quality / (float)num3);
				num2 = Mathf.Lerp(2f, 1f, (float)quality / (float)num3);
				Flatline.coros.Add(MelonCoroutines.Start(WaitRandomAfterConsume(type, quality)));
			}
			string key = type.ToString().ToLower();
			if (!Flatline.loadedPlayerData.State.consumptionDatas.ContainsKey(key))
			{
				Flatline.loadedPlayerData.State.consumptionDatas.Add(key, new ConsumptionData());
			}
			switch (type)
			{
			case EConsumeType.Weed:
				Flatline.loadedPlayerData.State.consumptionDatas[key].overtimeLungDamage += weedConsumeLungDamage * num2;
				Flatline.loadedPlayerData.State.healthData.TimesSmoked++;
				break;
			case EConsumeType.Meth:
				Flatline.loadedPlayerData.State.consumptionDatas[key].overtimeLungDamage += methConsumeLungDamage * num2;
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += methSystemicAmountPerDose * num;
				Flatline.loadedPlayerData.State.healthData.TimesSmoked++;
				Flatline.coros.Add(MelonCoroutines.Start(CurrentProductMonitor()));
				Flatline.coros.Add(MelonCoroutines.Start(StimulantEffectChanger()));
				Flatline.coros.Add(MelonCoroutines.Start(HeartPumpOverride("meth")));
				break;
			case EConsumeType.Cocaine:
				Flatline.loadedPlayerData.State.consumptionDatas[key].overtimeLungDamage += cocaineConsumeLungDamage * num2;
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += cocaineSystemicAmountPerDose * num;
				Flatline.coros.Add(MelonCoroutines.Start(CurrentProductMonitor()));
				Flatline.coros.Add(MelonCoroutines.Start(StimulantEffectChanger()));
				Flatline.coros.Add(MelonCoroutines.Start(HeartPumpOverride("cocaine")));
				break;
			case EConsumeType.Shroom:
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += shroomSystemicAmountPerDose * num;
				Flatline.coros.Add(MelonCoroutines.Start(CurrentProductMonitor()));
				Flatline.coros.Add(MelonCoroutines.Start(ShroomEffectChanger()));
				break;
			case EConsumeType.Paracetamol:
			{
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += IngestibleParacetamol.SystemicAmountPerDose;
				Flatline.loadedPlayerData.State.consumptionDatas[key].overtimeLiverDamage += paracetamolLiverDamage;
				float maxHP = Flatline.loadedPlayerData.State.healthData.MaxHP;
				if (!Mathf.Approximately(maxHP, 100f))
				{
					Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(maxHP + IngestibleParacetamol.MaxHPRegen, 1f, 100f);
				}
				break;
			}
			case EConsumeType.Addy:
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += IngestibleAddy.SystemicAmountPerDose;
				break;
			case EConsumeType.Chili:
				Flatline.loadedPlayerData.State.consumptionDatas[key].currentAmountInSystem += IngestibleChili.SystemicAmountPerDose;
				break;
			}
			DebugModule.Log("Changed consumption values succesfully", "OnProductConsumed");
		}

		[IteratorStateMachine(typeof(<WaitRandomAfterConsume>d__27))]
		public static IEnumerator WaitRandomAfterConsume(EConsumeType type, EQuality quality)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitRandomAfterConsume>d__27(0)
			{
				type = type,
				quality = quality
			};
		}

		public static void OnHourPass()
		{
			if (Flatline.registered && !FlatlinePlayer.isQueuedForDeath && !Flatline.haltExecution && (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 659 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 400))
			{
				Flatline.coros.Add(MelonCoroutines.Start(SystemicDecay()));
			}
		}

		[IteratorStateMachine(typeof(<SystemicDecay>d__29))]
		public static IEnumerator SystemicDecay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SystemicDecay>d__29(0);
		}

		public static float DecayHalfLife(float current, int lifeTimeHrs)
		{
			return Mathf.Clamp(current * Mathf.Pow(0.5f, 1f / (float)lifeTimeHrs), 0f, 2f);
		}

		[IteratorStateMachine(typeof(<CurrentProductMonitor>d__31))]
		public static IEnumerator CurrentProductMonitor()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CurrentProductMonitor>d__31(0);
		}

		[IteratorStateMachine(typeof(<ShroomEffectChanger>d__32))]
		public static IEnumerator ShroomEffectChanger()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShroomEffectChanger>d__32(0);
		}

		[IteratorStateMachine(typeof(<StimulantEffectChanger>d__33))]
		public static IEnumerator StimulantEffectChanger()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StimulantEffectChanger>d__33(0);
		}

		[IteratorStateMachine(typeof(<HeartPumpOverride>d__34))]
		public static IEnumerator HeartPumpOverride(string consumedID)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HeartPumpOverride>d__34(0)
			{
				consumedID = consumedID
			};
		}

		[CompilerGenerated]
		internal static bool <HeartPumpOverride>g__CanContinue|34_0(ConsumptionData data)
		{
			if (PlayerSingleton<PlayerCamera>.Instance.HeartbeatSoundController._sound._audioSource.volume == 0f && Mathf.Clamp01(data.currentAmountInSystem) > 0.55f && !FlatlinePlayer.isQueuedForDeath && !FlatlinePlayer.isPassedOut)
			{
				return ProductEffectRunning;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ShroomInstance), "DoPsychedlicEffectBlend")]
	public static class ShroomInstance_DoPsychedlicEffectBlend_Patch
	{
		[CompilerGenerated]
		private sealed class <EmptyCoroutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EmptyCoroutine>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPrefix]
		public static bool Prefix(ShroomInstance __instance, ref IEnumerator __result, MaterialProperties targetMaterialProperties, float targetValuePercentage, float duration)
		{
			if (!Flatline.currentConfig.DrugSideEffects)
			{
				return true;
			}
			if (targetValuePercentage > 0f)
			{
				__result = EmptyCoroutine();
				return false;
			}
			return true;
		}

		[IteratorStateMachine(typeof(<EmptyCoroutine>d__1))]
		public static IEnumerator EmptyCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EmptyCoroutine>d__1(0);
		}
	}
	public static class PlayerDiseaseDamage
	{
		private enum ImpactLocation
		{
			Legs,
			Torso,
			Head
		}

		public static List<Disease> allDiseases = new List<Disease>();

		public static readonly List<string> diseaseNames = new List<string> { "cancer", "fever", "bonebreak", "bleed", "depression" };

		public static GameObject bleedPressureIntObj;

		public static bool isBleedingStemmed = false;

		public static void InitPlayerDiseaseDamage()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_004b: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			bleedPressureIntObj = new GameObject("ApplyPressureInt");
			bleedPressureIntObj.layer = LayerMask.NameToLayer("Task");
			bleedPressureIntObj.transform.parent = ((Component)Player.Local).transform.root;
			bleedPressureIntObj.transform.localScale = Vector3.one;
			bleedPressureIntObj.transform.localRotation = Quaternion.identity;
			bleedPressureIntObj.transform.localPosition = new Vector3(0f, 0.1f, 0.1f);
			bleedPressureIntObj.AddComponent<BoxCollider>().size = new Vector3(0.2f, 0.2f, 0.2f);
			InteractableObject obj = bleedPressureIntObj.AddComponent<InteractableObject>();
			obj.message = "Stem bleeding";
			obj.MaxInteractionRange = 2f;
			obj.interactionType = (EInteractionType)0;
			obj.onInteractStart.AddListener(new UnityAction(SetIsBleedingStemmedTrue));
			obj.onInteractEnd.AddListener(new UnityAction(SetIsBleedingStemmedFalse));
			bleedPressureIntObj.SetActive(false);
			static void SetIsBleedingStemmedFalse()
			{
				DebugModule.Log("Disable bleeding stemmed", "InitPlayerDiseaseDamage");
				isBleedingStemmed = false;
			}
			static void SetIsBleedingStemmedTrue()
			{
				DebugModule.Log("Set bleeding stemmed", "InitPlayerDiseaseDamage");
				isBleedingStemmed = true;
			}
		}

		public static void ResetPlayerDiseaseDamage()
		{
			bleedPressureIntObj = null;
			isBleedingStemmed = false;
		}

		public static void ApplyLoadedDiseases()
		{
			if (!Flatline.currentConfig.DiseasesEnabled)
			{
				return;
			}
			foreach (DiseaseData diseaseDatum in Flatline.loadedPlayerData.DiseaseData)
			{
				switch (diseaseDatum.DiseaseID)
				{
				case "cancer":
				{
					Cancer item5 = new Cancer(diseaseDatum);
					allDiseases.Add(item5);
					break;
				}
				case "fever":
				{
					Fever item4 = new Fever(diseaseDatum);
					allDiseases.Add(item4);
					break;
				}
				case "bonebreak":
				{
					BoneBreak item3 = new BoneBreak(diseaseDatum);
					allDiseases.Add(item3);
					break;
				}
				case "bleed":
				{
					Bleeding item2 = new Bleeding(diseaseDatum);
					allDiseases.Add(item2);
					break;
				}
				case "depression":
				{
					Depression item = new Depression(diseaseDatum);
					allDiseases.Add(item);
					break;
				}
				default:
					DebugModule.Log("Unknown disease id: " + diseaseDatum.DiseaseID, "ApplyLoadedDiseases");
					break;
				}
			}
			bool flag = false;
			foreach (Disease allDisease in allDiseases)
			{
				if (allDisease.data.Active && allDisease.data.HealState < 1f)
				{
					allDisease.diseaseCoroutine = MelonCoroutines.Start(allDisease.DiseaseEvaluator());
				}
				if (allDisease.data.DiseaseID == "bonebreak")
				{
					flag = true;
				}
			}
			if (Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken && !flag)
			{
				DebugModule.Log("Player leg bone cant be broken since there is no active disease, setting false", "ApplyLoadedDiseases");
				Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = false;
			}
		}

		public static void UpdateDiseaseData()
		{
			Flatline.loadedPlayerData.DiseaseData.Clear();
			foreach (Disease allDisease in allDiseases)
			{
				if (allDisease.data.Active)
				{
					allDisease.UpdateDiseaseData();
					Flatline.loadedPlayerData.DiseaseData.Add(allDisease.data);
				}
			}
		}

		public static T AddNewDisease<T>(float severity) where T : Disease
		{
			if (!Flatline.currentConfig.DiseasesEnabled)
			{
				return null;
			}
			if (typeof(T) == typeof(Bleeding) && !Flatline.currentConfig.BleedingEnabled)
			{
				return null;
			}
			if (typeof(T) == typeof(BoneBreak) && !Flatline.currentConfig.BoneBreakEnabled)
			{
				return null;
			}
			if (typeof(T) == typeof(Cancer) && !Flatline.currentConfig.CancerEnabled)
			{
				return null;
			}
			if (typeof(T) == typeof(Depression) && !Flatline.currentConfig.DepressionEnabled)
			{
				return null;
			}
			if (typeof(T) == typeof(Fever) && !Flatline.currentConfig.FeverEnabled)
			{
				return null;
			}
			float num = Mathf.Clamp(severity, 0f, 0.3f);
			foreach (Disease allDisease in allDiseases)
			{
				if (allDisease.GetType() == typeof(T) && allDisease.data.Active)
				{
					DebugModule.Log("Disease of type " + typeof(T).Name + " is already active, can't add duplicate", "AddNewDisease");
					if (allDisease.GetType() == typeof(Bleeding) && allDisease.data.Severity < num)
					{
						DebugModule.Log("Upgrading bleeding to worse severity on reapply", "AddNewDisease");
						allDisease.data.Severity = num;
						allDisease.data.HealState *= 0.75f;
						(allDisease as Bleeding).MaximumMaxHPReduction = Mathf.Lerp(40f, 150f, num / 0.3f);
					}
					return null;
				}
			}
			DiseaseData diseaseData = new DiseaseData();
			diseaseData.Active = true;
			diseaseData.Severity = num;
			T val = (T)Activator.CreateInstance(typeof(T), diseaseData);
			allDiseases.Add(val);
			val.diseaseCoroutine = MelonCoroutines.Start(val.DiseaseEvaluator());
			DebugModule.Log("Succesfully added new disease: " + typeof(T).Name, "AddNewDisease");
			return val;
		}

		public static void OnHourPass()
		{
			if (!Flatline.haltExecution && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 659 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 400))
			{
				CalculateFeverProbability();
			}
		}

		public static void OnSleepEnd()
		{
			if (!Flatline.haltExecution)
			{
				CalculateCancerProbability();
				CalculateDepressionPassiveProbability();
			}
		}

		public static void CalculateDepressionPassiveProbability()
		{
			float num = Mathf.Clamp01((float)NetworkSingleton<TimeManager>.Instance.ElapsedDays / 100f);
			int num2 = ((FlatlinePlayer.minsInsideProperty == 0) ? 1 : FlatlinePlayer.minsInsideProperty);
			int num3 = ((FlatlinePlayer.minsOutsideProperty == 0) ? 1 : FlatlinePlayer.minsOutsideProperty);
			float num4 = 0f;
			if (num2 >= num3)
			{
				int num5 = num2 - num3;
				if ((float)num5 > 480f)
				{
					num4 += 0.09f;
				}
				else if ((float)num5 > 360f)
				{
					num4 += 0.06f;
				}
				else if ((float)num5 > 240f)
				{
					num4 += 0.03f;
				}
			}
			int num6 = 0;
			float num7 = 0f;
			if (Flatline.loadedPlayerData.State.consumptionDatas.Count > 0)
			{
				foreach (KeyValuePair<string, ConsumptionData> consumptionData in Flatline.loadedPlayerData.State.consumptionDatas)
				{
					if (Depression.temporaryDepressionCures.Contains(consumptionData.Key))
					{
						num7 += consumptionData.Value.currentAmountInSystem;
						num6++;
					}
				}
			}
			float num8 = 0f;
			if (num6 > 0)
			{
				num7 /= (float)num6;
				num8 = Mathf.Lerp(0f, 0.03f, num7);
			}
			num8 += Mathf.Clamp((float)Flatline.loadedPlayerData.State.healthData.TimesSmoked / 100f, 0f, 0.33f);
			num8 = Mathf.Clamp01(num8);
			float num9 = 0f;
			if (Flatline.loadedPlayerData.State.Thirst <= 0.65f)
			{
				num9 += 0.002f;
			}
			if (Flatline.loadedPlayerData.State.Hunger <= 0.65f)
			{
				num9 += 0.002f;
			}
			if (Flatline.loadedPlayerData.State.Temperature <= 0.65f)
			{
				num9 += 0.002f;
			}
			if (NetworkSingleton<MoneyManager>.Instance.cashBalance < 5000f)
			{
				num9 += 0.002f;
			}
			float gender = Player.Local.Avatar.CurrentSettings.Gender;
			float num10 = 0f;
			num10 = ((!(gender > 0.5f)) ? Random.Range(0.003f, 0.004f) : Random.Range(0.005f, 0.007f));
			float num11 = (float)FlatlinePlayer.minsWithSunnyWeather / 1440f;
			float num12 = Mathf.Lerp(0.25f, 0f, num11);
			float num13 = (num + num4 + num7 + num9 + num10 + num12) / 6f;
			DebugModule.Log($"Mins with sun: {FlatlinePlayer.minsWithSunnyWeather} ({num12})", "CalculateDepressionPassiveProbability");
			DebugModule.Log("Depression chance subtotal: " + num13, "CalculateDepressionPassiveProbability");
			if (Random.Range(0f, 1f) < num13)
			{
				DebugModule.Log("Depression consumption chance hits", "CalculateDepressionPassiveProbability");
				AddNewDisease<Depression>(Random.Range(0.001f, 0.3f));
			}
			FlatlinePlayer.minsOutsideProperty = 0;
			FlatlinePlayer.minsInsideProperty = 0;
			FlatlinePlayer.minsWithSunnyWeather = 0;
		}

		public static void CalculateDepressionAfterConsumeProbability(PlayerConsumeDamage.EConsumeType type, EQuality quality)
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if (type != PlayerConsumeDamage.EConsumeType.Weed && type != PlayerConsumeDamage.EConsumeType.Meth && type != PlayerConsumeDamage.EConsumeType.Cocaine && type != PlayerConsumeDamage.EConsumeType.Shroom)
			{
				return;
			}
			float num = 0f;
			switch (type)
			{
			case PlayerConsumeDamage.EConsumeType.Weed:
			{
				if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("weed", out var value3) && value3.currentAmountInSystem < 0.3f)
				{
					num = Random.Range(0.002f, 0.019f);
				}
				break;
			}
			case PlayerConsumeDamage.EConsumeType.Shroom:
			{
				if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("shroom", out var value2) && value2.currentAmountInSystem > 0.08f)
				{
					num = Random.Range(0.002f, 0.025f);
				}
				break;
			}
			case PlayerConsumeDamage.EConsumeType.Meth:
			{
				if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("meth", out var value4) && value4.currentAmountInSystem < 0.35f)
				{
					num = Random.Range(0.03f, 0.095f);
				}
				break;
			}
			case PlayerConsumeDamage.EConsumeType.Cocaine:
			{
				if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("cocaine", out var value) && value.currentAmountInSystem < 0.35f)
				{
					num = Random.Range(0.03f, 0.125f);
				}
				break;
			}
			}
			if (num == 0f)
			{
				num = 0.05f;
			}
			float num2 = num;
			float num3 = 1f + Flatline.loadedPlayerData.State.healthData.Predisposition;
			int num4 = Enum.GetNames(typeof(EQuality)).Length - 1;
			float num5 = Mathf.Lerp(0.95f, 1.08f, (float)quality / (float)num4);
			float num6 = Mathf.Clamp01(num2 * num3 * num5);
			DebugModule.Log("Depression subtotal consumption: " + num6, "CalculateDepressionAfterConsumeProbability");
			if (Random.Range(0f, 1f) < num6)
			{
				DebugModule.Log("Depression consumption chance hits", "CalculateDepressionAfterConsumeProbability");
				AddNewDisease<Depression>(Random.Range(0.001f, 0.3f));
			}
		}

		public static void CalculateFallBoneBreakProbability(float fallDamage)
		{
			float num = 0f;
			if (fallDamage >= 20f && fallDamage <= 25f)
			{
				num += 0.2f;
			}
			else if (fallDamage > 20f && fallDamage <= 28f)
			{
				num += 0.35f;
			}
			else if (fallDamage > 28f && fallDamage <= 38f)
			{
				num += 0.65f;
			}
			else if (fallDamage > 38f)
			{
				num += 0.75f;
			}
			float weight = Player.Local.Avatar.CurrentSettings.Weight;
			if (weight <= 0.25f)
			{
				num += 0.005f;
			}
			else if (weight > 0.25f && weight <= 0.4f)
			{
				num += 0.015f;
			}
			else if (weight > 0.4f && weight <= 0.65f)
			{
				num += 0.03f;
			}
			else if (weight > 0.65f)
			{
				num += 0.07f;
			}
			bool flag = false;
			bool flag2 = false;
			if (!(fallDamage <= 0.12f))
			{
				if (Player.Local.Health.CurrentHealth - fallDamage <= 0f)
				{
					FlatlineUIModule.causeOfDeath = "Fall damage";
					flag2 = true;
				}
				if (!flag2 && !FlatlinePlayer.isFPRagdollActive && !Player.Local.IsRagdolled && fallDamage > 20f)
				{
					flag = true;
					Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.FPRagdoll(waitSleepEnd: false, null, 0)));
				}
				Player.Local.Health.TakeDamage(fallDamage, true, false);
				FlatlinePlayer.AppendDamageSource($"Fall damage (-{Mathf.RoundToInt(fallDamage)}HP)");
			}
			if (!(fallDamage <= 0.18f) && Random.Range(0f, 1f) < num)
			{
				if (!flag && !flag2 && !FlatlinePlayer.isFPRagdollActive && !Player.Local.IsRagdolled)
				{
					Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.FPRagdoll(waitSleepEnd: false, null, 0)));
				}
				if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(ConfigLoader.loadedAudios["bonebreak"]);
				}
				if (!flag2)
				{
					AddNewDisease<BoneBreak>(Random.Range(0.01f, 0.3f));
					Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = true;
				}
				DebugModule.Log("Fall damage bone break chance hits", "CalculateFallBoneBreakProbability");
			}
		}

		public static void CalculateImpact(Impact impact)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0017: 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_001d: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = Player.Local.CenterPointTransform.position;
			Vector3 val = impact.HitPoint - position;
			ImpactLocation loc = ((!(val.y <= -0.1f)) ? ((val.y > -0.1f && val.y < 0.24f) ? ImpactLocation.Torso : ImpactLocation.Head) : ImpactLocation.Legs);
			CalculateImpactBleedingProbability(impact, loc);
			CalculateImpactBoneBreakProbability(impact, loc);
		}

		private static void CalculateImpactBleedingProbability(Impact impact, ImpactLocation loc)
		{
			//IL_004d: 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_0069: Expected I4, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.0001f;
			float num2 = 0.002f;
			switch (loc)
			{
			case ImpactLocation.Legs:
				num += 0.03f;
				break;
			case ImpactLocation.Torso:
				num += 0.07f;
				num2 += 0.05f;
				break;
			case ImpactLocation.Head:
				num += 0.05f;
				num2 += 0.08f;
				break;
			}
			EImpactType impactType = impact.ImpactType;
			switch ((int)impactType)
			{
			case 0:
				num *= 0.1f;
				break;
			case 1:
				num += 0.005f;
				break;
			case 2:
				num += 0.23f;
				num2 = ((!(Random.Range(0f, 1f) > 0.5f) || loc != ImpactLocation.Head) ? (num2 + 0.12f) : (num2 + 0.2f));
				break;
			case 3:
				num += 0.33f;
				num2 += 0.2f;
				break;
			}
			num += Flatline.loadedPlayerData.State.healthData.Predisposition * 0.2f;
			DebugModule.Log($"Impact Bleeding probability: {num} - {loc}, {impact.ImpactType}", "CalculateImpactBleedingProbability");
			if (Random.Range(0f, 1f) < num)
			{
				DebugModule.Log("Impact bleeding chance hits", "CalculateImpactBleedingProbability");
				AddNewDisease<Bleeding>(num2);
			}
		}

		private static void CalculateImpactBoneBreakProbability(Impact impact, ImpactLocation loc)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected I4, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.0001f;
			switch (loc)
			{
			case ImpactLocation.Legs:
				num += 0.005f;
				break;
			case ImpactLocation.Torso:
				num += 0.012f;
				break;
			case ImpactLocation.Head:
				num += 0.009f;
				break;
			}
			EImpactType impactType = impact.ImpactType;
			switch ((int)impactType)
			{
			case 0:
				num += 0.0002f;
				break;
			case 1:
				num += 0.22f;
				break;
			case 2:
				num += 0.05f;
				break;
			case 3:
				num += 0.12f;
				break;
			case 4:
				num += 0.08f;
				break;
			}
			num += Flatline.loadedPlayerData.State.healthData.Predisposition * 0.2f;
			DebugModule.Log($"Impact Bone break probability: {num} - {loc}, {impact.ImpactType}", "CalculateImpactBoneBreakProbability");
			if (Random.Range(0f, 1f) < num)
			{
				if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(ConfigLoader.loadedAudios["bonebreak"]);
				}
				AddNewDisease<BoneBreak>(Random.Range(0.001f, 0.15f));
				if (loc == ImpactLocation.Legs)
				{
					Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = true;
				}
				DebugModule.Log("Impact Bone break chance hits", "CalculateImpactBoneBreakProbability");
			}
		}

		public static void CalculateFeverProbability()
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(2000f, 12000f) / 100000f / 365f / 24f;
			float num2 = Mathf.Lerp(1f, 1.33f, Mathf.Clamp01((float)Flatline.loadedPlayerData.State.healthData.daysSinceFlu / 24f));
			float num3 = Mathf.Lerp(1.08f, 1f, Flatline.loadedPlayerData.State.Temperature);
			float num4 = Mathf.Lerp(1f, 2f, Flatline.loadedPlayerData.State.healthData.Predisposition);
			float num5 = 1f;
			for (int i = 0; i < allDiseases.Count; i++)
			{
				if (allDiseases[i].data.DiseaseID == "cancer" && allDiseases[i].data.Active && allDiseases[i].data.HealState < 1f)
				{
					num5 = Mathf.Lerp(1f, 5f, Mathf.Clamp01((float)allDiseases[i].data.Progression));
				}
			}
			float num6 = 1f;
			if (Singleton<SewerCameraPresense>.Instance.IsPointInSewerArea(Player.Local.CenterPointTransform.position))
			{
				num6 = Random.Range(1.1f, 1.3f);
			}
			num = num * num2 * num3 * num4 * num5 * num6;
			DebugModule.Log("Fever eval chance: " + num, "CalculateFeverProbability");
			if (Random.Range(0f, 1f) < num)
			{
				AddNewDisease<Fever>(Random.Range(0.001f, 0.3f));
				DebugModule.Log("Fever chance hits", "CalculateFeverProbability");
			}
		}

		public static void CalculateCancerProbability()
		{
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			float gender = Player.Local.Avatar.CurrentSettings.Gender;
			float num = NetworkSingleton<TimeManager>.Instance.ElapsedDays;
			if (num < 4f)
			{
				return;
			}
			float num2 = 25f;
			float num3 = 47f;
			float num4 = 36f;
			float num5 = 18f;
			float num6 = 0f;
			if (gender > 0.5f)
			{
				if (num < num5)
				{
					num6 = Mathf.Lerp(0.0001f, 0.08f, num / num5);
				}
				else if (num > num5 && num < num4)
				{
					num6 = Mathf.Lerp(0.08f, 0.01f, num / num4);
				}
				else if (num > num4)
				{
					float num7 = Mathf.Clamp01((num - num4) / 100f);
					num6 = Mathf.Lerp(0.01f, 0.1f, num7);
				}
			}
			else if (num < num2)
			{
				num6 = Mathf.Lerp(0.0001f, 0.03f, num / num3);
			}
			else if (num > num2 && num < num3)
			{
				num6 = Mathf.Lerp(0.03f, 0.07f, num / num3);
			}
			else if (num > num3)
			{
				float num8 = Mathf.Clamp01((num - num3) / 100f);
				num6 = Mathf.Lerp(0.07f, 0.1f, num8);
			}
			float num9 = Random.Range(300f, 900f) / 100000f / 365f;
			float num10 = Mathf.Lerp(1f, 0f, Mathf.Clamp01(Flatline.loadedPlayerData.State.healthData.MaxHP / 100f));
			float predisposition = Flatline.loadedPlayerData.State.healthData.Predisposition;
			float gluttony = Flatline.loadedPlayerData.State.healthData.Gluttony;
			float weight = Player.Local.Avatar.CurrentSettings.Weight;
			int num11 = Random.Range(5, 15);
			int num12 = 30;
			int num13 = 20;
			int num14 = num11 * num12 * num13;
			float num15 = Mathf.Clamp01((float)Flatline.loadedPlayerData.State.healthData.TimesSmoked / (float)num14);
			float num16 = 0f;
			foreach (ConsumptionData value in Flatline.loadedPlayerData.State.consumptionDatas.Values)
			{
				num16 += Mathf.Clamp01(value.overtimeLungDamage + value.overtimeLiverDamage);
			}
			float num17 = 0f;
			if (Singleton<SewerCameraPresense>.Instance.IsPointInSewerArea(Player.Local.CenterPointTransform.position))
			{
				num17 = Random.Range(0.01f, 0.3f);
			}
			float num18 = (num10 + predisposition + gluttony + weight + num15 + num16) / 12f;
			float num19 = (num9 + num17 + num6) / 1.4f;
			float num20 = Mathf.Clamp01((num18 + num19) / 2f);
			if (Random.Range(0f, 1f) < num20)
			{
				DebugModule.Log("Cancer chance hits", "CalculateCancerProbability");
				AddNewDisease<Cancer>(Random.Range(0.001f, 0.29f));
			}
		}
	}
	public static class PlayerFallDamage
	{
		[CompilerGenerated]
		private sealed class <EvaluatePlayerJumpMovement>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <minimumYFrame>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EvaluatePlayerJumpMovement>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<minimumYFrame>5__2 = -8.5f;
					goto IL_0031;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						DebugModule.Log("Exiting registered", "EvaluatePlayerJumpMovement");
						return false;
					}
					if (!Flatline.haltExecution && !PlayerSingleton<PlayerMovement>.Instance.IsGrounded)
					{
						break;
					}
					goto IL_0031;
				case 2:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (PlayerSingleton<PlayerMovement>.Instance.lastFrameMovement.y < <minimumYFrame>5__2)
					{
						float num = 0f - PlayerSingleton<PlayerMovement>.Instance.lastFrameMovement.y;
						if (num > lastHighestFrameY)
						{
							lastHighestFrameY = num;
						}
					}
					break;
				case 3:
					{
						<>1__state = -1;
						lastHighestFrameY = 0f;
						goto IL_0031;
					}
					IL_0031:
					<>2__current = Flatline.Wait01;
					<>1__state = 1;
					return true;
				}
				if (Flatline.registered && !PlayerSingleton<PlayerMovement>.Instance.IsGrounded)
				{
					<>2__current = Flatline.Wait01;
					<>1__state = 2;
					return true;
				}
				float num2 = 119f;
				float num3 = 62f;
				PlayerDiseaseDamage.CalculateFallBoneBreakProbability(Mathf.Lerp(0f, num2, Mathf.Clamp01(lastHighestFrameY / num3)));
				<>2__current = Flatline.Wait05;
				<>1__state = 3;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static float lastHighestFrameY;

		[IteratorStateMachine(typeof(<EvaluatePlayerJumpMovement>d__1))]
		public static IEnumerator EvaluatePlayerJumpMovement()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EvaluatePlayerJumpMovement>d__1(0);
		}
	}
	public static class ConsoleModule
	{
		[Flags]
		public enum CommandSupport
		{
			None = 0,
			Set = 1,
			List = 2,
			Add = 4
		}

		public class MemberTypeException : Exception
		{
			public MemberTypeException()
			{
			}

			public MemberTypeException(string message)
				: base(message)
			{
			}
		}

		public abstract class ConsoleCommandBase
		{
			public virtual string Name { get; }

			public virtual CommandSupport SupportedMethods { get; }

			public virtual void Set(string id, string str, float fVal = -1f, bool bVal = false, string sVal = "")
			{
				DebugModule.Log("Not implemented", "Set");
			}

			public virtual void Execute(List<string> args)
			{
				DebugModule.Log("Not implemented", "Execute");
			}

			public virtual void List()
			{
				DebugModule.Log("Not implemented", "List");
			}

			public virtual void Add(List<string> args)
			{
				DebugModule.Log("Not implemented", "Add");
			}

			public void ArgTypeParse(string id, string str, string val)
			{
				if (val == string.Empty)
				{
					return;
				}
				bool result = false;
				float result2 = -1f;
				try
				{
					if (float.TryParse(val, out result2))
					{
						Set(id, str, result2);
					}
					else if (bool.TryParse(val, out result))
					{
						Set(id, str, -1f, result, val);
					}
					else
					{
						Set(id, str, -1f, bVal: false, val);
					}
				}
				catch (MemberTypeException ex)
				{
					DebugModule.Log("Failed to run command with exception: " + ex.Message, "ArgTypeParse");
				}
			}

			public bool AssertNotDefault(float fVal, bool bVal, string sVal, out Type type)
			{
				if (bool.TryParse(sVal, out var _))
				{
					type = typeof(bool);
					return true;
				}
				if (fVal != -1f)
				{
					type = typeof(float);
					return true;
				}
				if (sVal != "")
				{
					type = typeof(string);
					return true;
				}
				type = null;
				return false;
			}
		}

		public class PlayerTarget : ConsoleCommandBase
		{
			private readonly List<string> supportedMembers = new List<string>
			{
				"thirst", "hunger", "energy", "temperature", "maxhp", "currenthp", "movespeedscale", "predisposition", "gluttony", "timessmoked",
				"islegbonebroken"
			};

			public override string Name => "Player";

			public override CommandSupport SupportedMethods => CommandSupport.Set | CommandSupport.List;

			public override void Execute(List<string> args)
			{
				if (args.Count < 5)
				{
					DebugModule.Log("Usage: flatline set player (member) (value)", "Execute");
				}
				else if (!supportedMembers.Any((string m) => m.Equals(args[3], StringComparison.OrdinalIgnoreCase)))
				{
					DebugModule.Log("Player member: '" + args[3] + "' does not exist!\n    Try: 'flatline list player' for supported values", "Execute");
				}
				else
				{
					ArgTypeParse("", args[3], args[4]);
				}
			}

			public override void Set(string id, string str, float fVal = -1f, bool bVal = false, string sVal = "")
			{
				if (!AssertNotDefault(fVal, bVal, sVal, out var type))
				{
					return;
				}
				switch (str.ToLower())
				{
				case "thirst":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for thirst");
					}
					FlatlinePlayer.SetWater(Mathf.Clamp01(fVal));
					break;
				case "hunger":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for hunger");
					}
					FlatlinePlayer.SetFood(Mathf.Clamp01(fVal));
					break;
				case "energy":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for energy");
					}
					FlatlinePlayer.SetEnergy(Mathf.Clamp01(fVal));
					break;
				case "temperature":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for temperature");
					}
					FlatlinePlayer.SetTemperature(Mathf.Clamp01(fVal));
					break;
				case "maxhp":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for max hp");
					}
					Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(fVal, 0f, 100f);
					break;
				case "currenthp":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for current hp");
					}
					Flatline.loadedPlayerData.State.healthData.CurrentHP = Mathf.Clamp(fVal, 0f, 100f);
					break;
				case "movespeedscale":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for move speed scale");
					}
					Flatline.loadedPlayerData.State.healthData.MoveSpeedScale = Mathf.Clamp(fVal, 0.1f, 3f);
					break;
				case "predisposition":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for predisposition");
					}
					Flatline.loadedPlayerData.State.healthData.Predisposition = Mathf.Clamp01(fVal);
					break;
				case "gluttony":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for gluttony");
					}
					Flatline.loadedPlayerData.State.healthData.Gluttony = Mathf.Clamp01(fVal);
					break;
				case "timessmoked":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for times smoked");
					}
					Flatline.loadedPlayerData.State.healthData.TimesSmoked = Mathf.Clamp((int)fVal, 0, int.MaxValue);
					break;
				case "islegbonebroken":
					if (type != typeof(bool))
					{
						throw new MemberTypeException("Invalid member value type for is leg bone broken");
					}
					Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = bVal;
					break;
				}
				DebugModule.Log("Player state set", "Set");
			}

			public override void List()
			{
				DebugModule.Log(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat("" + "\nMember name: Member value", $"\n thirst: {Flatline.loadedPlayerData.State.Thirst}"), $"\n energy: {Flatline.loadedPlayerData.State.Energy}"), $"\n temperature: {Flatline.loadedPlayerData.State.Temperature}"), $"\n maxhp: {Flatline.loadedPlayerData.State.healthData.MaxHP}"), $"\n currenthp: {Flatline.loadedPlayerData.State.healthData.CurrentHP}"), $"\n movespeedscale: {Flatline.loadedPlayerData.State.healthData.MoveSpeedScale}"), $"\n predisposition: {Flatline.loadedPlayerData.State.healthData.Predisposition}"), $"\n gluttony: {Flatline.loadedPlayerData.State.healthData.Gluttony}"), $"\n timesSmoked: {Flatline.loadedPlayerData.State.healthData.TimesSmoked}"), $"\n isLegBoneBroken: {Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken}"), "\n\nMoving values per minute:"), $"\n Thirst consumption: {FlatlinePlayer.ThirstConsumptionPerMinute} (delta: {FlatlinePlayer.ThirstConsumptionPerMinute - FlatlinePlayer.DefaultThirstConsumption})"), $"\n Food consumption: {FlatlinePlayer.FoodConsumptionPerMinute} (delta: {FlatlinePlayer.FoodConsumptionPerMinute - FlatlinePlayer.DefaultFoodConsumption})"), $"\n Energy consumption: {FlatlinePlayer.EnergyConsumptionPerMinute} (delta: {FlatlinePlayer.EnergyConsumptionPerMinute - FlatlinePlayer.DefaultEnergyConsumption})"), $"\n Temperature consumption: {FlatlinePlayer.TemperatureConsumption} (delta: {FlatlinePlayer.TemperatureConsumption - FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff})"), $"\n HP Regen: {FlatlinePlayer.HealthRegenPerMinute} (delta: {FlatlinePlayer.HealthRegenPerMinute - FlatlinePlayer.DefaultHealthRegeneration})"), $"\n Sprint Regen: {FlatlinePlayer.sprintReserveRegenPerMinute} (delta: {FlatlinePlayer.sprintReserveRegenPerMinute - FlatlinePlayer.DefaultSprintReserveRegenPerMinute})"), "List");
			}
		}

		public class DiseaseTarget : ConsoleCommandBase
		{
			private readonly List<string> supportedMembers = new List<string> { "active", "progression", "healstate", "minssincediseasestart", "severity" };

			public override string Name => "Disease";

			public override CommandSupport SupportedMethods => CommandSupport.Set | CommandSupport.List | CommandSupport.Add;

			public override void Execute(List<string> args)
			{
				if (args.Count < 6)
				{
					DebugModule.Log("Usage: flatline set disease (disease ID) (member) (value)", "Execute");
				}
				else if (!PlayerDiseaseDamage.diseaseNames.Contains(args[3].ToLower()))
				{
					DebugModule.Log("Disease with ID: '" + args[3] + "' does not exist!\n    Try: 'flatline list disease' for supported values", "Execute");
				}
				else if (!supportedMembers.Any((string m) => m.Equals(args[4], StringComparison.OrdinalIgnoreCase)))
				{
					DebugModule.Log("Disease member: '" + args[4] + "' does not exist!\n    Try: 'flatline list disease' for supported values", "Execute");
				}
				else
				{
					ArgTypeParse(args[3], args[4], args[5]);
				}
			}

			public override void Set(string id, string str, float fVal = -1f, bool bVal = false, string sVal = "")
			{
				if (!AssertNotDefault(fVal, bVal, sVal, out var type))
				{
					return;
				}
				Disease disease = PlayerDiseaseDamage.allDiseases.Find((Disease x) => x.data.DiseaseID.ToLower() == id.ToLower());
				if (disease == null)
				{
					DebugModule.Log("Failed to find a disease with ID: " + id, "Set");
					return;
				}
				switch (str.ToLower())
				{
				case "active":
					if (type != typeof(bool))
					{
						throw new MemberTypeException("Invalid member value type for active");
					}
					disease.data.Active = bVal;
					break;
				case "progression":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for progression");
					}
					disease.data.Progression = Mathf.Clamp((int)fVal, 1, 5);
					break;
				case "healstate":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for heal state");
					}
					disease.data.HealState = Mathf.Clamp01(fVal);
					break;
				case "minssincediseasestart":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for mins since disease start");
					}
					disease.data.MinsSinceDiseaseStart = Mathf.Clamp((int)fVal, 0, int.MaxValue);
					break;
				case "severity":
					if (type != typeof(float))
					{
						throw new MemberTypeException("Invalid member value type for severity");
					}
					disease.data.Severity = Mathf.Clamp(fVal, 0f, 0.3f);
					break;
				}
				DebugModule.Log("Disease state set", "Set");
			}

			public override void List()
			{
				string text = "";
				text += "\n# SUPPORTED DISEASE ID LIST";
				foreach (string diseaseName in PlayerDiseaseDamage.diseaseNames)
				{
					text = text + "\n  " + diseaseName;
				}
				text += "\n# SUPPORTED MEMBER NAMES";
				foreach (string supportedMember in supportedMembers)
				{
					text = text + "\n  " + supportedMember;
				}
				text += "\n# ACTIVE DISEASES";
				foreach (Disease allDisease in PlayerDiseaseDamage.allDiseases)
				{
					text = text + "\nDiseaseID: " + allDisease.data.DiseaseID;
					text += $"\n  active: {allDisease.data.Active}";
					text += $"\n  progression: {allDisease.data.Progression}";
					text += $"\n  healstate: {allDisease.data.HealState}";
					text += $"\n  minssincediseasestart: {allDisease.data.MinsSinceDiseaseStart}";
					text += $"\n  severity: {allDisease.data.Severity}";
				}
				DebugModule.Log(text, "List");
			}

			public override void Add(List<string> args)
			{
				if (args.Count != 4)
				{
					DebugModule.Log("Usage: flatline add disease (disease ID)", "Add");
					return;
				}
				if (!PlayerDiseaseDamage.diseaseNames.Contains(args[3].ToLower()))
				{
					DebugModule.Log("Disease with ID: '" + args[3] + "' does not exist!\n    Try: 'flatline list disease' for supported values", "Add");
					return;
				}
				switch (args[3])
				{
				case "cancer":
					PlayerDiseaseDamage.AddNewDisease<Cancer>(0.01f);
					break;
				case "fever":
					PlayerDiseaseDamage.AddNewDisease<Fever>(0.01f);
					break;
				case "bonebreak":
					PlayerDiseaseDamage.AddNewDisease<BoneBreak>(0.01f);
					break;
				case "bleed":
					PlayerDiseaseDamage.AddNewDisease<Bleeding>(0.3f);
					break;
				case "depression":
					PlayerDiseaseDamage.AddNewDisease<Depression>(0.01f);
					break;
				}
			}
		}

		public class ConsumptionTarget : ConsoleCommandBase
		{
			public override string Name => "Consumption";

			public override CommandSupport SupportedMethods => CommandSupport.List;

			public override void Execute(List<string> args)
			{
				DebugModule.Log("Not implemented", "Execute");
			}

			public override void Set(string id, string str, float fVal = -1f, bool bVal = false, string sVal = "")
			{
				DebugModule.Log("Not implemented", "Set");
			}

			public override void List()
			{
				string text = "";
				text += "\n# CONSUMED ITEMS";
				foreach (KeyValuePair<string, ConsumptionData> consumptionData in Flatline.loadedPlayerData.State.consumptionDatas)
				{
					text = text + "\n" + consumptionData.Key + ":";
					text += $"\n  Currently in system: {consumptionData.Value.currentAmountInSystem}";
					text += $"\n  Lung Damage: {consumptionData.Value.overtimeLungDamage}";
					text += $"\n  Liver Damage: {consumptionData.Value.overtimeLiverDamage}";
				}
				DebugModule.Log(text, "List");
			}
		}

		public static bool isLoggingEnabled = false;

		public static readonly HashSet<string> ConsoleMethodNames = new HashSet<string> { "Help", "Set", "List", "Execute", "Add" };
	}
	public static class DebugModule
	{
		public static Dictionary<string, ConsoleModule.ConsoleCommandBase> consoleTargets = new Dictionary<string, ConsoleModule.ConsoleCommandBase>
		{
			{
				"player",
				new ConsoleModule.PlayerTarget()
			},
			{
				"disease",
				new ConsoleModule.DiseaseTarget()
			},
			{
				"consumption",
				new ConsoleModule.ConsumptionTarget()
			}
		};

		public static void Log(string msg, [CallerMemberName] string memberName = "")
		{
			if (ConsoleModule.isLoggingEnabled || ConsoleModule.ConsoleMethodNames.Contains(memberName))
			{
				MelonLogger.Msg("[" + memberName + "] " + msg);
			}
		}

		public static void RunCommand(List<string> args)
		{
			if (args.Count == 2)
			{
				if (args[1].ToLower() == "help")
				{
					Help();
				}
				else if (args[1].ToLower() == "start")
				{
					Flatline.haltExecution = false;
				}
				else if (args[1].ToLower() == "stop")
				{
					Flatline.haltExecution = true;
				}
				else
				{
					Log("Usage: flatline (action) (method)\n    Try: flatline help", "RunCommand");
				}
				return;
			}
			if (args.Count == 3 && args[1].ToLower() == "enable" && args[2].ToLower() == "logs")
			{
				ConsoleModule.isLoggingEnabled = true;
				return;
			}
			if (args.Count < 3)
			{
				Log("Usage: flatline (action) (method)\n    Try: flatline help", "RunCommand");
				return;
			}
			string text = args[1].ToLower();
			string text2 = args[2].ToLower();
			if (!consoleTargets.TryGetValue(text2, out var value))
			{
				Log("Unknown command target '" + text2 + "'", "RunCommand");
				return;
			}
			ConsoleModule.CommandSupport commandSupport = text switch
			{
				"set" => ConsoleModule.CommandSupport.Set, 
				"list" => ConsoleModule.CommandSupport.List, 
				"add" => ConsoleModule.CommandSupport.Add, 
				_ => ConsoleModule.CommandSupport.None, 
			};
			if ((value.SupportedMethods & commandSupport) == 0)
			{
				Log($"Command target '{text2}' does not support requested method '{commandSupport}'", "RunCommand");
				return;
			}
			switch (commandSupport)
			{
			case ConsoleModule.CommandSupport.Set:
				value.Execute(args);
				break;
			case ConsoleModule.CommandSupport.List:
				value.List();
				break;
			case ConsoleModule.CommandSupport.Add:
				value.Add(args);
				break;
			case ConsoleModule.CommandSupport.Set | ConsoleModule.CommandSupport.List:
				break;
			}
		}

		public static void Help()
		{
			string text = "";
			text += "\nSupported Commands:";
			text += "\n\n# ENABLE FULL LOGGING";
			text += "\nflatline enable logs";
			text += "\n\n# START OR STOP UPDATING THE MOD EVENTS";
			text += "\nflatline start";
			text += "\nflatline stop";
			foreach (ConsoleModule.ConsoleCommandBase value in consoleTargets.Values)
			{
				text = text + "\n\n# " + value.Name.ToUpper();
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.Set))
				{
					text = ((!value.Name.ToLower().Contains("disease")) ? (text + "\nflatline set " + value.Name + " (member) (member value)") : (text + "\nflatline set " + value.Name + " (disease ID) (member) (member value)"));
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.List))
				{
					text = text + "\nflatline list " + value.Name;
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.Add) && value.Name.ToLower().Contains("disease"))
				{
					text = text + "\nflatline add " + value.Name + " (disease ID)";
				}
			}
			Log(text, "Help");
		}
	}
	[HarmonyPatch(typeof(Console), "SubmitCommand", new Type[] { typeof(List<string>) })]
	public static class Console_SubmitCommand_ListString_Patch
	{
		public static bool Prefix(Console __instance, List<string> args)
		{
			if (args.Count == 0)
			{
				return true;
			}
			if (args[0].ToLower() == "flatline")
			{
				DebugModule.RunCommand(args);
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Console), "SubmitCommand", new Type[] { typeof(string) })]
	public static class Console_SubmitCommand_String_Patch
	{
		public static bool Prefix(Console __instance, string args)
		{
			return true;
		}
	}
	public static class BuildInfo
	{
		public const string Name = "Flatline";

		public const string Description = "";

		public const string Author = "XOWithSauce";

		public const string Company = null;

		public const string Version = "1.0.1";

		public const string DownloadLink = "https://github.com/XOWithSauce/schedule-flatline";
	}
	public class Flatline : MelonMod
	{
		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
		public static class SaveManager_Save_String_Patch
		{
			public static bool Prefix(SaveManager __instance, string saveFolderPath)
			{
				if (!isSaving)
				{
					isSaving = true;
					PlayerDiseaseDamage.UpdateDiseaseData();
					ConfigLoader.Save(loadedPlayerData);
				}
				isSaving = false;
				return true;
			}
		}

		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { })]
		public static class SaveManager_Save_Patch
		{
			public static bool Prefix(SaveManager __instance)
			{
				return true;
			}
		}

		[HarmonyPatch(typeof(LoadManager), "ExitToMenu")]
		public static class LoadManager_ExitToMenu_Patch
		{
			public static bool Prefix(LoadManager __instance, SaveInfo autoLoadSave = null, Data mainMenuPopup = null, bool preventLeaveLobby = false)
			{
				ExitPreTask();
				return true;
			}
		}

		[HarmonyPatch(typeof(DeathScreen), "LoadSaveClicked")]
		public static class DeathScreen_LoadSaveClicked_Patch
		{
			public static bool Prefix(DeathScreen __instance)
			{
				ExitPreTask();
				return true;
			}
		}

		[HarmonyPatch(typeof(DeathScreen), "Open")]
		public static class DeathScreen_Open_Patch
		{
			[HarmonyPostfix]
			public static void Postfix(DeathScreen __instance)
			{
				if (currentConfig == null || !registered)
				{
					return;
				}
				if (!currentConfig.PermanentDeath)
				{
					((Component)FlatlineUIModule.CustomButton).gameObject.SetActive(false);
				}
				else if (currentConfig.PermanentDeath)
				{
					if (((Component)__instance.respawnButton).gameObject.activeSelf)
					{
						((Component)__instance.respawnButton).gameObject.SetActive(false);
					}
					if (((Component)__instance.loadSaveButton).gameObject.activeSelf)
					{
						((Component)__instance.loadSaveButton).gameObject.SetActive(false);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <Setup>d__48 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Setup>d__48(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					WaitUntil val2 = new WaitUntil((Func<bool>)(() => Singleton<LoadManager>.Instance.IsGameLoaded));
					<>2__current = val2;
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					WaitUntil val = new WaitUntil((Func<bool>)(() => NetworkSingleton<TimeManager>.InstanceExists));
					<>2__current = val;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					DebugModule.Log("Starting Setup", "Setup");
					loadedPlayerData = ConfigLoader.LoadPlayerData();
					FlatlineUIModule.InitiateSurvivalSliders();
					FlatlineUIModule.InitiateDiseasesHolder();
					<>2__current = MelonCoroutines.Start(FlatlineUIModule.InitiateWorldTemperatureText());
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					FlatlineUIModule.InitiateDeathScreen();
					DepressionSimulator.InitiateDepressionSimulatorModule();
					<>2__current = MelonCoroutines.Start(FlatlineIngestibles.InitiateIngestibleModule());
					<>1__state = 4;
					return true;
				case 4:
				{
					<>1__state = -1;
					FlatlinePlayer.InitFlatlinePlayer();
					PlayerDiseaseDamage.InitPlayerDiseaseDamage();
					PlayerConsumeDamage.InitConsumeDamageModule();
					HospitalHealing.InitHospitalHealing();
					Player_ConsumeProduct_Patch.AssignPseudoProductIDs();
					PropertyTemperatureController.InitPropertyTemperatureController();
					PlayerDiseaseDamage.ApplyLoadedDiseases();
					coros.Add(MelonCoroutines.Start(FlatlinePlayer.UpdateSliderState()));
					coros.Add(MelonCoroutines.Start(FlatlinePlayer.WhileSprinting()));
					coros.Add(MelonCoroutines.Start(PlayerFallDamage.EvaluatePlayerJumpMovement()));
					coros.Add(MelonCoroutines.Start(FlatlinePlayer.EnsureSystematicHomeostasis()));
					coros.Add(MelonCoroutines.Start(FlatlineUIModule.UpdateDiseasesHolder()));
					coros.Add(MelonCoroutines.Start(FlatlinePlayer.LazyUpdatePlayerWarmBuilding()));
					coros.Add(MelonCoroutines.Start(PropertyTemperatureController.UpdateAllPropertyTemperatures()));
					TimeManager instance = NetworkSingleton<TimeManager>.Instance;
					Action action = FlatlinePlayer.OnMinPass;
					Action action2 = BedRotSimulator.MinPassBedrotting;
					instance.onMinutePass.Add(action);
					instance.onMinutePass.Add(action2);
					instance.onHourPass = (Action)Delegate.Combine(instance.onHourPass, new Action(FlatlinePlayer.OnHourPass));
					instance.onHourPass = (Action)Delegate.Combine(instance.onHourPass, new Action(PlayerConsumeDamage.OnHourPass));
					instance.onHourPass = (Action)Delegate.Combine(instance.onHourPass, new Action(PlayerDiseaseDamage.OnHourPass));
					instance.onSleepEnd = (Action)Delegate.Combine(instance.onSleepEnd, new Action(PlayerDiseaseDamage.OnSleepEnd));
					instance.onSleepEnd = (Action)Delegate.Combine(instance.onSleepEnd, new Action(FlatlinePlayer.OnSleepEnd));
					setupCompleted = true;
					DebugModule.Log("Setup finished", "Setup");
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static FlatlinePlayerData loadedPlayerData;

		public static FlatlineModConfig currentConfig;

		public static List<object> coros = new List<object>();

		public static bool registered = false;

		private bool firstTimeLoad;

		public static bool isSaving = false;

		public static bool haltExecution = false;

		public static bool setupCompleted = false;

		public static readonly WaitForEndOfFrame WaitFrame = new WaitForEndOfFrame();

		public static readonly WaitForSeconds Wait01 = new WaitForSeconds(0.1f);

		public static readonly WaitForSeconds Wait025 = new WaitForSeconds(0.25f);

		public static readonly WaitForSeconds Wait05 = new WaitForSeconds(0.5f);

		public static readonly WaitForSeconds Wait1 = new WaitForSeconds(1f);

		public static readonly WaitForSeconds Wait2 = new WaitForSeconds(2f);

		public static readonly WaitForSeconds Wait5 = new WaitForSeconds(5f);

		public static readonly WaitForSeconds Wait10 = new WaitForSeconds(10f);

		public static readonly WaitForSeconds Wait30 = new WaitForSeconds(30f);

		public static readonly WaitForSeconds Wait60 = new WaitForSeconds(60f);

		private MelonPreferences_Category category;

		private MelonPreferences_Entry<bool> PermanentDeath;

		private MelonPreferences_Entry<bool> DrugSideEffects;

		private MelonPreferences_Entry<bool> PropertyTemperatureChanges;

		private MelonPreferences_Entry<bool> WorldTemperatureChanges;

		private MelonPreferences_Entry<bool> FahrenheitTemp;

		private MelonPreferences_Entry<bool> DiseasesEnabled;

		private MelonPreferences_Entry<bool> BleedingEnabled;

		private MelonPreferences_Entry<bool> BoneBreakEnabled;

		private MelonPreferences_Entry<bool> CancerEnabled;

		private MelonPreferences_Entry<bool> DepressionEnabled;

		private MelonPreferences_Entry<bool> FeverEnabled;

		private MelonPreferences_Entry<bool> WaterRequired;

		private MelonPreferences_Entry<bool> FoodRequired;

		private MelonPreferences_Entry<bool> EnergyRequired;

		private MelonPreferences_Entry<bool> TemperatureRequired;

		private MelonPreferences_Entry<float> WaterConsumption;

		private MelonPreferences_Entry<float> FoodConsumption;

		private MelonPreferences_Entry<float> EnergyConsumption;

		private MelonPreferences_Entry<float> TemperatureConsumption;

		public static Flatline Instance { get; private set; }

		public override void OnPreferencesSaved()
		{
			currentConfig.PermanentDeath = PermanentDeath.Value;
			currentConfig.DrugSideEffects = DrugSideEffects.Value;
			currentConfig.PropertyTemperatureChanges = PropertyTemperatureChanges.Value;
			currentConfig.WorldTemperatureChanges = WorldTemperatureChanges.Value;
			currentConfig.FahrenheitTemp = FahrenheitTemp.Value;
			currentConfig.DiseasesEnabled = DiseasesEnabled.Value;
			currentConfig.BleedingEnabled = BleedingEnabled.Value;
			currentConfig.BoneBreakEnabled = BoneBreakEnabled.Value;
			currentConfig.CancerEnabled = CancerEnabled.Value;
			currentConfig.DepressionEnabled = DepressionEnabled.Value;
			currentConfig.FeverEnabled = FeverEnabled.Value;
			currentConfig.WaterRequired = WaterRequired.Value;
			currentConfig.FoodRequired = FoodRequired.Value;
			currentConfig.EnergyRequired = EnergyRequired.Value;
			currentConfig.TemperatureRequired = TemperatureRequired.Value;
			FlatlinePlayer.DefaultThirstConsumption = WaterConsumption.Value;
			FlatlinePlayer.DefaultFoodConsumption = FoodConsumption.Value;
			FlatlinePlayer.DefaultEnergyConsumption = EnergyConsumption.Value;
			FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff = TemperatureConsumption.Value;
		}

		private void SetupMelonPreferences()
		{
			category = MelonPreferences.CreateCategory("Flatline_XOWithSauce", "Flatline");
			PermanentDeath = category.CreateEntry<bool>("PermanentDeath", true, "PermanentDeath", "Permanent Death Enabled", false, false, (ValueValidator)null, (string)null);
			DrugSideEffects = category.CreateEntry<bool>("DrugSideEffects", true, "DrugSideEffects", "Enables overdosing on drugs and medicine and adds effects to drugs", false, false, (ValueValidator)null, (string)null);
			PropertyTemperatureChanges = category.CreateEntry<bool>("PropertyTemperatureChanges", true, "PropertyTemperatureChanges", "Properties get cold if door is kept open and outside is colder", false, false, (ValueValidator)null, (string)null);
			WorldTemperatureChanges = category.CreateEntry<bool>("WorldTemperatureChanges", true, "WorldTemperatureChanges", "World temperature changes based on time and weather", false, false, (ValueValidator)null, (string)null);
			FahrenheitTemp = category.CreateEntry<bool>("FahrenheitTemp", false, "FahrenheitTemp", "Display Temperatures as Fahrenheit", false, false, (ValueValidator)null, (string)null);
			DiseasesEnabled = category.CreateEntry<bool>("DiseasesEnabled", true, "DiseasesEnabled", "Enables all diseases", false, false, (ValueValidator)null, (string)null);
			BleedingEnabled = category.CreateEntry<bool>("BleedingEnabled", true, "BleedingEnabled", "Enable Bleeding disease", false, false, (ValueValidator)null, (string)null);
			BoneBreakEnabled = category.CreateEntry<bool>("BoneBreakEnabled", true, "BoneBreakEnabled", "Enable Bone Break disease", false, false, (ValueValidator)null, (string)null);
			CancerEnabled = category.CreateEntry<bool>("CancerEnabled", true, "CancerEnabled", "Enable Cancer disease", false, false, (ValueValidator)null, (string)null);
			DepressionEnabled = category.CreateEntry<bool>("DepressionEnabled", true, "DepressionEnabled", "Enable Depression disease", false, false, (ValueValidator)null, (string)null);
			FeverEnabled = category.CreateEntry<bool>("FeverEnabled", true, "FeverEnabled", "Enable Fever disease", false, false, (ValueValidator)null, (string)null);
			WaterRequired = category.CreateEntry<bool>("WaterRequired", true, "WaterRequired", "Player needs to drink to survive", false, false, (ValueValidator)null, (string)null);
			FoodRequired = category.CreateEntry<bool>("FoodRequired", true, "FoodRequired", "Player needs to eat to survive", false, false, (ValueValidator)null, (string)null);
			EnergyRequired = category.CreateEntry<bool>("EnergyRequired", true, "EnergyRequired", "Player needs to rest and manage energy", false, false, (ValueValidator)null, (string)null);
			TemperatureRequired = category.CreateEntry<bool>("TemperatureRequired", true, "TemperatureRequired", "Player needs to stay warm to survive", false, false, (ValueValidator)null, (string)null);
			WaterConsumption = category.CreateEntry<float>("WaterConsumption", 0.00087958f, "WaterConsumption", "Amount of water consumed per minute", false, false, (ValueValidator)null, (string)null);
			FoodConsumption = category.CreateEntry<float>("FoodConsumption", 0.0015f, "FoodConsumption", "Amount of food consumed per minute", false, false, (ValueValidator)null, (string)null);
			EnergyConsumption = category.CreateEntry<float>("EnergyConsumption", 0.0007f, "EnergyConsumption", "Amount of energy consumed per minute", false, false, (ValueValidator)null, (string)null);
			TemperatureConsumption = category.CreateEntry<float>("TemperatureConsumption", 0.00022f, "TemperatureConsumption", "Amount of temperature lost per each degree difference", false, false, (ValueValidator)null, (string)null);
			DebugModule.Log("Diseases enabled: " + DiseasesEnabled.Value, "SetupMelonPreferences");
			DebugModule.Log("In config: " + currentConfig.DiseasesEnabled, "SetupMelonPreferences");
			((MelonBase)this).OnPreferencesSaved();
			MelonPreferences.Save();
		}

		public override void OnInitializeMelon()
		{
			((MelonBase)this).OnInitializeMelon();
			Instance = this;
			currentConfig = new FlatlineModConfig();
			SetupMelonPreferences();
			DebugModule.Log("Diseases enabled: " + DiseasesEnabled.Value, "OnInitializeMelon");
			DebugModule.Log("In config: " + currentConfig.DiseasesEnabled, "OnInitializeMelon");
			ConfigLoader.LoadModResources();
			MelonCoroutines.Start(BedRotSimulator.InitBedRotModule());
			MelonLogger.Msg("Flatline Mod Loaded");
		}

		public override void OnUpdate()
		{
			if (registered && !isSaving && !haltExecution)
			{
				FlatlineIngestibles.UpdateConsumption();
			}
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (buildIndex == 1 && (Object)(object)Singleton<LoadManager>.Instance != (Object)null && !registered && !firstTimeLoad)
			{
				firstTimeLoad = true;
				Singleton<LoadManager>.Instance.onLoadComplete.AddListener(new UnityAction(OnLoadCompleteCb));
			}
			if (buildIndex != 1 && registered)
			{
				ExitPreTask();
			}
		}

		private void OnLoadCompleteCb()
		{
			if (!registered)
			{
				registered = true;
				MelonCoroutines.Start(Setup());
			}
		}

		[IteratorStateMachine(typeof(<Setup>d__48))]
		public static IEnumerator Setup()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Setup>d__48(0);
		}

		private static void ExitPreTask()
		{
			registered = false;
			foreach (object coro in coros)
			{
				try
				{
					if (coro != null)
					{
						MelonCoroutines.Stop(coro);
					}
				}
				catch (Exception ex)
				{
					DebugModule.Log("Something failed while stopping coroutines: " + ex, "ExitPreTask");
				}
			}
			coros.Clear();
			if (PlayerDiseaseDamage.allDiseases.Count > 0)
			{
				foreach (Disease allDisease in PlayerDiseaseDamage.allDiseases)
				{
					try
					{
						if (allDisease.diseaseCoroutine != null)
						{
							MelonCoroutines.Stop(allDisease.diseaseCoroutine);
						}
					}
					catch (Exception ex2)
					{
						DebugModule.Log("Something failed while stopping coroutines: " + ex2, "ExitPreTask");
					}
				}
				PlayerDiseaseDamage.allDiseases.Clear();
			}
			FlatlineUIModule.ResetFlatlineUIModule();
			FlatlinePlayer.ResetFlatlinePlayer();
			FlatlineIngestibles.ResetIngestibleModule();
			PlayerConsumeDamage.ResetConsumeDamageModule();
			BedRotSimulator.ResetBedRotModule();
			HospitalHealing.ResetHospitalHealing();
			DepressionSimulator.ResetDepressionSimulatorModule();
			PlayerDiseaseDamage.ResetPlayerDiseaseDamage();
			PropertyTemperatureController.ResetPropertyTemperatureController();
			PlayerFallDamage.lastHighestFrameY = 0f;
			isSaving = false;
			loadedPlayerData = null;
			setupCompleted = false;
		}
	}
	public static class HospitalHealing
	{
		[CompilerGenerated]
		private sealed class <OnCureChoiceChoosen>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DialogueController controller;

			public string diseaseID;

			public DialogueChoice choice;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnCureChoiceChoosen>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					controller.handler.ContinueSubmitted();
					<>2__current = Flatline.Wait05;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (Vector3.Distance(controller.npc.CenterPoint, hospitalDoorPoint) > 7f)
					{
						controller.handler.WorldspaceRend.ShowText("I'm off duty. Ask for the charge nurse at the hospital.", 10f);
						controller.npc.PlayVO((EVOLineType)9, false);
						return false;
					}
					Disease disease = null;
					foreach (Disease allDisease in PlayerDiseaseDamage.allDiseases)
					{
						if (string.Equals(allDisease.data.DiseaseID, diseaseID) && allDisease.data.Active)
						{
							disease = allDisease;
							break;
						}
					}
					if (disease == null)
					{
						DebugModule.Log("Failed to find the target disease", "OnCureChoiceChoosen");
					}
					bool flag = true;
					float num = cureCosts[diseaseID];
					float cashBalance = NetworkSingleton<MoneyManager>.Instance.cashBalance;
					float onlineBalance = NetworkSingleton<MoneyManager>.Instance.onlineBalance;
					if (cashBalance + onlineBalance < num)
					{
						flag = false;
					}
					if (!flag)
					{
						controller.handler.WorldspaceRend.ShowText("Sorry, but you can't afford the treatment.", 10f);
						controller.npc.PlayVO((EVOLineType)17, false);
						return false;
					}
					if (disease.data.DiseaseID == "cancer" && disease.data.Progression >= 4)
					{
						controller.handler.WorldspaceRend.ShowText("Sorry, but your cancer is terminal...", 10f);
						controller.npc.PlayVO((EVOLineType)5, false);
						return false;
					}
					bool flag2 = false;
					bool flag3 = false;
					float num2 = 0f;
					if (cashBalance >= num)
					{
						flag2 = true;
					}
					else
					{
						flag2 = true;
						flag3 = true;
						num2 = num - cashBalance;
					}
					if (flag2 && flag3)
					{
						NetworkSingleton<MoneyManager>.Instance.ChangeCashBalance(0f - cashBalance, true, false);
						NetworkSingleton<MoneyManager>.Instance.CreateOnlineTransaction("Removed online balance", 0f - num2, 1f, "Flatline mod medical fee");
					}
					else
					{
						NetworkSingleton<MoneyManager>.Instance.ChangeCashBalance(0f - num, true, false);
					}
					disease.data.HealState = 1f;
					DebugModule.Log("Disease cured: " + diseaseID, "OnCureChoiceChoosen");
					controller.handler.WorldspaceRend.ShowText("You're all patched up!", 5f);
					controller.npc.PlayVO((EVOLineType)3, false);
					choice.Enabled = false;
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static Lisa lisaNPC;

		public static Irene ireneNPC;

		public static Dictionary<string, DialogueChoice> lisaCureChoices = new Dictionary<string, DialogueChoice>();

		public static Dictionary<string, DialogueChoice> ireneCureChoices = new Dictionary<string, DialogueChoice>();

		public static bool hospitalChoiceInitialized = false;

		public static Vector3 hospitalDoorPoint;

		public static readonly Dictionary<string, float> cureCosts = new Dictionary<string, float>
		{
			{ "cancer", 80000f },
			{ "bonebreak", 18000f },
			{ "bleed", 30000f },
			{ "fever", 8000f },
			{ "depression", 4000f }
		};

		public static void InitHospitalHealing()
		{
			//IL_004f: 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)
			lisaNPC = Object.FindObjectOfType<Lisa>(true);
			ireneNPC = Object.FindObjectOfType<Irene>(true);
			if ((Object)(object)lisaNPC == (Object)null || (Object)(object)ireneNPC == (Object)null)
			{
				DebugModule.Log("Failed to init hospital healing module", "InitHospitalHealing");
				return;
			}
			hospitalDoorPoint = Singleton<Map>.Instance.MedicalCentre.RespawnPoint.position;
			foreach (KeyValuePair<string, float> cureCost in cureCosts)
			{
				DialogueChoice value = AddDiseaseCureChoice((NPC)(object)lisaNPC, cureCost.Key);
				lisaCureChoices.Add(cureCost.Key, value);
				DialogueChoice value2 = AddDiseaseCureChoice((NPC)(object)ireneNPC, cureCost.Key);
				ireneCureChoices.Add(cureCost.Key, value2);
			}
			hospitalChoiceInitialized = true;
		}

		public static void ResetHospitalHealing()
		{
			hospitalChoiceInitialized = false;
			lisaNPC = null;
			ireneNPC = null;
			lisaCureChoices.Clear();
			ireneCureChoices.Clear();
		}

		public static DialogueChoice AddDiseaseCureChoice(NPC npc, string diseaseID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			DialogueController controller = ((Component)npc.DialogueHandler).gameObject.GetComponent<DialogueController>();
			DialogueChoice choice = new DialogueChoice();
			choice.ChoiceText = $"Cure {diseaseID} <color=#FF3008>-${cureCosts[diseaseID]}</color>";
			choice.Enabled = false;
			choice.onChoosen.AddListener(new UnityAction(OnCureChoosen));
			controller.AddDialogueChoice(choice, 0);
			return choice;
			void OnCureChoosen()
			{
				Flatline.coros.Add(MelonCoroutines.Start(OnCureChoiceChoosen(controller, choice, diseaseID)));
			}
		}

		[IteratorStateMachine(typeof(<OnCureChoiceChoosen>d__10))]
		public static IEnumerator OnCureChoiceChoosen(DialogueController controller, DialogueChoice choice, string diseaseID)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCureChoiceChoosen>d__10(0)
			{
				controller = controller,
				choice = choice,
				diseaseID = diseaseID
			};
		}
	}
	public class IngestibleAddy : Ingestible
	{
		public static readonly float SystemicAmountPerDose = 0.22f;

		public override string ItemID => "addy";

		public override float Food => 0f;

		public override float Energy => 0.18f;

		public override float Thirst => 0f;

		public override float HPRegen => 1f;

		public override bool increaseSanity => true;

		public override float toxicityInDose => SystemicAmountPerDose;
	}
	public class IngestibleBanana : Ingestible
	{
		public override string ItemID => "banana";

		public override float Food => 0.18f;

		public override float Energy => 0.015f;

		public override float Thirst => 0f;

		public override float HPRegen => 2f;
	}
	public class IngestibleBean : Ingestible
	{
		public override string ItemID => "megabean";

		public override float Food => 0.08f;

		public override float Energy => 0.1f;

		public override float Thirst => 0f;

		public override float HPRegen => 3f;
	}
	public class IngestibleChili : Ingestible
	{
		public static readonly float SystemicAmountPerDose = 0.05f;

		public override string ItemID => "chili";

		public override float Food => 0.05f;

		public override float Energy => 0.03f;

		public override float Thirst => 0f;

		public override float HPRegen => 5f;

		public override float toxicityInDose => SystemicAmountPerDose;
	}
	public class IngestibleCuke : Ingestible
	{
		public override string ItemID => "cuke";

		public override float Food => 0f;

		public override float Energy => 0.015f;

		public override float Thirst => 0.14f;

		public override float HPRegen => 3f;
	}
	public class IngestibleDonut : Ingestible
	{
		public override string ItemID => "donut";

		public override float Food => 0.15f;

		public override float Energy => 0.02f;

		public override float Thirst => 0f;

		public override float HPRegen => 1f;
	}
	public class IngestibleEnergyDrink : Ingestible
	{
		public override string ItemID => "energydrink";

		public override float Food => 0f;

		public override float Energy => 0.05f;

		public override float Thirst => 0.1f;

		public override float HPRegen => 1f;

		public override bool increaseSanity => true;
	}
	public class IngestibleFluMedicine : Ingestible
	{
		public override string ItemID => "flumedicine";

		public override float Food => 0f;

		public override float Energy => 0f;

		public override float Thirst => 0.05f;

		public override float HPRegen => 3f;

		public override bool healIllness => true;
	}
	public class IngestibleParacetamol : Ingestible
	{
		public static readonly float SystemicAmountPerDose = 0.17f;

		public static readonly float MaxHPRegen = 4f;

		public override string ItemID => "paracetamol";

		public override float Food => 0f;

		public override float Energy => 0f;

		public override float Thirst => 0f;

		public override float HPRegen => 8f;

		public override bool healIllness => true;

		public override float toxicityInDose => SystemicAmountPerDose;
	}
	public static class FlatlineIngestibles
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass15_0
		{
			public Tap tap;

			public InteractableObject intObj;
		}

		[CompilerGenerated]
		private sealed class <DrinkTapWater>d__24 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Tap tap;

			public InteractableObject intObj;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DrinkTapWater>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)tap.NPCUserObject != (Object)null || (Object)(object)tap.PlayerUserObject != (Object)null || tapsInUse.Contains(tap))
					{
						return false;
					}
					tapsInUse.Add(tap);
					((Behaviour)intObj).enabled = false;
					if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
					{
						FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(drinkClip);
					}
					tap.SetHeldOpen(true);
					<>2__current = Flatline.Wait05;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					FlatlinePlayer.SetWater(Mathf.Clamp(Flatline.loadedPlayerData.State.Thirst + 0.08f, 0f, 1f));
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					tap.SetHeldOpen(false);
					<>2__current = Flatline.Wait1;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					tapsInUse.Remove(tap);
					((Behaviour)intObj).enabled = true;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EvaluateTapAccess>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InteractableObject drinkWater;

			public InteractableObject fillCan;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EvaluateTapAccess>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Invalid comparison between Unknown and I4
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Invalid comparison between Unknown and I4
				//IL_006a: 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_008b: Invalid comparison between Unknown and I4
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Behaviour)drinkWater).enabled || ((Component)drinkWater).gameObject.activeSelf)
					{
						return false;
					}
					if (((int)fillCan.interactionState == 0 || (int)fillCan.interactionState == 1) && (int)drinkWater.interactionState == 0)
					{
						drinkWater.interactionState = (EInteractableState)2;
					}
					else if ((int)drinkWater.interactionState == 2 && (int)fillCan.interactionState == 2)
					{
						drinkWater.interactionState = (EInteractableState)0;
					}
					<>2__current = Flatline.Wait05;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					isEvaluatingTapAccess = false;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <InitiateIngestibleModule>d__15 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private Equippable_Cuke <cukeEquippable>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitiateIngestibleModule>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<cukeEquippable>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_034f: 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_00c6: 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_03d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03da: Expected O, but got Unknown
				//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0428: Unknown result type (might be due to invalid IL or missing references)
				//IL_0491: Unknown result type (might be due to invalid IL or missing references)
				//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_050d: Unknown result type (might be due to invalid IL or missing references)
				//IL_052b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0535: Expected O, but got Unknown
				//IL_0549: Unknown result type (might be due to invalid IL or missing references)
				//IL_0553: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if ((Object)(object)Singleton<HUD>.Instance != (Object)null && (Object)(object)Singleton<HUD>.Instance.radialIndicator != (Object)null)
					{
						GameObject obj = Object.Instantiate<GameObject>(((Component)Singleton<HUD>.Instance.radialIndicator).gameObject, ((Component)Singleton<HUD>.Instance.radialIndicator).transform.parent);
						obj.SetActive(true);
						((Object)obj).name = "RadialIndicatorAdditional";
						RectTransform component = ((Component)Singleton<HUD>.Instance.radialIndicator).gameObject.GetComponent<RectTransform>();
						if ((Object)(object)component == (Object)null)
						{
							DebugModule.Log("Radial indicator has no rect trasform", "InitiateIngestibleModule");
						}
						RectTransform component2 = obj.GetComponent<RectTransform>();
						((Transform)component2).position = ((Transform)component).position;
						((Transform)component2).rotation = ((Transform)component).rotation;
						((Transform)component2).localScale = ((Transform)component).localScale;
						consumeRadialIndicator = obj.GetComponent<Image>();
						if ((Object)(object)consumeRadialIndicator != (Object)null)
						{
							((Behaviour)consumeRadialIndicator).enabled = true;
						}
						else
						{
							DebugModule.Log("Radial indicator has no Image component", "InitiateIngestibleModule");
						}
					}
					else
					{
						DebugModule.Log("Failed to make radial indicator copy", "InitiateIngestibleModule");
					}
					DebugModule.Log("Radial indicator copy made", "InitiateIngestibleModule");
					PlayerSingleton<PlayerInventory>.Instance.onEquippedSlotChanged = (Action<int>)Delegate.Combine(PlayerSingleton<PlayerInventory>.instance.onEquippedSlotChanged, new Action<int>(OnSlotChanged));
					DebugModule.Log("Equipped slot change callback assigned", "InitiateIngestibleModule");
					Func<string, ItemDefinition> func = Registry.GetItem;
					ItemDefinition val2 = func("shroom");
					ItemDefinition val3 = func("cuke");
					val2.GetDefaultInstance(1);
					<cukeEquippable>5__2 = null;
					ItemDefinition obj2 = ((val2 is ShroomDefinition) ? val2 : null);
					ref Equippable_Cuke reference = ref <cukeEquippable>5__2;
					Equippable equippable = val3.Equippable;
					reference = (Equippable_Cuke)(object)((equippable is Equippable_Cuke) ? equippable : null);
					ProductConsumeAnimation val4 = Object.Instantiate<ProductConsumeAnimation>(((ProductDefinition)obj2).ConsumeAnimation, (Transform)null);
					if ((Object)(object)val4.ConsumeSound == (Object)null)
					{
						DebugModule.Log("Failed to instantiate sound component", "InitiateIngestibleModule");
					}
					else if ((Object)(object)val4.ConsumeSound.Clip == (Object)null)
					{
						DebugModule.Log("Could not instantiate clip", "InitiateIngestibleModule");
					}
					else
					{
						munchClip = val4.ConsumeSound.Clip;
					}
					Object.Destroy((Object)(object)((Component)val4).gameObject);
					val4 = null;
					<>2__current = Flatline.Wait01;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					DebugModule.Log($"Is null:  {(Object)(object)munchClip == (Object)null}", "InitiateIngestibleModule");
					if ((Object)(object)<cukeEquippable>5__2 != (Object)null)
					{
						DebugModule.Log("Assiging drink clip", "InitiateIngestibleModule");
						Equippable_Cuke val = Object.Instantiate<Equippable_Cuke>(<cukeEquippable>5__2, (Transform)null);
						if ((Object)(object)val != (Object)null && (Object)(object)val.SlurpSound != (Object)null && (Object)(object)val.SlurpSound.Clip != (Object)null)
						{
							drinkClip = val.SlurpSound.Clip;
						}
						Object.Destroy((Object)(object)((Component)val).gameObject);
						val = null;
						<>2__current = Flatline.Wait01;
						<>1__state = 2;
						return true;
					}
					DebugModule.Log("Could not assing drink clip", "InitiateIngestibleModule");
					break;
				case 2:
					<>1__state = -1;
					DebugModule.Log($"Is null:  {(Object)(object)drinkClip == (Object)null}", "InitiateIngestibleModule");
					break;
				}
				DebugModule.Log("Sound clips found", "InitiateIngestibleModule");
				GameObject val5 = new GameObject("FlatlineIngestorAudio");
				ingestorAudio = val5.AddComponent<AudioSource>();
				ingestorAudio.loop = false;
				ingestorAudio.playOnAwake = false;
				ingestorAudio.volume = 0.7f;
				val5.SetActive(true);
				DebugModule.Log("IngestorAudio made", "InitiateIngestibleModule");
				Tap[] array = Object.FindObjectsOfType<Tap>(true);
				for (int i = 0; i < array.Length; i++)
				{
					<>c__DisplayClass15_0 CS$<>8__locals0 = new <>c__DisplayClass15_0
					{
						tap = array[i]
					};
					if (!((Object)(object)CS$<>8__locals0.tap._interactable == (Object)null))
					{
						GameObject val6 = new GameObject("DrinkTapWater");
						CS$<>8__locals0.intObj = val6.AddComponent<InteractableObject>();
						BoxCollider obj3 = val6.AddComponent<BoxCollider>();
						obj3.size = new Vector3(0.45f, 0.45f, 0.45f);
						((Collider)obj3).isTrigger = true;
						CS$<>8__locals0.intObj.message = "Drink tap water";
						CS$<>8__locals0.intObj.interactionState = (EInteractableState)0;
						CS$<>8__locals0.intObj.MaxInteractionRange = 1.85f;
						val6.transform.parent = ((Component)CS$<>8__locals0.tap._interactable).transform.parent;
						if ((Object)(object)CS$<>8__locals0.tap._interactable.displayLocationPoint != (Object)null)
						{
							val6.transform.localPosition = CS$<>8__locals0.tap._interactable.displayLocationPoint.localPosition;
						}
						else if ((Object)(object)CS$<>8__locals0.tap._interactable.displayLocationCollider != (Object)null)
						{
							val6.transform.localPosition = ((Component)CS$<>8__locals0.tap._interactable.displayLocationCollider).gameObject.transform.localPosition;
						}
						else
						{
							val6.transform.localPosition = ((Component)CS$<>8__locals0.tap._interactable).transform.localPosition;
						}
						val6.transform.localRotation = Quaternion.identity;
						CS$<>8__locals0.intObj.onInteractStart.AddListener(new UnityAction(StartDrinking));
						CS$<>8__locals0.intObj.onHovered.AddListener(new UnityAction(OnHover));
						((Behaviour)CS$<>8__locals0.intObj).enabled = true;
						val6.SetActive(true);
					}
					void OnHover()
					{
						if (isEvaluatingTapAccess)
						{
							isEvaluatingTapAccess = true;
							Flatline.coros.Add(MelonCoroutines.Start(EvaluateTapAccess(CS$<>8__locals0.intObj, CS$<>8__locals0.tap._interactable)));
						}
					}
					void StartDrinking()
					{
						Flatline.coros.Add(MelonCoroutines.Start(DrinkTapWater(CS$<>8__locals0.tap, CS$<>8__locals0.intObj)));
					}
				}
				ingestibleModuleInitiated = true;
				DebugModule.Log("Initiated ingestible module", "InitiateIngestibleModule");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly List<string> addOnConsumption = new List<string> { "donut", "chili", "megabean", "banana", "paracetamol", "flumedicine", "addy" };

		public static readonly List<string> chokeableFoods = new List<string> { "donut", "megabean", "banana" };

		public static readonly List<Ingestible> ingestibles = new List<Ingestible>
		{
			new IngestibleDonut(),
			new IngestibleChili(),
			new IngestibleBean(),
			new IngestibleBanana(),
			new IngestibleParacetamol(),
			new IngestibleFluMedicine(),
			new IngestibleAddy(),
			new IngestibleCuke(),
			new IngestibleEnergyDrink()
		};

		public static readonly float consumeDuration = 1.5f;

		public static Image consumeRadialIndicator;

		public static AudioClip munchClip;

		public static AudioClip drinkClip;

		public static AudioSource ingestorAudio;

		private static bool isCurrentItemChecked = false;

		private static bool isCurrentItemValid = false;

		private static float currentConsumeDuration = 0f;

		private static bool ingestingItem = false;

		private static bool isEvaluatingTapAccess = false;

		public static bool ingestibleModuleInitiated = false;

		public static List<Tap> tapsInUse = new List<Tap>();

		[IteratorStateMachine(typeof(<InitiateIngestibleModule>d__15))]
		public static IEnumerator InitiateIngestibleModule()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitiateIngestibleModule>d__15(0);
		}

		public static void ResetIngestibleModule()
		{
			ingestibleModuleInitiated = false;
			consumeRadialIndicator = null;
			munchClip = null;
			drinkClip = null;
			ingestorAudio = null;
			isCurrentItemChecked = false;
			isCurrentItemValid = false;
			currentConsumeDuration = 0f;
			ingestingItem = false;
		}

		[IteratorStateMachine(typeof(<EvaluateTapAccess>d__17))]
		public static IEnumerator EvaluateTapAccess(InteractableObject drinkWater, InteractableObject fillCan)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EvaluateTapAccess>d__17(0)
			{
				drinkWater = drinkWater,
				fillCan = fillCan
			};
		}

		public static void UpdateConsumption()
		{
			if (!PlayerSingleton<PlayerInventory>.Instance.isAnythingEquipped || !ingestibleModuleInitiated)
			{
				return;
			}
			if (!isCurrentItemChecked)
			{
				isCurrentItemChecked = true;
				isCurrentItemValid = CheckSlotItem();
			}
			if (!isCurrentItemValid)
			{
				return;
			}
			if (Input.GetMouseButtonDown(0))
			{
				ingestingItem = true;
				currentConsumeDuration = 0f;
				((Component)consumeRadialIndicator).gameObject.SetActive(true);
				consumeRadialIndicator.fillAmount = 0f;
			}
			if (Input.GetMouseButtonUp(0))
			{
				ResetEatingState();
			}
			if (Input.GetMouseButton(0) && ingestingItem)
			{
				((Component)consumeRadialIndicator).gameObject.SetActive(true);
				currentConsumeDuration += Time.deltaTime;
				float fillAmount = Mathf.Clamp01(currentConsumeDuration / consumeDuration);
				consumeRadialIndicator.fillAmount = fillAmount;
				if (currentConsumeDuration >= consumeDuration)
				{
					IngestCurrentItem();
					ResetEatingState();
				}
			}
		}

		private static void ResetEatingState()
		{
			if (ingestibleModuleInitiated)
			{
				isCurrentItemChecked = false;
				ingestingItem = false;
				currentConsumeDuration = 0f;
				((Component)consumeRadialIndicator).gameObject.SetActive(false);
				consumeRadialIndicator.fillAmount = 0f;
			}
		}

		public static void IngestCurrentItem()
		{
			int equippedSlotIndex = PlayerSingleton<PlayerInventory>.Instance._equippedSlotIndex;
			ItemInstance itemInstance = Player.Local.Inventory[equippedSlotIndex].ItemInstance;
			if (itemInstance != null)
			{
				AudioClip val = ((((BaseItemInstance)itemInstance).ID == "flumedicine") ? drinkClip : munchClip);
				ingestorAudio.PlayOneShot(val);
				((BaseItemInstance)itemInstance).ChangeQuantity(-1);
				if (((BaseItemInstance)itemInstance).Quantity > 0)
				{
					PlayerSingleton<PlayerInventory>.Instance.Reequip();
				}
				Player.Local.SendAnimationTrigger("Eat");
				ProcessIngestible(((BaseItemInstance)itemInstance).ID, (EQuality)0);
			}
		}

		public static void ProcessIngestible(string id, EQuality quality = 0, bool useQuality = false)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (useQuality)
			{
				PlayerConsumeDamage.OnProductConsumed(PlayerConsumeDamage.TypeFromID(id), quality, useQuality: true);
			}
			else
			{
				PlayerConsumeDamage.OnProductConsumed(PlayerConsumeDamage.TypeFromID(id), (EQuality)0);
			}
			if (ingestibles.Count == 0)
			{
				return;
			}
			Ingestible ingestible = null;
			for (int i = 0; i < ingestibles.Count; i++)
			{
				if (ingestibles[i].ItemID == id)
				{
					ingestible = ingestibles[i];
					break;
				}
			}
			if (ingestible == null)
			{
				return;
			}
			if (Random.Range(0, 67000000) == 0)
			{
				DebugModule.Log("Player lethally choked on food: " + ingestible.ItemID, "ProcessIngestible");
				FlatlineUIModule.causeOfDeath = "Choked on a " + ingestible.ItemID;
				if (Player.Local.Avatar.CurrentSettings.Gender > 0.5f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(ConfigLoader.loadedAudios["femalecough"]);
				}
				else
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(ConfigLoader.loadedAudios["malecough"]);
				}
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				return;
			}
			Player.Local.Health.CurrentHealth = Mathf.Clamp(Player.Local.Health.CurrentHealth + ingestible.HPRegen, 0f, Flatline.loadedPlayerData.State.healthData.MaxHP);
			FlatlinePlayer.SetEnergy(Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy + ingestible.Energy));
			FlatlinePlayer.SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst + ingestible.Thirst));
			FlatlinePlayer.SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger + ingestible.Food));
			if ((ingestible.healIllness || ingestible.increaseSanity) && PlayerDiseaseDamage.allDiseases.Count > 0)
			{
				for (int j = 0; j < PlayerDiseaseDamage.allDiseases.Count; j++)
				{
					if (PlayerDiseaseDamage.allDiseases[j].data.Active)
					{
						if (PlayerDiseaseDamage.allDiseases[j].data.DiseaseID == "fever" && ingestible.healIllness)
						{
							PlayerDiseaseDamage.allDiseases[j].data.HealState += Random.Range(0.33f, 0.66f);
						}
						if (PlayerDiseaseDamage.allDiseases[j].data.DiseaseID == "bonebreak" && ingestible.healIllness)
						{
							PlayerDiseaseDamage.allDiseases[j].data.HealState += Random.Range(0.02f, 0.09f);
						}
						if (PlayerDiseaseDamage.allDiseases[j].data.DiseaseID == "depression" && ingestible.increaseSanity)
						{
							PlayerDiseaseDamage.allDiseases[j].data.HealState += Random.Range(0.02f, 0.09f);
						}
					}
				}
			}
			FlatlinePlayer.stateChanged = true;
		}

		public static bool CheckSlotItem()
		{
			int equippedSlotIndex = PlayerSingleton<PlayerInventory>.Instance._equippedSlotIndex;
			if (equippedSlotIndex >= 0 && equippedSlotIndex < 8)
			{
				ItemInstance itemInstance = Player.Local.Inventory[equippedSlotIndex].ItemInstance;
				if (itemInstance != null)
				{
					if (addOnConsumption.Contains(((BaseItemInstance)itemInstance).ID))
					{
						return true;
					}
					ingestingItem = false;
					return false;
				}
				ingestingItem = false;
				return false;
			}
			ingestingItem = false;
			return false;
		}

		public static void OnSlotChanged(int _)
		{
			ResetEatingState();
		}

		[IteratorStateMachine(typeof(<DrinkTapWater>d__24))]
		public static IEnumerator DrinkTapWater(Tap tap, InteractableObject intObj)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DrinkTapWater>d__24(0)
			{
				tap = tap,
				intObj = intObj
			};
		}
	}
	[HarmonyPatch(typeof(Equippable_Cuke), "ApplyEffects")]
	public static class Equippable_Cuke_ApplyEffects_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(Equippable_Cuke __instance)
		{
			DebugModule.Log("Apply Cuke Effects", "Prefix");
			if ((Object)(object)__instance.PseudoProduct != (Object)null)
			{
				ItemInstance defaultInstance = ((ItemDefinition)__instance.PseudoProduct).GetDefaultInstance(1);
				ProductItemInstance val = (ProductItemInstance)(object)((defaultInstance is ProductItemInstance) ? defaultInstance : null);
				if (val != null)
				{
					Player.Local.ConsumeProduct(val);
				}
			}
			return false;
		}
	}
	public abstract class Ingestible
	{
		public abstract string ItemID { get; }

		public abstract float Food { get; }

		public abstract float Energy { get; }

		public abstract float Thirst { get; }

		public abstract float HPRegen { get; }

		public virtual bool healIllness => false;

		public virtual bool increaseSanity => false;

		public virtual float toxicityInDose { get; }
	}
	public static class FlatlinePlayer
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass44_0
		{
			public bool shouldWakeNow;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass51_0
		{
			public GameObject visPos;

			public bool bindToHeadEnabled;

			public Func<bool> waitState;

			internal bool <FPRagdoll>b__4()
			{
				if (Flatline.registered)
				{
					return waitState();
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <EnsureSystematicHomeostasis>d__52 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnsureSystematicHomeostasis>d__52(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (Player.Local.Health.IsAlive && !isQueuedForDeath && !Flatline.isSaving && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && !Flatline.haltExecution)
					{
						if (!Mathf.Approximately(ThirstConsumptionPerMinute, DefaultThirstConsumption))
						{
							ThirstConsumptionPerMinute = Mathf.Lerp(ThirstConsumptionPerMinute, DefaultThirstConsumption, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(FoodConsumptionPerMinute, DefaultFoodConsumption))
						{
							FoodConsumptionPerMinute = Mathf.Lerp(FoodConsumptionPerMinute, DefaultFoodConsumption, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(EnergyConsumptionPerMinute, DefaultEnergyConsumption))
						{
							EnergyConsumptionPerMinute = Mathf.Lerp(EnergyConsumptionPerMinute, DefaultEnergyConsumption, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(TemperatureConsumption, TemperatureConsumptionPerMinutePerDegreeDiff))
						{
							TemperatureConsumption = Mathf.Lerp(TemperatureConsumption, TemperatureConsumptionPerMinutePerDegreeDiff, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(HealthRegenPerMinute, DefaultHealthRegeneration))
						{
							HealthRegenPerMinute = Mathf.Lerp(HealthRegenPerMinute, DefaultHealthRegeneration, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(Flatline.loadedPlayerData.State.healthData.MaxHP, 100f))
						{
							Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Lerp(Flatline.loadedPlayerData.State.healthData.MaxHP, 100f, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(Flatline.loadedPlayerData.State.healthData.MoveSpeedScale, 1f))
						{
							Flatline.loadedPlayerData.State.healthData.MoveSpeedScale = Mathf.Lerp(Flatline.loadedPlayerData.State.healthData.MoveSpeedScale, 1f, SystematicHomeostasisSpeed);
						}
						if (!Mathf.Approximately(sprintReserveRegenPerMinute, DefaultSprintReserveRegenPerMinute))
						{
							sprintReserveRegenPerMinute = Mathf.Lerp(sprintReserveRegenPerMinute, DefaultSprintReserveRegenPerMinute, SystematicHomeostasisSpeed);
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = Flatline.Wait2;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <FPRagdoll>d__51 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Func<bool> waitState;

			private <>c__DisplayClass51_0 <>8__1;

			public int forceDown;

			public bool waitSleepEnd;

			private float <originalNearClip>5__2;

			private Vector3 <origin1stPos>5__3;

			private Quaternion <origin1stRot>5__4;

			private float <smoothInDur>5__5;

			private float <currentDur>5__6;

			private GameObject <visColl>5__7;

			private Vector3 <worldStart>5__8;

			private Quaternion <worldRot>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FPRagdoll>d__51(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<visColl>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0089: 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_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Expected O, but got Unknown
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Expected O, but got Unknown
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c6: 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_0354: Unknown result type (might be due to invalid IL or missing references)
				//IL_0359: Unknown result type (might be due to invalid IL or missing references)
				//IL_0369: Unknown result type (might be due to invalid IL or missing references)
				//IL_036e: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_06df: Unknown result type (might be due to invalid IL or missing references)
				//IL_045c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0461: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0602: Expected O, but got Unknown
				//IL_0671: Unknown result type (might be due to invalid IL or missing references)
				//IL_0677: Expected O, but got Unknown
				//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0486: Unknown result type (might be due to invalid IL or missing references)
				//IL_048b: Unknown result type (might be due to invalid IL or missing references)
				//IL_046a: Unknown result type (might be due to invalid IL or missing references)
				//IL_046f: Unknown result type (might be due to invalid IL or missing references)
				//IL_057f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0586: Expected O, but got Unknown
				//IL_049b: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0539: Unknown result type (might be due to invalid IL or missing references)
				//IL_0540: Expected O, but got Unknown
				Vector3 zero;
				WaitUntil val2;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass51_0();
					<>8__1.waitState = waitState;
					if (isFPRagdollActive)
					{
						return false;
					}
					isFPRagdollActive = true;
					<originalNearClip>5__2 = PlayerSingleton<PlayerCamera>.Instance.Camera.nearClipPlane;
					<origin1stPos>5__3 = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localPosition;
					<origin1stRot>5__4 = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localRotation;
					_ = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.parent;
					PlayerSingleton<PlayerMovement>.Instance.IsSprinting = false;
					PlayerSingleton<PlayerMovement>.Instance.AddSprintBlocker("LegDamage");
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(false);
					PlayerSingleton<PlayerCamera>.Instance.AddActiveUIElement("FirstPersonRagdoll");
					PlayerSingleton<PlayerMovement>.Instance.CanMove = false;
					((Behaviour)PlayerSingleton<PlayerCamera>.Instance).enabled = false;
					((Collider)Player.Local.CapCol).enabled = false;
					<smoothInDur>5__5 = 0.3f;
					<currentDur>5__6 = 0f;
					_ = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localPosition;
					_ = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localRotation;
					<>8__1.bindToHeadEnabled = false;
					<>8__1.visPos = new GameObject("CamTrackPos");
					<>8__1.visPos.SetActive(false);
					<visColl>5__7 = new GameObject("CamBlockCollider");
					<visColl>5__7.SetActive(false);
					BoxCollider obj = <visColl>5__7.AddComponent<BoxCollider>();
					<visColl>5__7.AddComponent<Rigidbody>().isKinematic = true;
					<>8__1.visPos.transform.parent = Player.Local.Avatar.HeadBone;
					<>8__1.visPos.transform.localScale = Vector3.one;
					<>8__1.visPos.transform.localRotation = Quaternion.identity;
					<>8__1.visPos.transform.localPosition = new Vector3(0f, 0.001f, 0.002f);
					<visColl>5__7.transform.parent = Player.Local.Avatar.HeadBone;
					<visColl>5__7.transform.localScale = new Vector3(0.001f, 0.001f, 0.001f);
					<visColl>5__7.transform.localRotation = Quaternion.identity;
					<visColl>5__7.transform.localPosition = new Vector3(0f, 0.0001f, 0.0018f);
					((Collider)obj).providesContacts = true;
					obj.size = new Vector3(0.06f, 0.06f, 0.7f);
					obj.center = new Vector3(0f, 0.01f, 0f);
					<>8__1.visPos.layer = LayerMask.NameToLayer("Invisible");
					<>8__1.visPos.SetActive(true);
					<visColl>5__7.layer = LayerMask.NameToLayer("Invisible");
					<visColl>5__7.SetActive(true);
					PlayerSingleton<PlayerCamera>.Instance.Camera.nearClipPlane = 0.001f;
					<worldStart>5__8 = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.position;
					<worldRot>5__9 = ((Component)PlayerSingleton<PlayerCamera>.Instance).transform.rotation;
					goto IL_0418;
				}
				case 1:
					<>1__state = -1;
					goto IL_0418;
				case 2:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (isQueuedForDeath && Player.PlayerList.Count == 1)
					{
						<>8__1.bindToHeadEnabled = false;
						Object.Destroy((Object)(object)<>8__1.visPos);
						Object.Destroy((Object)(object)<visColl>5__7);
						return false;
					}
					if (Player.PlayerList.Count > 1)
					{
						WaitUntil val3 = new WaitUntil((Func<bool>)(() => !Flatline.registered || Player.Local.Health.IsAlive));
						<>2__current = val3;
						<>1__state = 3;
						return true;
					}
					goto IL_0558;
				case 3:
					<>1__state = -1;
					goto IL_0558;
				case 4:
					<>1__state = -1;
					<>2__current = Flatline.Wait5;
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = Flatline.Wait1;
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					goto IL_05dd;
				case 7:
					<>1__state = -1;
					<>2__current = Flatline.Wait1;
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					goto IL_063e;
				case 9:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<>8__1.bindToHeadEnabled = false;
						Object.Destroy((Object)(object)<>8__1.visPos);
						Object.Destroy((Object)(object)<visColl>5__7);
						((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localPosition = <origin1stPos>5__3;
						((Component)PlayerSingleton<PlayerCamera>.Instance).transform.localRotation = <origin1stRot>5__4;
						PlayerSingleton<PlayerCamera>.Instance.Camera.nearClipPlane = <originalNearClip>5__2;
						((Behaviour)PlayerSingleton<PlayerCamera>.Instance).enabled = true;
						PlayerSingleton<PlayerMovement>.Instance.CanMove = true;
						PlayerSingleton<PlayerCamera>.Instance.SetCanLook(true);
						((Collider)Player.Local.CapCol).enabled = true;
						PlayerSingleton<PlayerInventory>.Instance.SetEquippingEnabled(true);
						PlayerSingleton<PlayerMovement>.Instance.RemoveSprintBlocker("LegDamage");
						Player.Local.SetRagdolled(false);
						PlayerSingleton<PlayerCamera>.Instance.RemoveActiveUIElement("FirstPersonRagdoll");
						isFPRagdollActive = false;
						return false;
					}
					IL_0418:
					if (<currentDur>5__6 < <smoothInDur>5__5)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						<currentDur>5__6 += Time.deltaTime;
						float num = <currentDur>5__6 / <smoothInDur>5__5;
						((Component)PlayerSingleton<PlayerCamera>.Instance).transform.position = Vector3.Lerp(<worldStart>5__8, <>8__1.visPos.transform.position, num);
						((Component)PlayerSingleton<PlayerCamera>.Instance).transform.rotation = Quaternion.Slerp(<worldRot>5__9, <>8__1.visPos.transform.rotation, num);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>8__1.bindToHeadEnabled = true;
					MelonCoroutines.Start(WhileRagdolledBindCamToHead());
					Player.Local.SetRagdolled(true);
					PlayerSingleton<PlayerInventory>.Instance.SetEquippingEnabled(false);
					zero = Vector3.zero;
					zero = ((forceDown != 0) ? ((Component)((Component)Player.Local).transform.root).transform.forward : Vector3.down);
					Player.Local.Avatar.MiddleSpineRB.AddForce(zero * 1.4f, (ForceMode)2);
					<>2__current = Flatline.Wait5;
					<>1__state = 2;
					return true;
					IL_05dd:
					if (<>8__1.waitState != null)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.registered || <>8__1.waitState()));
						<>2__current = val;
						<>1__state = 7;
						return true;
					}
					goto IL_063e;
					IL_063e:
					Player.Local.Avatar.Animation.PlayStandUpAnimation();
					val2 = new WaitUntil((Func<bool>)(() => !Flatline.registered || !Player.Local.Avatar.Animation.StandUpAnimationPlaying));
					<>2__current = val2;
					<>1__state = 9;
					return true;
					IL_0558:
					if (waitSleepEnd)
					{
						WaitUntil val4 = new WaitUntil((Func<bool>)(() => !Flatline.registered || !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress));
						<>2__current = val4;
						<>1__state = 4;
						return true;
					}
					goto IL_05dd;
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass51_0.<<FPRagdoll>g__WhileRagdolledBindCamToHead|0>d))]
				IEnumerator WhileRagdolledBindCamToHead()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass51_0.<<FPRagdoll>g__WhileRagdolledBindCamToHead|0>d(0)
					{
						<>4__this = this
					};
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LazyUpdatePlayerWarmBuilding>d__56 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LazyUpdatePlayerWarmBuilding>d__56(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (isQueuedForDeath && Flatline.currentConfig.PermanentDeath)
					{
						return false;
					}
					if (Flatline.currentConfig.TemperatureRequired && !isPassedOut && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && !Flatline.haltExecution && !((Object)(object)Player.Local.CurrentProperty != (Object)null) && !((Object)(object)Player.Local.CurrentBusiness != (Object)null))
					{
						bool flag = false;
						bool flag2 = false;
						if (NetworkSingleton<EnvironmentManager>.Instance._weatherEnclosures != null)
						{
							float num2 = default(float);
							foreach (WeatherEnclosure weatherEnclosure in NetworkSingleton<EnvironmentManager>.Instance._weatherEnclosures)
							{
								if (((WorldEnclosure)weatherEnclosure).WithinEnclosure(Player.Local.CenterPointTransform.position, ref num2))
								{
									flag = true;
									break;
								}
							}
						}
						if (!flag)
						{
							float num3 = 100f;
							foreach (KeyValuePair<EMapRegion, List<BoxCollider>> item in PropertyTemperatureController.warmBuildingsInRegion)
							{
								if (flag2)
								{
									break;
								}
								foreach (BoxCollider item2 in item.Value)
								{
									float num4 = Vector3.Distance(Player.Local.CenterPointTransform.position, ((Component)item2).transform.position);
									if (num4 < num3)
									{
										num3 = num4;
									}
									if (num4 < 5f || IsPointInsideBox(Player.Local.CenterPointTransform.position, item2))
									{
										insideWarmBuilding = true;
										string text = ((num4 < 5f) ? "near" : "");
										text += (IsPointInsideBox(Player.Local.CenterPointTransform.position, item2) ? "+in box" : "");
										DebugModule.Log("Detected player presence in a warm building " + text, "LazyUpdatePlayerWarmBuilding");
										flag2 = true;
										break;
									}
								}
							}
						}
						if (!flag && !flag2)
						{
							DebugModule.Log("Player not inside a warm building in region ", "LazyUpdatePlayerWarmBuilding");
							insideWarmBuilding = false;
						}
						else
						{
							DebugModule.Log("Detected player presence in a weather enclosure or warm building", "LazyUpdatePlayerWarmBuilding");
							insideWarmBuilding = true;
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = Flatline.Wait10;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PrePlayerDied>d__43 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <duration>5__2;

			private float <current>5__3;

			private bool <hasSetRagdolled>5__4;

			private float <moveSpeed>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PrePlayerDied>d__43(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Expected O, but got Unknown
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_0361: Unknown result type (might be due to invalid IL or missing references)
				//IL_0368: Expected O, but got Unknown
				float num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					DebugModule.Log("Started death routine", "PrePlayerDied");
					if (isQueuedForDeath)
					{
						return false;
					}
					isQueuedForDeath = true;
					if (BedRotSimulator.isBedrotting)
					{
						<>2__current = Flatline.Wait2;
						<>1__state = 1;
						return true;
					}
					goto IL_00a2;
				case 1:
					<>1__state = -1;
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					goto IL_00a2;
				case 3:
					<>1__state = -1;
					goto IL_00e5;
				case 4:
					<>1__state = -1;
					goto IL_0134;
				case 5:
					<>1__state = -1;
					goto IL_0288;
				case 6:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					Player.Local.Health.SendDie();
					Flatline.coros.Add(MelonCoroutines.Start(FlatlineUIModule.GenerateDeathScreenScore()));
					if (Player.PlayerList.Count > 1 && !Flatline.currentConfig.PermanentDeath)
					{
						DebugModule.Log("Detected multiplayer instance where permanent death is disabled", "PrePlayerDied");
						DebugModule.Log("Wait until player presses respawn button", "PrePlayerDied");
						WaitUntil val3 = new WaitUntil((Func<bool>)(() => !Flatline.registered || Player.Local.Health.IsAlive));
						<>2__current = val3;
						<>1__state = 7;
						return true;
					}
					break;
				case 7:
					<>1__state = -1;
					<>2__current = Flatline.Wait2;
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					SetWater(0.99f);
					SetFood(0.99f);
					SetTemperature(0.99f);
					SetEnergy(0.99f);
					Flatline.loadedPlayerData.State.healthData.MaxHP = 100f;
					Flatline.loadedPlayerData.State.healthData.CurrentHP = 99f;
					<current>5__3 = 0f;
					num = 0f;
					goto IL_0477;
				case 9:
					{
						<>1__state = -1;
						goto IL_0477;
					}
					IL_0134:
					Player.Local.Health.PlayBloodMist();
					Singleton<EyelidOverlay>.Instance.AutoUpdate = false;
					<duration>5__2 = 3.5f;
					<current>5__3 = 0f;
					<hasSetRagdolled>5__4 = false;
					<moveSpeed>5__5 = PlayerMovement.StaticMoveSpeedMultiplier;
					flatlinePlayerAudio.PlayOneShot(ConfigLoader.loadedAudios["flatline"]);
					num = 0f;
					goto IL_0288;
					IL_00a2:
					if (isPassedOut)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.registered || !isPassedOut));
						<>2__current = val;
						<>1__state = 3;
						return true;
					}
					goto IL_00e5;
					IL_0477:
					if (<current>5__3 < <duration>5__2)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__3 += Time.deltaTime;
						num = <current>5__3 / <duration>5__2;
						Singleton<PostProcessingManager>.Instance.SetBlur(Mathf.Lerp(1f, 0f, num));
						Singleton<EyelidOverlay>.Instance.CurrentOpen = num;
						<>2__current = null;
						<>1__state = 9;
						return true;
					}
					Singleton<EyelidOverlay>.Instance.CurrentOpen = 1f;
					Singleton<EyelidOverlay>.Instance.AutoUpdate = true;
					Singleton<PostProcessingManager>.Instance.SetBlur(0f);
					PlayerMovement.StaticMoveSpeedMultiplier = <moveSpeed>5__5;
					if (<hasSetRagdolled>5__4)
					{
						PlayerSingleton<PlayerInventory>.Instance.SetInventoryEnabled(true);
						Player.Local.IsUnconscious = false;
						Singleton<HUD>.Instance.SetCrosshairVisible(true);
					}
					isQueuedForDeath = false;
					DebugModule.Log("Player respawned", "PrePlayerDied");
					break;
					IL_00e5:
					if (isFPRagdollActive || Player.Local.IsRagdolled)
					{
						WaitUntil val2 = new WaitUntil((Func<bool>)(() => !Flatline.registered || (!isFPRagdollActive && !Player.Local.IsRagdolled)));
						<>2__current = val2;
						<>1__state = 4;
						return true;
					}
					goto IL_0134;
					IL_0288:
					if (Flatline.registered && <current>5__3 < <duration>5__2)
					{
						<current>5__3 += Time.deltaTime;
						num = <current>5__3 / <duration>5__2;
						Singleton<PostProcessingManager>.Instance.SetBlur(num);
						PlayerMovement.StaticMoveSpeedMultiplier = Mathf.Lerp(<moveSpeed>5__5, 0f, num);
						Singleton<EyelidOverlay>.Instance.CurrentOpen = Mathf.Lerp(1f, 0f, num);
						if (!<hasSetRagdolled>5__4 && num > 0.1f && !isFPRagdollActive && !Player.Local.IsRagdolled)
						{
							<hasSetRagdolled>5__4 = true;
							Player.Local.IsUnconscious = true;
							Singleton<GameInput>.Instance.ExitAll();
							PlayerSingleton<PlayerInventory>.Instance.SetInventoryEnabled(false);
							Singleton<HUD>.Instance.SetCrosshairVisible(false);
							((Behaviour)Singleton<HUD>.Instance.canvas).enabled = false;
							Flatline.coros.Add(MelonCoroutines.Start(FPRagdoll()));
						}
						<>2__current = null;
						<>1__state = 5;
						return true;
					}
					Singleton<EyelidOverlay>.Instance.CurrentOpen = 0f;
					Singleton<PostProcessingManager>.Instance.SetBlur(1f);
					<>2__current = Flatline.Wait05;
					<>1__state = 6;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PrePlayerPassOut>d__44 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass44_0 <>8__1;

			private bool <shouldRob>5__2;

			private bool <shouldSleep>5__3;

			private float <duration>5__4;

			private float <current>5__5;

			private bool <hasSetRagdolled>5__6;

			private float <moveSpeed>5__7;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PrePlayerPassOut>d__44(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Expected O, but got Unknown
				//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d8: Expected O, but got Unknown
				WaitUntil val;
				float num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass44_0();
					if (isPassedOut || isQueuedForDeath)
					{
						return false;
					}
					isPassedOut = true;
					if (BedRotSimulator.isBedrotting)
					{
						<>2__current = Flatline.Wait2;
						<>1__state = 1;
						return true;
					}
					goto IL_00a8;
				case 1:
					<>1__state = -1;
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!Flatline.registered || isQueuedForDeath)
					{
						return false;
					}
					goto IL_00a8;
				case 3:
					<>1__state = -1;
					goto IL_00f7;
				case 4:
					<>1__state = -1;
					goto IL_0292;
				case 5:
					<>1__state = -1;
					if (!Flatline.registered || isQueuedForDeath)
					{
						return false;
					}
					goto IL_042a;
				case 6:
					<>1__state = -1;
					<>2__current = Flatline.Wait5;
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					if (!Flatline.registered || isQueuedForDeath)
					{
						return false;
					}
					DebugModule.Log("Resume ragdoll recover", "PrePlayerPassOut");
					goto IL_042a;
				case 8:
					{
						<>1__state = -1;
						break;
					}
					IL_0292:
					if (<current>5__5 < <duration>5__4)
					{
						if (!Flatline.registered || isQueuedForDeath)
						{
							return false;
						}
						<current>5__5 += Time.deltaTime;
						num = <current>5__5 / <duration>5__4;
						Singleton<PostProcessingManager>.Instance.SetBlur(num);
						PlayerMovement.StaticMoveSpeedMultiplier = Mathf.Lerp(1f, 0f, num);
						if (num > 0.375f)
						{
							Singleton<EyelidOverlay>.Instance.CurrentOpen = Mathf.Lerp(1f, 0f, num);
						}
						if (!<hasSetRagdolled>5__6 && num > 0.1f)
						{
							<hasSetRagdolled>5__6 = true;
							Player.Local.IsUnconscious = true;
							Singleton<GameInput>.Instance.ExitAll();
							PlayerSingleton<PlayerInventory>.Instance.SetInventoryEnabled(false);
							Flatline.coros.Add(MelonCoroutines.Start(FPRagdoll(<shouldSleep>5__3, ShouldWake)));
						}
						<>2__current = null;
						<>1__state = 4;
						return true;
					}
					Singleton<EyelidOverlay>.Instance.CurrentOpen = 0f;
					Singleton<PostProcessingManager>.Instance.SetBlur(1f);
					if (!Flatline.registered || isQueuedForDeath)
					{
						return false;
					}
					if (<shouldRob>5__2)
					{
						float num2 = 0f;
						if (NetworkSingleton<MoneyManager>.Instance.cashBalance > 50f)
						{
							num2 = Mathf.Round(NetworkSingleton<MoneyManager>.Instance.cashBalance * 0.85f);
						}
						if (num2 != 0f)
						{
							NetworkSingleton<MoneyManager>.Instance.ChangeCashBalance(0f - num2, false, false);
						}
					}
					if (<shouldSleep>5__3)
					{
						NetworkSingleton<TimeManager>.Instance.StartSleep();
					}
					else
					{
						int num3 = TimeManager.AddMinutesTo24HourTime(NetworkSingleton<TimeManager>.Instance.CurrentTime, 180);
						NetworkSingleton<TimeManager>.Instance.SkipForwardToTime(num3);
						Flatline.loadedPlayerData.State.Energy += 0.33f;
					}
					if (!<shouldSleep>5__3)
					{
						<>2__current = Flatline.Wait5;
						<>1__state = 5;
						return true;
					}
					DebugModule.Log("Waiting until sleep ends to recover ragdoll...", "PrePlayerPassOut");
					val = new WaitUntil((Func<bool>)(() => !Flatline.registered || !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress));
					<>2__current = val;
					<>1__state = 6;
					return true;
					IL_042a:
					<>8__1.shouldWakeNow = true;
					<current>5__5 = 0f;
					num = 0f;
					break;
					IL_00f7:
					Singleton<EyelidOverlay>.Instance.AutoUpdate = false;
					<shouldRob>5__2 = false;
					if ((Object)(object)Player.Local.CurrentProperty == (Object)null)
					{
						<shouldRob>5__2 = true;
					}
					<shouldSleep>5__3 = false;
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime > 30 && NetworkSingleton<TimeManager>.Instance.CurrentTime < 701)
					{
						if (!InstanceFinder.IsServer)
						{
							DebugModule.Log("Server client cannot sleep through the night during pass out", "PrePlayerPassOut");
						}
						else
						{
							<shouldSleep>5__3 = true;
						}
					}
					<duration>5__4 = 6f;
					<current>5__5 = 0f;
					<hasSetRagdolled>5__6 = false;
					<>8__1.shouldWakeNow = false;
					<moveSpeed>5__7 = PlayerMovement.StaticMoveSpeedMultiplier;
					num = 0f;
					goto IL_0292;
					IL_00a8:
					if (isFPRagdollActive || Player.Local.IsRagdolled)
					{
						WaitUntil val2 = new WaitUntil((Func<bool>)(() => !Flatline.registered || (!isFPRagdollActive && !Player.Local.IsRagdolled)));
						<>2__current = val2;
						<>1__state = 3;
						return true;
					}
					goto IL_00f7;
				}
				if (<current>5__5 < <duration>5__4)
				{
					if (!Flatline.registered || isQueuedForDeath)
					{
						return false;
					}
					<current>5__5 += Time.deltaTime;
					num = <current>5__5 / <duration>5__4;
					Singleton<PostProcessingManager>.Instance.SetBlur(Mathf.Lerp(1f, 0f, num));
					Singleton<EyelidOverlay>.Instance.CurrentOpen = num;
					<>2__current = null;
					<>1__state = 8;
					return true;
				}
				Singleton<EyelidOverlay>.Instance.CurrentOpen = 1f;
				Singleton<EyelidOverlay>.Instance.AutoUpdate = true;
				Singleton<PostProcessingManager>.Instance.SetBlur(0f);
				PlayerMovement.StaticMoveSpeedMultiplier = <moveSpeed>5__7;
				PlayerSingleton<PlayerInventory>.Instance.SetInventoryEnabled(true);
				Player.Local.IsUnconscious = false;
				isPassedOut = false;
				return false;
				bool ShouldWake()
				{
					return ((<>c__DisplayClass44_0)this).shouldWakeNow;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateSliderState>d__49 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateSliderState>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Flatline.registered || (isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if ((Player.PlayerList.Count <= 1 || Player.Local.Health.IsAlive) && stateChanged && !Flatline.isSaving && !Singleton<SaveManager>.Instance.IsSaving && !Flatline.haltExecution)
					{
						stateChanged = false;
						if ((Object)(object)FlatlineUIModule.ThirstSlider != (Object)null)
						{
							FlatlineUIModule.ThirstSlider.value = Flatline.loadedPlayerData.State.Thirst;
						}
						if ((Object)(object)FlatlineUIModule.HungerSlider != (Object)null)
						{
							FlatlineUIModule.HungerSlider.value = Flatline.loadedPlayerData.State.Hunger;
						}
						if ((Object)(object)FlatlineUIModule.EnergySlider != (Object)null)
						{
							FlatlineUIModule.EnergySlider.value = Flatline.loadedPlayerData.State.Energy;
						}
						if ((Object)(object)FlatlineUIModule.TemperatureSlider != (Object)null)
						{
							FlatlineUIModule.TemperatureSlider.value = Flatline.loadedPlayerData.State.Temperature;
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = Flatline.Wait05;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WhileSprinting>d__50 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WhileSprinting>d__50(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Flatline.registered || (isQueuedForDeath && Flatline.currentConfig.PermanentDeath) || Flatline.haltExecution)
					{
						return false;
					}
					if ((Player.PlayerList.Count <= 1 || Player.Local.Health.IsAlive) && !Flatline.isSaving && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
					{
						SetEnergy(Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy - extraEnergyConsumptionWhileRunning));
						if (Flatline.loadedPlayerData.State.Temperature < 0.8f)
						{
							SetTemperature(Mathf.Clamp01(Flatline.loadedPlayerData.State.Temperature + extraTemperatureIncreaseWhileRunning));
						}
						sprintReserveSeconds = Mathf.Clamp(sprintReserveSeconds - 0.5f, 0f, MaxSprintReserveSeconds);
						if (!isSprintExhausted && sprintReserveSeconds < 0.5f)
						{
							DebugModule.Log("Set sprint exhausted", "WhileSprinting");
							isSprintExhausted = true;
							PlayerSingleton<PlayerMovement>.Instance.IsSprinting = false;
							PlayerSingleton<PlayerMovement>.Instance.AddSprintBlocker("Exhaustion");
						}
						if (PlayerSingleton<PlayerMovement>.Instance.IsGrounded && Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken && Random.Range(0, 30) == 0 && Flatline.loadedPlayerData.State.healthData.CurrentHP > 0f)
						{
							float num2 = Random.Range(5f, 10f);
							if (Player.Local.Health.CurrentHealth - num2 <= 0f)
							{
								FlatlineUIModule.causeOfDeath = "Leg bone fracture";
							}
							Player.Local.Health.TakeDamage(num2, true, false);
							AppendDamageSource($"Leg bone damage (-{Mathf.RoundToInt(num2)}HP)");
							Flatline.coros.Add(MelonCoroutines.Start(FPRagdoll()));
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = Flatline.Wait05;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly float SystematicHomeostasisSpeed = 0.0013888889f;

		public static float DefaultThirstConsumption = 0.00087958f;

		public static float ThirstConsumptionPerMinute = DefaultThirstConsumption;

		public static float DefaultFoodConsumption = 0.0015f;

		public static float FoodConsumptionPerMinute = DefaultFoodConsumption;

		public static float DefaultEnergyConsumption = 0.0007f;

		public static float EnergyConsumptionPerMinute = DefaultEnergyConsumption;

		public static readonly float PunchEnergyConsumption = 0.001f;

		public static readonly float JumpEnergyConsumption = 0.0032f;

		public static readonly float ParasympatheticActiveTempDecreasePerMinute = 0.00035f;

		public static float TemperatureConsumptionPerMinutePerDegreeDiff = 0.00022f;

		public static readonly float TemperatureIncreasePerMinuteInside = 0.0035f;

		public static float TemperatureConsumption = TemperatureConsumptionPerMinutePerDegreeDiff;

		public static readonly float DefaultHealthRegeneration = 0.0006944f;

		public static float HealthRegenPerMinute = DefaultHealthRegeneration;

		public static readonly float MaxSprintReserveSeconds = 15f;

		public static float sprintReserveSeconds = MaxSprintReserveSeconds;

		public static readonly float extraEnergyConsumptionWhileRunning = 0.0005f;

		public static readonly float extraTemperatureIncreaseWhileRunning = 2.5E-05f;

		public static readonly float DefaultSprintReserveRegenPerMinute = 0.66f;

		public static float sprintReserveRegenPerMinute = DefaultSprintReserveRegenPerMinute;

		public static bool isSprintExhausted = false;

		public static bool isPassedOut = false;

		public static bool isQueuedForDeath = false;

		public static bool isFPRagdollActive = false;

		public static bool stateChanged = false;

		public static readonly List<string> warmClothesPaths = new List<string>
		{
			"Avatar/Layers/Bottom/Jeans", "Avatar/Layers/Top/Overalls", "Avatar/Layers/Bottom/CargoPants", "Avatar/Layers/Top/Buttonup", "Avatar/Layers/Top/FlannelButtonUp", "Avatar/Layers/Accessories/Gloves", "Avatar/Accessories/Chest/CollarJacket/CollarJacket", "Avatar/Accessories/Chest/Blazer/Blazer", "Avatar/Accessories/Feet/Sneakers/Sneakers", "Avatar/Accessories/Feet/CombatBoots/CombatBoots",
			"Avatar/Accessories/Feet/DressShoes/DressShoes", "Avatar/Accessories/Head/Beanie/Beanie"
		};

		public static readonly int maxBodyLayerClothes = 3;

		public static readonly int maxAccessoryLayerClothes = 3;

		public static float OutsideTemperatureCelsius = 17f;

		public static float dayTempTarget = 20f;

		public static float nightTempTarget = 5f;

		public static readonly float maxOutTempCelsius = 23f;

		public static readonly float minOutTempCelsius = -1f;

		public static float playerClothingAmount = 0.33f;

		public static int minsInsideProperty = 0;

		public static int minsOutsideProperty = 0;

		public static int minsWithSunnyWeather = 0;

		public static bool insideWarmBuilding = false;

		public static AudioSource flatlinePlayerAudio;

		public static List<string> lastDamageSources = new List<string>();

		public static void InitFlatlinePlayer()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00de: 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)
			Player.Local.Health.CurrentHealth = Flatline.loadedPlayerData.State.healthData.CurrentHP;
			Player.Local.Energy.CurrentEnergy = Mathf.Lerp(1f, 100f, Flatline.loadedPlayerData.State.Energy);
			FlatlineUIModule.ThirstSlider.value = Flatline.loadedPlayerData.State.Thirst;
			FlatlineUIModule.HungerSlider.value = Flatline.loadedPlayerData.State.Hunger;
			FlatlineUIModule.EnergySlider.value = Flatline.loadedPlayerData.State.Energy;
			FlatlineUIModule.TemperatureSlider.value = Flatline.loadedPlayerData.State.Temperature;
			GameObject val = new GameObject("FlatlinePlayerAudio");
			val.transform.parent = ((Component)Player.Local).transform.root;
			val.transform.localPosition = Vector3.zero;
			flatlinePlayerAudio = val.AddComponent<AudioSource>();
			flatlinePlayerAudio.volume = 0.7f;
			flatlinePlayerAudio.loop = false;
			val.SetActive(true);
			((Behaviour)flatlinePlayerAudio).enabled = true;
			if (Flatline.currentConfig.WorldTemperatureChanges)
			{
				float num = Mathf.Lerp(2f, 20f, Mathf.Sin(NetworkSingleton<TimeManager>.Instance.NormalizedTimeOfDay * 2f * (float)Math.PI - (float)Math.PI / 2f));
				OutsideTemperatureCelsius = Mathf.MoveTowards(num, GetWeatherAdjustedWorldTemp(num, 5f, 17f), 2.5f);
			}
			else
			{
				OutsideTemperatureCelsius = 20f;
			}
			if ((Object)(object)FlatlineUIModule.WorldTemperature != (Object)null)
			{
				string arg = (Flatline.currentConfig.FahrenheitTemp ? FlatlineUIModule.fahrenheitSign : FlatlineUIModule.celsiusSign);
				int num2 = (Flatline.currentConfig.FahrenheitTemp ? Mathf.RoundToInt(FlatlineUIModule.CelsiusToFahrenheit(OutsideTemperatureCelsius)) : Mathf.RoundToInt(OutsideTemperatureCelsius));
				FlatlineUIModule.WorldTemperature.text = $"{num2}{arg}";
			}
			Singleton<AudioManager>.Instance.onVolumeSettingsChanged = (Action)Delegate.Combine(Singleton<AudioManager>.Instance.onVolumeSettingsChanged, new Action(OnAudioSettingsChanged));
			DebugModule.Log("Finished init player", "InitFlatlinePlayer");
		}

		public static void ResetFlatlinePlayer()
		{
			ThirstConsumptionPerMinute = DefaultThirstConsumption;
			FoodConsumptionPerMinute = DefaultFoodConsumption;
			EnergyConsumptionPerMinute = DefaultEnergyConsumption;
			TemperatureConsumption = TemperatureConsumptionPerMinutePerDegreeDiff;
			HealthRegenPerMinute = DefaultHealthRegeneration;
			sprintReserveSeconds = MaxSprintReserveSeconds;
			sprintReserveRegenPerMinute = DefaultSprintReserveRegenPerMinute;
			isSprintExhausted = false;
			isPassedOut = false;
			isQueuedForDeath = false;
			isFPRagdollActive = false;
			stateChanged = false;
			OutsideTemperatureCelsius = 20f;
			playerClothingAmount = 0.33f;
			minsInsideProperty = 0;
			minsOutsideProperty = 0;
			minsWithSunnyWeather = 0;
			flatlinePlayerAudio = null;
			insideWarmBuilding = false;
		}

		[IteratorStateMachine(typeof(<PrePlayerDied>d__43))]
		public static IEnumerator PrePlayerDied()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PrePlayerDied>d__43(0);
		}

		[IteratorStateMachine(typeof(<PrePlayerPassOut>d__44))]
		public static IEnumerator PrePlayerPassOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PrePlayerPassOut>d__44(0);
		}

		public static void OnSleepEnd()
		{
			if (Flatline.haltExecution)
			{
				return;
			}
			SetEnergy(1f);
			SetFood(Flatline.loadedPlayerData.State.Hunger * 0.66f);
			SetWater(Flatline.loadedPlayerData.State.Thirst * 0.66f);
			SetTemperature(Flatline.loadedPlayerData.State.Temperature * 0.9f);
			if (Flatline.currentConfig.DiseasesEnabled && Flatline.currentConfig.FeverEnabled)
			{
				bool flag = false;
				foreach (Disease allDisease in PlayerDiseaseDamage.allDiseases)
				{
					if (allDisease.GetType() == typeof(Fever) && allDisease.data.Active)
					{
						flag = true;
					}
				}
				if (!flag)
				{
					Flatline.loadedPlayerData.State.healthData.daysSinceFlu++;
				}
				else
				{
					Flatline.loadedPlayerData.State.healthData.daysSinceFlu = 0;
				}
			}
			if (Flatline.currentConfig.WorldTemperatureChanges)
			{
				dayTempTarget = Random.Range(16f, maxOutTempCelsius);
				nightTempTarget = Random.Range(minOutTempCelsius, 6f);
				OutsideTemperatureCelsius = GetWeatherAdjustedWorldTemp(Mathf.Lerp(OutsideTemperatureCelsius, nightTempTarget, 0.66f), nightTempTarget, nightTempTarget + 6f);
			}
		}

		public static void OnMinPass()
		{
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0842: Unknown result type (might be due to invalid IL or missing references)
			if (Flatline.isSaving || !Flatline.registered || isPassedOut || isQueuedForDeath || NetworkSingleton<TimeManager>.Instance.IsSleepInProgress || Flatline.haltExecution || (NetworkSingleton<TimeManager>.Instance.CurrentTime < 659 && NetworkSingleton<TimeManager>.Instance.CurrentTime > 400) || (Player.PlayerList.Count > 1 && !Player.Local.Health.IsAlive))
			{
				return;
			}
			bool num = Flatline.loadedPlayerData.State.Hunger >= 0.9f;
			if (num)
			{
				SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - ThirstConsumptionPerMinute * Random.Range(1.05f, 1.15f)));
			}
			else
			{
				SetWater(Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - ThirstConsumptionPerMinute));
			}
			SetFood(Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger - FoodConsumptionPerMinute));
			if (num)
			{
				SetEnergy(Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy - EnergyConsumptionPerMinute * Random.Range(0.55f, 0.7f)));
			}
			else
			{
				SetEnergy(Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy - EnergyConsumptionPerMinute));
			}
			Player.Local.Energy.CurrentEnergy = Mathf.Lerp(1f, 100f, Flatline.loadedPlayerData.State.Energy);
			if (!Mathf.Approximately(PlayerMovement.StaticMoveSpeedMultiplier, Flatline.loadedPlayerData.State.healthData.MoveSpeedScale))
			{
				PlayerMovement.StaticMoveSpeedMultiplier = Mathf.Lerp(PlayerMovement.StaticMoveSpeedMultiplier, Flatline.loadedPlayerData.State.healthData.MoveSpeedScale, 0.15f);
			}
			if (Player.Local.Health.CurrentHealth > Flatline.loadedPlayerData.State.healthData.MaxHP)
			{
				Player.Local.Health.CurrentHealth = Flatline.loadedPlayerData.State.healthData.MaxHP;
				if (Player.Local.Health.onHealthChanged != null)
				{
					Player.Local.Health.onHealthChanged.Invoke(Player.Local.Health.CurrentHealth);
				}
			}
			if (!Mathf.Approximately(Player.Local.Health.CurrentHealth, Flatline.loadedPlayerData.State.healthData.CurrentHP))
			{
				Flatline.loadedPlayerData.State.healthData.CurrentHP = Player.Local.Health.CurrentHealth;
			}
			if (Flatline.loadedPlayerData.State.Thirst > 0.2f && Flatline.loadedPlayerData.State.Hunger > 0.1f && Flatline.loadedPlayerData.State.healthData.CurrentHP != 0f && Flatline.loadedPlayerData.State.healthData.CurrentHP < Flatline.loadedPlayerData.State.healthData.MaxHP)
			{
				Flatline.loadedPlayerData.State.healthData.CurrentHP = Mathf.Clamp(Player.Local.Health.CurrentHealth + HealthRegenPerMinute, 0f, Flatline.loadedPlayerData.State.healthData.MaxHP);
				Player.Local.Health.CurrentHealth = Flatline.loadedPlayerData.State.healthData.CurrentHP;
				if (Player.Local.Health.onHealthChanged != null)
				{
					Player.Local.Health.onHealthChanged.Invoke(Player.Local.Health.CurrentHealth);
				}
			}
			if (Flatline.loadedPlayerData.State.Hunger >= 0.9f)
			{
				Flatline.loadedPlayerData.State.healthData.Gluttony = Mathf.Clamp01(Flatline.loadedPlayerData.State.healthData.Gluttony + 3.2E-05f);
			}
			else if (Flatline.loadedPlayerData.State.Hunger >= 0.8f && Flatline.loadedPlayerData.State.Hunger < 0.9f)
			{
				Flatline.loadedPlayerData.State.healthData.Gluttony = Mathf.Clamp01(Flatline.loadedPlayerData.State.healthData.Gluttony + 1.5E-05f);
			}
			else if (Flatline.loadedPlayerData.State.Hunger < 0.5f && Flatline.loadedPlayerData.State.Hunger >= 0.3f)
			{
				Flatline.loadedPlayerData.State.healthData.Gluttony = Mathf.Clamp01(Flatline.loadedPlayerData.State.healthData.Gluttony - 1.5E-05f);
			}
			else if (Flatline.loadedPlayerData.State.Hunger < 0.3f)
			{
				Flatline.loadedPlayerData.State.healthData.Gluttony = Mathf.Clamp01(Flatline.loadedPlayerData.State.healthData.Gluttony - 3.2E-05f);
			}
			if (!PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
			{
				sprintReserveSeconds = Mathf.Clamp(sprintReserveSeconds + sprintReserveRegenPerMinute, 0f, MaxSprintReserveSeconds);
			}
			if (Flatline.loadedPlayerData.State.Energy <= 0.2f)
			{
				if (!isSprintExhausted)
				{
					DebugModule.Log("Set Exhausted Minpass", "OnMinPass");
					isSprintExhausted = true;
					PlayerSingleton<PlayerMovement>.Instance.AddSprintBlocker("Exhaustion");
					if (PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
					{
						PlayerSingleton<PlayerMovement>.Instance.IsSprinting = false;
					}
					if (PlayerSingleton<PlayerMovement>.Instance.ForceSprint)
					{
						PlayerSingleton<PlayerMovement>.Instance.ForceSprint = false;
					}
				}
			}
			else if (Flatline.loadedPlayerData.State.Energy > 0.2f && isSprintExhausted && sprintReserveSeconds > 5f)
			{
				DebugModule.Log("Remove Exhausted Minpass", "OnMinPass");
				PlayerSingleton<PlayerMovement>.Instance.RemoveSprintBlocker("Exhaustion");
				isSprintExhausted = false;
			}
			bool num2 = (Object)(object)Player.Local.CurrentProperty != (Object)null;
			bool flag = (Object)(object)Player.Local.CurrentBusiness != (Object)null;
			bool isInVehicle = Player.Local.IsInVehicle;
			bool flag2 = Singleton<SewerCameraPresense>.Instance.IsPointInSewerArea(Player.Local.CenterPointTransform.position);
			if (num2)
			{
				minsInsideProperty++;
			}
			else
			{
				minsOutsideProperty++;
			}
			WeatherConditions currentWeatherConditions = NetworkSingleton<EnvironmentManager>.Instance.CurrentWeatherConditions;
			if (currentWeatherConditions.Sunny > 0.5f && currentWeatherConditions.Cloudy <= 0.49f && currentWeatherConditions.Rainy <= 0.25f && currentWeatherConditions.Stormy <= 0.25f)
			{
				minsWithSunnyWeather++;
			}
			float num3 = 0f;
			num3 = (num2 ? Player.Local.CurrentProperty.AmbientTemperature : (flag ? ((Property)Player.Local.CurrentBusiness).AmbientTemperature : (isInVehicle ? 20f : (flag2 ? Random.Range(8f, 14f) : ((!insideWarmBuilding) ? OutsideTemperatureCelsius : Random.Range(16f, 18.9f))))));
			if (num2 && Player.Local.CurrentProperty.propertyCode == "seweroffice" && PropertyTemperatureController.propertyHeaterCounts.ContainsKey("seweroffice"))
			{
				int count = PropertyTemperatureController.propertyHeaterCounts["seweroffice"].Count;
				num3 = Mathf.Lerp(Player.Local.CurrentProperty.AmbientTemperature, 20f, Mathf.Clamp01((float)count / 3f));
			}
			bool flag3 = false;
			if (num3 <= 17f)
			{
				flag3 = true;
				float num4 = (37f - num3) * TemperatureConsumption;
				num4 = Mathf.Lerp(num4, TemperatureConsumptionPerMinutePerDegreeDiff, playerClothingAmount * 0.9f);
				SetTemperature(Mathf.Clamp01(Flatline.loadedPlayerData.State.Temperature - num4));
			}
			else if (Flatline.loadedPlayerData.State.Temperature < 0.9f && num3 > 17f)
			{
				SetTemperature(Mathf.Clamp01(Flatline.loadedPlayerData.State.Temperature + TemperatureIncreasePerMinuteInside * (1f + playerClothingAmount)));
			}
			if (num)
			{
				bool flag4 = PlayerSingleton<PlayerMovement>.Instance.Movement.x > 0.01f || PlayerSingleton<PlayerMovement>.Instance.Movement.z > 0.01f;
				if (Flatline.loadedPlayerData.State.Temperature > 0.25f && !flag3 && flag4)
				{
					SetTemperature(Flatline.loadedPlayerData.State.Temperature - ParasympatheticActiveTempDecreasePerMinute * 0.66f);
				}
				else if (Flatline.loadedPlayerData.State.Temperature > 0.25f && !flag3 && !flag4)
				{
					SetTemperature(Flatline.loadedPlayerData.State.Temperature - ParasympatheticActiveTempDecreasePerMinute * 0.88f);
				}
				else if (Flatline.loadedPlayerData.State.Temperature > 0.25f && flag3 && flag4)
				{
					SetTemperature(Flatline.loadedPlayerData.State.Temperature - ParasympatheticActiveTempDecreasePerMinute);
				}
				else if (Flatline.loadedPlayerData.State.Temperature > 0.25f && flag3 && !flag4)
				{
					SetTemperature(Flatline.loadedPlayerData.State.Temperature - ParasympatheticActiveTempDecreasePerMinute * 1.33f);
				}
			}
			EvaluatePlayerStatus();
			stateChanged = true;
		}

		public static void OnHourPass()
		{
			if (Flatline.isSaving || !Flatline.registered || isPassedOut || isQueuedForDeath || NetworkSingleton<TimeManager>.Instance.IsSleepInProgress || Flatline.haltExecution || (NetworkSingleton<TimeManager>.Instance.CurrentTime < 659 && NetworkSingleton<TimeManager>.Instance.CurrentTime > 400) || (Player.PlayerList.Count > 1 && !Player.Local.Health.IsAlive))
			{
				return;
			}
			if (Flatline.currentConfig.WorldTemperatureChanges)
			{
				float num = minOutTempCelsius;
				float num2 = maxOutTempCelsius;
				bool flag = false;
				if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1600 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 700)
				{
					bool flag2 = NetworkSingleton<TimeManager>.Instance.CurrentTime <= 400;
					num2 -= (float)Random.Range(1, 3);
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1700 || flag2)
					{
						num2 -= (float)Random.Range(2, 4);
					}
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1900 || flag2)
					{
						num2 -= (float)Random.Range(2, 4);
					}
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 2100 || flag2)
					{
						num2 -= 5f;
					}
					num2 = Mathf.Clamp(num2, 8f, maxOutTempCelsius);
				}
				else if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 700 && NetworkSingleton<TimeManager>.Instance.CurrentTime <= 1600)
				{
					flag = true;
					num += (float)Random.Range(1, 4);
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 900)
					{
						num += (float)Random.Range(2, 4);
					}
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1100)
					{
						num += (float)Random.Range(3, 4);
					}
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1300)
					{
						num += 5f;
					}
					num = Mathf.Clamp(num, minOutTempCelsius, 15f);
				}
				if (num >= num2)
				{
					num = num2 - 2f;
				}
				else if (num2 <= num)
				{
					num2 = num + 2f;
				}
				float num3 = 0.15f;
				if ((NetworkSingleton<TimeManager>.Instance.CurrentTime >= 659 && NetworkSingleton<TimeManager>.Instance.CurrentTime < 1200) || (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1700 && NetworkSingleton<TimeManager>.Instance.CurrentTime < 2100))
				{
					num3 = 0.26f;
				}
				float num4 = Mathf.Lerp(GetWeatherAdjustedWorldTemp(Mathf.Lerp(OutsideTemperatureCelsius, Random.Range(num, num2), num3 / 3f), num, num2), flag ? dayTempTarget : nightTempTarget, num3 / 1.66f);
				OutsideTemperatureCelsius = Mathf.MoveTowards(OutsideTemperatureCelsius, num4, 2.5f);
			}
			else
			{
				OutsideTemperatureCelsius = 20f;
			}
			if ((Object)(object)FlatlineUIModule.WorldTemperature != (Object)null)
			{
				string arg = (Flatline.currentConfig.FahrenheitTemp ? FlatlineUIModule.fahrenheitSign : FlatlineUIModule.celsiusSign);
				int num5 = (Flatline.currentConfig.FahrenheitTemp ? Mathf.RoundToInt(FlatlineUIModule.CelsiusToFahrenheit(OutsideTemperatureCelsius)) : Mathf.RoundToInt(OutsideTemperatureCelsius));
				FlatlineUIModule.WorldTemperature.text = $"{num5}{arg}";
			}
			playerClothingAmount = EvaluatePlayerClothing();
		}

		public static void EvaluatePlayerStatus()
		{
			if (Flatline.loadedPlayerData.State.Thirst <= 0.01f)
			{
				FlatlineUIModule.causeOfDeath = "Dehydration";
				Flatline.coros.Add(MelonCoroutines.Start(PrePlayerDied()));
			}
			else if (Flatline.loadedPlayerData.State.Hunger <= 0.01f)
			{
				FlatlineUIModule.causeOfDeath = "Starving";
				Flatline.coros.Add(MelonCoroutines.Start(PrePlayerDied()));
			}
			else if (Flatline.loadedPlayerData.State.Temperature <= 0.01f)
			{
				FlatlineUIModule.causeOfDeath = "Hypothermia";
				Flatline.coros.Add(MelonCoroutines.Start(PrePlayerDied()));
			}
			else if (Flatline.loadedPlayerData.State.Energy <= 0.01f && !isPassedOut && !isQueuedForDeath)
			{
				Flatline.coros.Add(MelonCoroutines.Start(PrePlayerPassOut()));
			}
		}

		[IteratorStateMachine(typeof(<UpdateSliderState>d__49))]
		public static IEnumerator UpdateSliderState()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateSliderState>d__49(0);
		}

		[IteratorStateMachine(typeof(<WhileSprinting>d__50))]
		public static IEnumerator WhileSprinting()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WhileSprinting>d__50(0);
		}

		[IteratorStateMachine(typeof(<FPRagdoll>d__51))]
		public static IEnumerator FPRagdoll(bool waitSleepEnd = false, Func<bool> waitState = null, int forceDown = -1)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FPRagdoll>d__51(0)
			{
				waitSleepEnd = waitSleepEnd,
				waitState = waitState,
				forceDown = forceDown
			};
		}

		[IteratorStateMachine(typeof(<EnsureSystematicHomeostasis>d__52))]
		public static IEnumerator EnsureSystematicHomeostasis()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureSystematicHomeostasis>d__52(0);
		}

		public static float EvaluatePlayerClothing()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			foreach (LayerSetting bodyLayerSetting in Player.Local.Avatar.CurrentSettings.BodyLayerSettings)
			{
				if (num == maxBodyLayerClothes)
				{
					break;
				}
				if (warmClothesPaths.Contains(bodyLayerSetting.layerPath))
				{
					num++;
				}
			}
			foreach (AccessorySetting accessorySetting in Player.Local.Avatar.CurrentSettings.AccessorySettings)
			{
				if (num2 == maxBodyLayerClothes)
				{
					break;
				}
				if (warmClothesPaths.Contains(accessorySetting.path))
				{
					num2++;
				}
			}
			return (float)(num2 + num) / 6f;
		}

		public static void AppendDamageSource(string source)
		{
			lastDamageSources.Insert(0, source);
			if (lastDamageSources.Count >= 10)
			{
				lastDamageSources.RemoveAt(lastDamageSources.Count - 1);
			}
		}

		public static bool IsPointInsideBox(Vector3 playerPos, BoxCollider bc)
		{
			//IL_0006: 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_000f: 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_001b: 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_002a: 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_0036: 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_0049: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)bc).transform.InverseTransformPoint(playerPos);
			val -= bc.center;
			Vector3 val2 = bc.size * 0.5f;
			if (Mathf.Abs(val.x) <= val2.x && Mathf.Abs(val.y) <= val2.y)
			{
				return Mathf.Abs(val.z) <= val2.z;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<LazyUpdatePlayerWarmBuilding>d__56))]
		public static IEnumerator LazyUpdatePlayerWarmBuilding()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LazyUpdatePlayerWarmBuilding>d__56(0);
		}

		public static void OnAudioSettingsChanged()
		{
			float volume = Singleton<AudioManager>.Instance.GetVolume((EAudioType)2, true);
			DebugModule.Log("Changing volume " + volume, "OnAudioSettingsChanged");
			if ((Object)(object)flatlinePlayerAudio != (Object)null)
			{
				flatlinePlayerAudio.volume = volume;
			}
			if ((Object)(object)FlatlineIngestibles.ingestorAudio != (Object)null)
			{
				FlatlineIngestibles.ingestorAudio.volume = volume;
			}
			if ((Object)(object)PlayerConsumeDamage.heartBeatSource != (Object)null)
			{
				PlayerConsumeDamage.heartBeatSource.volume = volume;
			}
		}

		public static float GetWeatherAdjustedWorldTemp(float temp, float currentMin, float currentMax)
		{
			WeatherConditions currentWeatherConditions = NetworkSingleton<EnvironmentManager>.Instance.CurrentWeatherConditions;
			float num = currentWeatherConditions.Sunny + currentWeatherConditions.Cloudy + currentWeatherConditions.Windy + currentWeatherConditions.Foggy + currentWeatherConditions.Rainy + currentWeatherConditions.Stormy + currentWeatherConditions.Sleet + currentWeatherConditions.Hail + currentWeatherConditions.Snowy;
			float num2 = NetworkSingleton<TimeManager>.Instance.CurrentTime;
			float num3 = ((num2 > 600f && num2 < 1800f) ? 1f : 0f);
			float num4 = currentWeatherConditions.Sunny * num3 / num;
			float num5 = (currentWeatherConditions.Foggy + currentWeatherConditions.Rainy + currentWeatherConditions.Stormy) / num;
			float num6 = (currentWeatherConditions.Cloudy + currentWeatherConditions.Windy) / num;
			float num7 = (currentWeatherConditions.Snowy + currentWeatherConditions.Sleet + currentWeatherConditions.Hail) / num;
			return Mathf.Lerp(Mathf.Lerp(Mathf.Lerp(Mathf.Lerp(temp, currentMax, num4 * (currentWeatherConditions.Sunny * num3)), currentMin, num5 * 0.25f), currentMin, num6 * 0.33f), currentMin, num7 * 0.53f);
		}

		public static void SetWater(float val)
		{
			if (Flatline.currentConfig.WaterRequired)
			{
				Flatline.loadedPlayerData.State.Thirst = val;
			}
		}

		public static void SetFood(float val)
		{
			if (Flatline.currentConfig.FoodRequired)
			{
				Flatline.loadedPlayerData.State.Hunger = val;
			}
		}

		public static void SetEnergy(float val)
		{
			if (Flatline.currentConfig.EnergyRequired)
			{
				Flatline.loadedPlayerData.State.Energy = val;
			}
		}

		public static void SetTemperature(float val)
		{
			if (Flatline.currentConfig.TemperatureRequired)
			{
				Flatline.loadedPlayerData.State.Temperature = val;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "MinPass")]
	public static class PlayerHealth_MinPass_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PlayerHealth __instance)
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerEnergy), "MinPass")]
	public static class PlayerEnergy_MinPass_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PlayerEnergy __instance)
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "ReceiveImpact")]
	public static class Player_ReceiveImpact_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(Player __instance, Impact impact)
		{
			//IL_0024: 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)
			if (Flatline.haltExecution)
			{
				return true;
			}
			if ((Object)(object)((NetworkBehaviour)__instance).NetworkObject == (Object)(object)impact.ImpactSource)
			{
				return false;
			}
			FlatlinePlayer.AppendDamageSource($"{impact.ImpactType} impact damage (-{Mathf.RoundToInt(impact.ImpactDamage)}HP)");
			if (Player.Local.Health.CurrentHealth - impact.ImpactDamage <= 0f)
			{
				FlatlineUIModule.causeOfDeath = $"{impact.ImpactType} impact";
			}
			else
			{
				try
				{
					PlayerDiseaseDamage.CalculateImpact(impact);
				}
				catch (Exception ex)
				{
					DebugModule.Log("Failed to process impact: " + ex, "Player_ReceiveImpact_Patch");
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeProduct")]
	public static class Player_ConsumeProduct_Patch
	{
		private static string cukePseudoProductID = string.Empty;

		private static string energyDrinkPseudoProductID = string.Empty;

		public static void AssignPseudoProductIDs()
		{
			if (cukePseudoProductID == string.Empty || energyDrinkPseudoProductID == string.Empty)
			{
				Func<string, ItemDefinition> func = Registry.GetItem;
				ItemDefinition val = func("energydrink");
				ItemDefinition obj = func("cuke");
				ItemInstance defaultInstance = val.GetDefaultInstance(1);
				obj.GetDefaultInstance(1);
				Equippable_Cuke val2 = null;
				Equippable_Cuke val3 = null;
				Equippable equippable = defaultInstance.Equippable;
				val2 = (Equippable_Cuke)(object)((equippable is Equippable_Cuke) ? equippable : null);
				Equippable equippable2 = obj.Equippable;
				val3 = (Equippable_Cuke)(object)((equippable2 is Equippable_Cuke) ? equippable2 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					energyDrinkPseudoProductID = ((BaseItemDefinition)val2.PseudoProduct).ID;
				}
				else
				{
					DebugModule.Log("Failed to cast energy drink equippable", "Player_ConsumeProduct_Patch");
				}
				if ((Object)(object)val3 != (Object)null)
				{
					cukePseudoProductID = ((BaseItemDefinition)val3.PseudoProduct).ID;
				}
				else
				{
					DebugModule.Log("Failed to cast cuke drink equippable", "Player_ConsumeProduct_Patch");
				}
			}
		}

		[HarmonyPrefix]
		public static bool Prefix(Player __instance, ProductItemInstance product)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected I4, but got Unknown
			//IL_00e0: 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_0106: 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)
			if (Flatline.haltExecution)
			{
				return true;
			}
			if (!FlatlineIngestibles.ingestibleModuleInitiated)
			{
				return true;
			}
			if (!Flatline.setupCompleted)
			{
				return true;
			}
			if (Player.PlayerList.Count > 1 && !__instance.IsLocalPlayer)
			{
				return true;
			}
			if (((BaseItemInstance)product).ID == cukePseudoProductID)
			{
				FlatlineIngestibles.ProcessIngestible("cuke", (EQuality)0);
				return true;
			}
			if (((BaseItemInstance)product).ID == energyDrinkPseudoProductID)
			{
				FlatlineIngestibles.ProcessIngestible("energydrink", (EQuality)0);
				return true;
			}
			ItemDefinition definition = ((ItemInstance)product).Definition;
			ProductDefinition val = (ProductDefinition)(object)((definition is ProductDefinition) ? definition : null);
			if ((Object)(object)val == (Object)null)
			{
				DebugModule.Log("Failed to cast product definition", "Player_ConsumeProduct_Patch");
				return true;
			}
			int num = (int)val.DrugType;
			DebugModule.Log("Process drug type int: " + num, "Prefix");
			switch (num)
			{
			case 0:
				FlatlineIngestibles.ProcessIngestible("weed", ((QualityItemInstance)product).Quality, useQuality: true);
				break;
			case 1:
				FlatlineIngestibles.ProcessIngestible("meth", ((QualityItemInstance)product).Quality, useQuality: true);
				break;
			case 2:
				FlatlineIngestibles.ProcessIngestible("cocaine", ((QualityItemInstance)product).Quality, useQuality: true);
				break;
			case 3:
				DebugModule.Log("MDMA Drug Type Not Implemented", "Player_ConsumeProduct_Patch");
				break;
			case 4:
				FlatlineIngestibles.ProcessIngestible("shroom", ((QualityItemInstance)product).Quality, useQuality: true);
				break;
			case 5:
				DebugModule.Log("Heroin Drug Type Not Implemented", "Player_ConsumeProduct_Patch");
				break;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "TakeDamage")]
	public static class PlayerHealth_TakeDamage_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PlayerHealth __instance, float damage, bool flinch = true, bool playBloodMist = true)
		{
			if (Flatline.haltExecution)
			{
				return true;
			}
			if (!Flatline.setupCompleted)
			{
				return true;
			}
			if (Player.PlayerList.Count > 1 && !__instance.Player.IsLocalPlayer)
			{
				return true;
			}
			if (FlatlinePlayer.isQueuedForDeath || FlatlinePlayer.isPassedOut)
			{
				return false;
			}
			if (__instance.CurrentHealth - damage <= 0f)
			{
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PunchController), "Punch")]
	public static class PunchController_Punch_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PunchController __instance, float power)
		{
			if (!Flatline.registered)
			{
				return true;
			}
			if (Flatline.haltExecution)
			{
				return true;
			}
			if (!Flatline.setupCompleted)
			{
				return true;
			}
			if (Player.PlayerList.Count > 1 && !__instance.player.IsLocalPlayer)
			{
				return true;
			}
			if (Flatline.loadedPlayerData.State.Energy > 0.02f)
			{
				float num = Mathf.Lerp(FlatlinePlayer.PunchEnergyConsumption * 0.7f, FlatlinePlayer.PunchEnergyConsumption * 4f, Mathf.Clamp01(power));
				Flatline.loadedPlayerData.State.Energy -= num;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "Jump")]
	public static class PlayerMovement_Jump_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PlayerMovement __instance)
		{
			if (!Flatline.registered)
			{
				return true;
			}
			if (Flatline.haltExecution)
			{
				return true;
			}
			if (!Flatline.setupCompleted)
			{
				return true;
			}
			if (Player.PlayerList.Count > 1 && !__instance.Player.IsLocalPlayer)
			{
				return true;
			}
			if (Flatline.loadedPlayerData.State.Energy > 0.02f)
			{
				Flatline.loadedPlayerData.State.Energy -= FlatlinePlayer.JumpEnergyConsumption;
			}
			return true;
		}
	}
	public static class PropertyTemperatureController
	{
		[HarmonyPatch(typeof(AirConditioner), "Awake")]
		public static class AirConditioner_Awake_Patch
		{
			[HarmonyPostfix]
			public static void Postfix(AirConditioner __instance)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Invalid comparison between Unknown and I4
				if (!Flatline.currentConfig.PropertyTemperatureChanges)
				{
					return;
				}
				if ((Object)(object)((BuildableItem)__instance).ParentProperty != (Object)null)
				{
					string propertyCode = ((BuildableItem)__instance).ParentProperty.propertyCode;
					if ((int)__instance.CurrentMode == 2)
					{
						if (!propertyHeaterCounts.ContainsKey(propertyCode))
						{
							propertyHeaterCounts.Add(propertyCode, new List<int>());
						}
						if (!propertyHeaterCounts[propertyCode].Contains(((Object)__instance).GetInstanceID()))
						{
							propertyHeaterCounts[propertyCode].Add(((Object)__instance).GetInstanceID());
							DebugModule.Log($"Property {propertyCode} heater count increased to {propertyHeaterCounts[propertyCode].Count}", "Awake");
						}
					}
				}
				if (!((Object)(object)__instance.TemperatureEmitter == (Object)null))
				{
					__instance.TemperatureEmitter.OnEmitterChanged = (Action)Delegate.Combine(__instance.TemperatureEmitter.OnEmitterChanged, new Action(OnThisEmitterChanged));
				}
				void OnThisEmitterChanged()
				{
					//IL_0047: Unknown result type (might be due to invalid IL or missing references)
					//IL_004d: Invalid comparison between Unknown and I4
					if (Flatline.registered)
					{
						string text = (((Object)(object)((BuildableItem)__instance).ParentProperty != (Object)null) ? ((BuildableItem)__instance).ParentProperty.propertyCode : "");
						if (!(text == ""))
						{
							if ((int)__instance.CurrentMode == 2)
							{
								if (!propertyHeaterCounts.ContainsKey(text))
								{
									propertyHeaterCounts.Add(text, new List<int>());
								}
								if (!propertyHeaterCounts[text].Contains(((Object)__instance).GetInstanceID()))
								{
									propertyHeaterCounts[text].Add(((Object)__instance).GetInstanceID());
									DebugModule.Log($"Property heater count increased to {propertyHeaterCounts[text].Count}", "EmitterChanged");
								}
							}
							else
							{
								if (!propertyHeaterCounts.ContainsKey(text))
								{
									propertyHeaterCounts.Add(text, new List<int>());
								}
								if (propertyHeaterCounts[text].Count > 0 && propertyHeaterCounts[text].Contains(((Object)__instance).GetInstanceID()))
								{
									propertyHeaterCounts[text].Remove(((Object)__instance).GetInstanceID());
									DebugModule.Log($"Property heater count decreased to {propertyHeaterCounts[text].Count}", "EmitterChanged");
								}
							}
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(AirConditioner), "Destroy")]
		public static class AirConditioner_Destroy_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(AirConditioner __instance)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				if (!Flatline.registered)
				{
					return true;
				}
				if (!Flatline.currentConfig.PropertyTemperatureChanges)
				{
					return true;
				}
				if ((int)__instance.CurrentMode != 2)
				{
					return true;
				}
				if ((Object)(object)((BuildableItem)__instance).ParentProperty == (Object)null)
				{
					DebugModule.Log("Failed to process destroy prefix", "Destroy");
					return true;
				}
				string propertyCode = ((BuildableItem)__instance).ParentProperty.propertyCode;
				if (propertyHeaterCounts.ContainsKey(propertyCode) && propertyHeaterCounts[propertyCode].Count > 0 && propertyHeaterCounts[propertyCode].Contains(((Object)__instance).GetInstanceID()))
				{
					propertyHeaterCounts[propertyCode].Remove(((Object)__instance).GetInstanceID());
					DebugModule.Log($"Property heater count decreased to {propertyHeaterCounts[propertyCode].Count}", "Destroy");
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateAllPropertyTemperatures>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateAllPropertyTemperatures>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				Property val;
				float num2;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (Flatline.isSaving || Singleton<SaveManager>.Instance.IsSaving || Flatline.haltExecution || !Flatline.currentConfig.PropertyTemperatureChanges)
					{
						goto IL_0022;
					}
					<i>5__2 = 0;
					goto IL_07c9;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						if (!Flatline.isSaving && !Singleton<SaveManager>.Instance.IsSaving && !Flatline.haltExecution && Flatline.currentConfig.PropertyTemperatureChanges)
						{
							val = Property.Properties[<i>5__2];
							if (val.IsOwned)
							{
								bool flag = !(val.propertyCode == "dockswarehouse");
								int num = 0;
								float value = float.NaN;
								if (!PropertyTemperatureChangeMultiplier.TryGetValue(val.propertyCode, out value))
								{
									DebugModule.Log("Property does not support temp change: " + val.propertyCode, "UpdateAllPropertyTemperatures");
								}
								else
								{
									PropertyDoorController[] value2 = null;
									if (flag && propertyDoors.TryGetValue(val.propertyCode, out value2))
									{
										if (value2.Length == 0)
										{
											DebugModule.Log("Property has doors length 0! " + val.propertyCode, "UpdateAllPropertyTemperatures");
											goto IL_07b7;
										}
										PropertyDoorController[] array = value2;
										for (int i = 0; i < array.Length; i++)
										{
											if (((DoorController)array[i]).IsOpen)
											{
												num++;
											}
										}
									}
									num2 = float.NaN;
									if (!flag)
									{
										float num3 = 1f;
										float num4 = 1f - ACHeaterHeatConcentrationAdd;
										float num5 = propertyTempDefaults[val.propertyCode];
										float num6 = FlatlinePlayer.OutsideTemperatureCelsius;
										int num7 = 0;
										if (propertyHeaterCounts.Count > 0 && propertyHeaterCounts.ContainsKey(val.propertyCode))
										{
											propertyHeaterCounts.TryGetValue(val.propertyCode, out var value3);
											num7 = value3.Count;
										}
										if (num7 > 0)
										{
											num6 = Mathf.Lerp(num6, num5, Mathf.Clamp01((float)num7 / 3f));
										}
										if (val.AmbientTemperature > num6)
										{
											if (num7 > 0)
											{
												num3 = Mathf.Lerp(num3, ACHeaterHeatDissipationMin, Mathf.Clamp01((float)num7 / 3f));
											}
											num2 = EaseOutCubic(val.AmbientTemperature, num6, num3);
											DebugModule.Log($"{val.propertyCode} heat dissipation: {num2} (-{val.AmbientTemperature - num2})", "UpdateAllPropertyTemperatures");
										}
										else if (val.AmbientTemperature < num6)
										{
											if (num7 > 0)
											{
												num4 = Mathf.Lerp(num4, num4 + ACHeaterHeatConcentrationAdd, Mathf.Clamp01((float)num7 / 3f));
											}
											num2 = EaseOutCubic(val.AmbientTemperature, num6, num4);
											DebugModule.Log($"{val.propertyCode} heat accumulation: {num2} (+{num2 - val.AmbientTemperature})", "UpdateAllPropertyTemperatures");
										}
										goto IL_0715;
									}
									if (!propertyTempDefaults.ContainsKey(val.propertyCode))
									{
										DebugModule.Log("Property does not exist in temperature defaults: " + val.propertyCode, "UpdateAllPropertyTemperatures");
									}
									else
									{
										if (num <= 0 || !(val.AmbientTemperature > propertyTempDefaults[val.propertyCode] - MaximumPropertyTemperatureDrop))
										{
											if (num == 0 || val.AmbientTemperature <= propertyTempDefaults[val.propertyCode] - MaximumPropertyTemperatureDrop)
											{
												if (Mathf.Abs(val.AmbientTemperature - propertyTempDefaults[val.propertyCode]) > 0.1f)
												{
													float num8 = ClosedDoorHeatConcentrationT * value;
													int num9 = 0;
													if (propertyHeaterCounts.Count > 0 && propertyHeaterCounts.ContainsKey(val.propertyCode))
													{
														propertyHeaterCounts.TryGetValue(val.propertyCode, out var value4);
														num9 = value4.Count;
														if (num9 > 0)
														{
															num8 = Mathf.Lerp(num8, ClosedDoorHeatConcentrationT + ACHeaterHeatConcentrationAdd, Mathf.Clamp01((float)num9 / 3f));
														}
													}
													num2 = EaseOutCubic(val.AmbientTemperature, propertyTempDefaults[val.propertyCode], num8);
													DebugModule.Log($"{val.propertyCode} heat accumulation: {num2} (+{num2 - val.AmbientTemperature})", "UpdateAllPropertyTemperatures");
												}
												else
												{
													if (val.AmbientTemperature == propertyTempDefaults[val.propertyCode])
													{
														goto IL_07b7;
													}
													num2 = propertyTempDefaults[val.propertyCode];
												}
											}
											goto IL_0715;
										}
										if (value2 == null || value2.Length == 0)
										{
											DebugModule.Log("No listed doors for property!", "UpdateAllPropertyTemperatures");
										}
										else if (!(Mathf.Abs(FlatlinePlayer.OutsideTemperatureCelsius - val.AmbientTemperature) < 1.5f))
										{
											float num10 = OpenDoorHeatDissipationTMax * value;
											float num11 = OpenDoorHeatDissipationTMin * value;
											float num12 = OpenDoorHeatConcentrationTMax * value;
											float num13 = OpenDoorHeatConcentrationTMin * value;
											float num14 = Mathf.Clamp01((float)num / (float)value2.Length);
											float num15 = Mathf.Lerp(num11, num10, num14);
											float num16 = Mathf.Lerp(num13, num12, num14);
											if (val.AmbientTemperature <= FlatlinePlayer.OutsideTemperatureCelsius && val.AmbientTemperature < propertyTempDefaults[val.propertyCode])
											{
												int num17 = 0;
												if (propertyHeaterCounts.Count > 0 && propertyHeaterCounts.ContainsKey(val.propertyCode))
												{
													propertyHeaterCounts.TryGetValue(val.propertyCode, out var value5);
													num17 = value5.Count;
													if (num17 > 0)
													{
														num16 = Mathf.Lerp(num16, num16 + ACHeaterHeatConcentrationAdd, Mathf.Clamp01((float)num17 / 3f));
													}
												}
												num2 = EaseOutCubic(val.AmbientTemperature, FlatlinePlayer.OutsideTemperatureCelsius, num16);
												num2 = Mathf.Clamp(num2, 0f, propertyTempDefaults[val.propertyCode]);
												DebugModule.Log($"{val.propertyCode} heat accumulation: {num2} (+{num2 - val.AmbientTemperature})", "UpdateAllPropertyTemperatures");
											}
											else if (val.AmbientTemperature > FlatlinePlayer.OutsideTemperatureCelsius && val.AmbientTemperature > propertyTempDefaults[val.propertyCode] - MaximumPropertyTemperatureDrop)
											{
												int num18 = 0;
												if (propertyHeaterCounts.Count > 0 && propertyHeaterCounts.ContainsKey(val.propertyCode))
												{
													propertyHeaterCounts.TryGetValue(val.propertyCode, out var value6);
													num18 = value6.Count;
													if (num18 > 0)
													{
														num15 = Mathf.Lerp(num15, ACHeaterHeatDissipationMin, Mathf.Clamp01((float)num18 / 3f));
													}
												}
												num2 = EaseOutCubic(val.AmbientTemperature, FlatlinePlayer.OutsideTemperatureCelsius, num15);
												num2 = Mathf.Clamp(num2, 0f, propertyTempDefaults[val.propertyCode]);
												DebugModule.Log($"{val.propertyCode} heat dissipation: {num2} (-{val.AmbientTemperature - num2})", "UpdateAllPropertyTemperatures");
											}
											goto IL_0715;
										}
									}
								}
							}
						}
						goto IL_07b7;
					}
					IL_0715:
					if (!float.IsNaN(num2))
					{
						Property.Properties[<i>5__2].AmbientTemperature = num2;
						string arg = (Flatline.currentConfig.FahrenheitTemp ? FlatlineUIModule.fahrenheitSign : FlatlineUIModule.celsiusSign);
						int num19 = (Flatline.currentConfig.FahrenheitTemp ? Mathf.RoundToInt(FlatlineUIModule.CelsiusToFahrenheit(num2)) : Mathf.RoundToInt(num2));
						((TMP_Text)propertyTemperatureDisplayTexts[val.propertyCode]).text = $"{num19}{arg}";
					}
					else
					{
						DebugModule.Log("Temperature result calculation failed for " + val.propertyCode, "UpdateAllPropertyTemperatures");
					}
					goto IL_07b7;
					IL_07b7:
					<i>5__2++;
					goto IL_07c9;
					IL_0022:
					<>2__current = Flatline.Wait2;
					<>1__state = 1;
					return true;
					IL_07c9:
					if (<i>5__2 < Property.Properties.Count)
					{
						<>2__current = Flatline.Wait2;
						<>1__state = 2;
						return true;
					}
					goto IL_0022;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly float MaximumPropertyTemperatureDrop = 6f;

		public static readonly float OpenDoorHeatDissipationTMax = 0.125f;

		public static readonly float OpenDoorHeatDissipationTMin = 0.095f;

		public static readonly float OpenDoorHeatConcentrationTMax = 0.185f;

		public static readonly float OpenDoorHeatConcentrationTMin = 0.115f;

		public static readonly float ACHeaterHeatConcentrationAdd = 0.055f;

		public static readonly float ACHeaterHeatDissipationMin = 0.015f;

		public static readonly float ClosedDoorHeatConcentrationT = 0.195f;

		public static readonly Dictionary<string, float> PropertyTemperatureChangeMultiplier = new Dictionary<string, float>
		{
			{ "motelroom", 0.8f },
			{ "sweatshop", 0.75f },
			{ "bungalow", 0.67f },
			{ "storageunit", 0.8f },
			{ "barn", 0.78f },
			{ "manor", 0.6f },
			{ "dockswarehouse", 1f },
			{ "seweroffice", 0.1f }
		};

		public static Dictionary<string, float> propertyTempDefaults = new Dictionary<string, float>();

		public static Dictionary<string, TextMeshProUGUI> propertyTemperatureDisplayTexts = new Dictionary<string, TextMeshProUGUI>();

		public static Dictionary<string, List<int>> propertyHeaterCounts = new Dictionary<string, List<int>>();

		public static Dictionary<string, PropertyDoorController[]> propertyDoors = new Dictionary<string, PropertyDoorController[]>();

		public static Dictionary<EMapRegion, List<BoxCollider>> warmBuildingsInRegion = new Dictionary<EMapRegion, List<BoxCollider>>();

		public static Transform darkMarket;

		public static void InitPropertyTemperatureController()
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			SavePoint[] array = Object.FindObjectsOfType<SavePoint>();
			Property val = null;
			foreach (Property property in Property.Properties)
			{
				propertyTempDefaults.Add(property.propertyCode, property.AmbientTemperature);
				DebugModule.Log("Added Property temperature default value to list : " + property.propertyCode, "InitPropertyTemperatureController");
				if (property.propertyCode == "storageunit")
				{
					val = property;
				}
				if (!propertyHeaterCounts.ContainsKey(property.propertyCode))
				{
					propertyHeaterCounts.Add(property.propertyCode, new List<int>());
				}
				if (property.propertyCode != "dockswarehouse" && property.propertyCode != "rv")
				{
					PropertyDoorController[] componentsInChildren = ((Component)property).GetComponentsInChildren<PropertyDoorController>(true);
					if (componentsInChildren.Length != 0)
					{
						DebugModule.Log($"Found {componentsInChildren.Length} doors for {property.propertyCode}", "InitPropertyTemperatureController");
						propertyDoors.Add(property.propertyCode, componentsInChildren);
					}
				}
			}
			SavePoint[] array2 = array;
			Vector3 val4 = default(Vector3);
			foreach (SavePoint val2 in array2)
			{
				Property val3 = ((Component)val2).GetComponentInParent<Property>();
				if ((Object)(object)val3 == (Object)null)
				{
					((Vector3)(ref val4))..ctor(-6.09f, 1.3f, 105.01f);
					if (Vector3.Distance(((Component)val2).transform.position, val4) < 1f)
					{
						val3 = val;
					}
				}
				string propertyCode = val3.propertyCode;
				GameObject val5 = new GameObject("LocalAmbientTemp");
				val5.SetActive(false);
				val5.transform.parent = ((Component)val2).transform;
				TextMeshProUGUI val6 = val5.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val6).fontStyle = (FontStyles)1;
				((TMP_Text)val6).fontSize = 26f;
				((Graphic)val6).color = Color.black;
				string arg = (Flatline.currentConfig.FahrenheitTemp ? FlatlineUIModule.fahrenheitSign : FlatlineUIModule.celsiusSign);
				int num = (Flatline.currentConfig.FahrenheitTemp ? Mathf.RoundToInt(FlatlineUIModule.CelsiusToFahrenheit(val3.AmbientTemperature)) : Mathf.RoundToInt(val3.AmbientTemperature));
				((TMP_Text)val6).text = $"{num}{arg}";
				Canvas obj = val5.AddComponent<Canvas>();
				if ((Object)(object)PlayerSingleton<PlayerCamera>.Instance == (Object)null || (Object)(object)PlayerSingleton<PlayerCamera>.Instance.Camera == (Object)null)
				{
					DebugModule.Log("Player camer is null!", "InitPropertyTemperatureController");
				}
				obj.worldCamera = PlayerSingleton<PlayerCamera>.Instance.Camera;
				obj.renderMode = (RenderMode)2;
				RectTransform component = val5.GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(200f, 100f);
				((Transform)component).localPosition = new Vector3(-0.015f, -0.076f, -0.032f);
				((Transform)component).localRotation = Quaternion.Euler(0f, 90f, 0f);
				((Transform)component).localScale = new Vector3(0.001f, 0.001f, 0.001f);
				val5.SetActive(true);
				propertyTemperatureDisplayTexts.Add(propertyCode, val6);
			}
			List<BoxCollider> list = new List<BoxCollider>();
			Transform val7 = ((Component)Singleton<Map>.Instance).transform.Find("Hyland Point/Region_Docks/Clothing store with interior/Collider");
			BoxCollider item = default(BoxCollider);
			if ((Object)(object)val7 != (Object)null && ((Component)val7).TryGetComponent<BoxCollider>(ref item))
			{
				list.Add(item);
			}
			else
			{
				DebugModule.Log("Failed to find TR clothingShop", "InitPropertyTemperatureController");
			}
			Transform val8 = ((Component)Singleton<Map>.Instance).transform.Find("Hyland Point/Region_Docks/Barbershop/Collider");
			BoxCollider item2 = default(BoxCollider);
			if ((Object)(object)val8 != (Object)null && ((Component)val8).TryGetComponent<BoxCollider>(ref item2))
			{
				list.Add(item2);
			}
			else
			{
				DebugModule.Log("Failed to find TR clothingShop", "InitPropertyTemperatureController");
			}
			warmBuildingsInRegion.Add((EMapRegion)3, list);
			DebugModule.Log("Finished initializing property temperature controller", "InitPropertyTemperatureController");
		}

		public static void ResetPropertyTemperatureController()
		{
			propertyTempDefaults.Clear();
			propertyTemperatureDisplayTexts.Clear();
			propertyHeaterCounts.Clear();
			propertyDoors.Clear();
			warmBuildingsInRegion.Clear();
			darkMarket = null;
		}

		[IteratorStateMachine(typeof(<UpdateAllPropertyTemperatures>d__17))]
		public static IEnumerator UpdateAllPropertyTemperatures()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateAllPropertyTemperatures>d__17(0);
		}

		public static float EaseOutCubic(float a, float b, float t)
		{
			return Mathf.Lerp(a, b, 1f - Mathf.Pow(1f - t, 3f));
		}
	}
	public static class FlatlineUIModule
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__OnReturnToMenuClicked;
		}

		[CompilerGenerated]
		private sealed class <AnimateRandomLettersInTitle>d__22 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private string <flatlined>5__2;

			private float <baseDelay>5__3;

			private float <maxDelay>5__4;

			private int <k>5__5;

			private float <currentWait>5__6;

			private int <scrambleSteps>5__7;

			private int <j>5__8;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AnimateRandomLettersInTitle>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<flatlined>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Expected O, but got Unknown
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Expected O, but got Unknown
				char[] array3;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					_ = ((TMP_Text)deathTitleText).text;
					<flatlined>5__2 = "FLATLINED";
					if ((Object)(object)deathTitleText != (Object)null)
					{
						<k>5__5 = 0;
						goto IL_00c6;
					}
					DebugModule.Log("Death title text is null", "AnimateRandomLettersInTitle");
					break;
				case 1:
				{
					<>1__state = -1;
					if (!Flatline.registered || Player.Local.Health.IsAlive)
					{
						return false;
					}
					char c = ' ';
					char[] array = ((TMP_Text)deathTitleText).text.ToCharArray();
					array[<k>5__5] = c;
					((TMP_Text)deathTitleText).text = new string(array);
					<k>5__5++;
					goto IL_00c6;
				}
				case 2:
					<>1__state = -1;
					<j>5__8++;
					goto IL_0204;
				case 3:
					{
						<>1__state = -1;
						<k>5__5++;
						goto IL_0282;
					}
					IL_0282:
					if (<k>5__5 < <flatlined>5__2.Length)
					{
						float num = (float)<k>5__5 / (float)(<flatlined>5__2.Length - 1);
						<currentWait>5__6 = Mathf.Lerp(<baseDelay>5__3, <maxDelay>5__4, Mathf.Pow(num, 2f));
						<scrambleSteps>5__7 = 3;
						<j>5__8 = 0;
						goto IL_0204;
					}
					break;
					IL_00c6:
					if (<k>5__5 < ((TMP_Text)deathTitleText).text.Length)
					{
						<>2__current = Flatline.Wait025;
						<>1__state = 1;
						return true;
					}
					((TMP_Text)deathTitleText).text = new string(' ', <flatlined>5__2.Length);
					<baseDelay>5__3 = 0.025f;
					<maxDelay>5__4 = 0.1f;
					<k>5__5 = 0;
					goto IL_0282;
					IL_0204:
					if (<j>5__8 < <scrambleSteps>5__7)
					{
						if (!Flatline.registered || Player.Local.Health.IsAlive)
						{
							return false;
						}
						char[] array2 = ((TMP_Text)deathTitleText).text.ToCharArray();
						array2[<k>5__5] = <flatlined>5__2[Random.Range(0, <flatlined>5__2.Length)];
						((TMP_Text)deathTitleText).text = new string(array2);
						<>2__current = (object)new WaitForSeconds(<currentWait>5__6 / 3f);
						<>1__state = 2;
						return true;
					}
					array3 = ((TMP_Text)deathTitleText).text.ToCharArray();
					array3[<k>5__5] = <flatlined>5__2[<k>5__5];
					((TMP_Text)deathTitleText).text = new string(array3);
					<>2__current = (object)new WaitForSeconds(<currentWait>5__6);
					<>1__state = 3;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <GenerateDeathScreenScore>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private List<TextMeshProUGUI>.Enumerator <>7__wrap1;

			private TextMeshProUGUI <textComp>5__3;

			private float <fadeDur>5__4;

			private float <current>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GenerateDeathScreenScore>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 3) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(List<TextMeshProUGUI>.Enumerator);
				<textComp>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_035f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: 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_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					float num;
					float num3;
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						WaitUntil val3 = new WaitUntil((Func<bool>)(() => Singleton<DeathScreen>.Instance.isOpen));
						<>2__current = val3;
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					}
					case 1:
						<>1__state = -1;
						if (!Flatline.registered)
						{
							result = false;
						}
						else
						{
							if (Player.Local.Health.IsAlive)
							{
								Player.Local.Health.IsAlive = false;
							}
							<>2__current = Flatline.Wait05;
							<>1__state = 2;
							result = true;
						}
						goto end_IL_0000;
					case 2:
						<>1__state = -1;
						if (Flatline.registered)
						{
							string value = "";
							if (FlatlinePlayer.lastDamageSources.Count > 0)
							{
								value = FlatlinePlayer.lastDamageSources[0];
							}
							Dictionary<string, string> obj = new Dictionary<string, string>
							{
								{
									"Days survived: ",
									NetworkSingleton<TimeManager>.Instance.ElapsedDays.ToString()
								},
								{
									"Networth: ",
									Mathf.RoundToInt(NetworkSingleton<MoneyManager>.Instance.LastCalculatedNetworth).ToString()
								},
								{ "Cause of Death: ", causeOfDeath },
								{ "Last damage source: ", value }
							};
							List<TextMeshProUGUI> list = new List<TextMeshProUGUI>();
							string text = ((TMP_Text)deathTitleText).text;
							if (Player.PlayerList.Count > 1 && !Flatline.currentConfig.PermanentDeath)
							{
								Flatline.coros.Add(MelonCoroutines.Start(WaitUntilRespawn(text)));
							}
							int num2 = 0;
							foreach (KeyValuePair<string, string> item in obj)
							{
								GameObject val = new GameObject($"ScoreKVP{num2}");
								val.SetActive(false);
								val.AddComponent<RectTransform>().sizeDelta = new Vector2(500f, 35f);
								TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
								((TMP_Text)val2).fontSize = 16f;
								((TMP_Text)val2).text = item.Key + item.Value;
								val.transform.parent = (Transform)(object)scoreBoard;
								val.transform.localScale = Vector3.one;
								((Graphic)val2).color = new Color(1f, 1f, 1f, 0f);
								list.Insert(0, val2);
								num2++;
							}
							<>7__wrap1 = list.GetEnumerator();
							<>1__state = -3;
							break;
						}
						result = false;
						goto end_IL_0000;
					case 3:
						<>1__state = -3;
						if (Flatline.registered)
						{
							((Component)<textComp>5__3).gameObject.SetActive(true);
							<fadeDur>5__4 = 1f;
							<current>5__5 = 0f;
							num = 0f;
							goto IL_0386;
						}
						result = false;
						<>m__Finally1();
						goto end_IL_0000;
					case 4:
						{
							<>1__state = -3;
							goto IL_0386;
						}
						IL_0386:
						if (!Flatline.registered || !(<current>5__5 < <fadeDur>5__4))
						{
							((Graphic)<textComp>5__3).color = new Color(1f, 1f, 1f, 1f);
							<textComp>5__3 = null;
							break;
						}
						<current>5__5 += Time.deltaTime;
						num = <current>5__5 / <fadeDur>5__4;
						num3 = Mathf.Lerp(0f, 1f, Mathf.SmoothStep(0f, 1f, num));
						((Graphic)<textComp>5__3).color = new Color(1f, 1f, 1f, num3);
						<>2__current = null;
						<>1__state = 4;
						result = true;
						goto end_IL_0000;
					}
					if (<>7__wrap1.MoveNext())
					{
						<textComp>5__3 = <>7__wrap1.Current;
						<>2__current = Flatline.Wait025;
						<>1__state = 3;
						result = true;
					}
					else
					{
						<>m__Finally1();
						<>7__wrap1 = default(List<TextMeshProUGUI>.Enumerator);
						Flatline.coros.Add(MelonCoroutines.Start(AnimateRandomLettersInTitle()));
						DebugModule.Log("Generated death screen", "GenerateDeathScreenScore");
						result = false;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <InitiateWorldTemperatureText>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitiateWorldTemperatureText>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0107: 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_0146: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = Flatline.Wait5;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					GameObject val = null;
					for (int i = 0; i < ((Component)PlayerSingleton<HomeScreen>.Instance).transform.childCount; i++)
					{
						if (!((Object)((Component)PlayerSingleton<HomeScreen>.Instance).transform.GetChild(i)).name.ToLower().Contains("infobar"))
						{
							continue;
						}
						Transform child = ((Component)PlayerSingleton<HomeScreen>.Instance).transform.GetChild(i);
						for (int j = 0; j < child.childCount; j++)
						{
							if (((Object)child.GetChild(j)).name.ToLower() == "data")
							{
								val = Object.Instantiate<GameObject>(((Component)child.GetChild(j)).gameObject, child);
								break;
							}
						}
						break;
					}
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					((Object)val).name = "Temperature";
					val.GetComponent<RectTransform>().sizeDelta = new Vector2(150f, 35f);
					val.transform.localRotation = Quaternion.identity;
					val.transform.localScale = Vector3.one;
					val.transform.localPosition = new Vector3(150.5101f, 0f, 0f);
					Text val2 = val.GetComponent<Text>();
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = val.GetComponentInChildren<Text>();
					}
					if ((Object)(object)val2 == (Object)null)
					{
						return false;
					}
					WorldTemperature = val2;
					string arg = (Flatline.currentConfig.FahrenheitTemp ? fahrenheitSign : celsiusSign);
					int num = Random.Range(16, 21);
					num = (Flatline.currentConfig.FahrenheitTemp ? ((int)CelsiusToFahrenheit(num)) : num);
					WorldTemperature.text = $"{num}{arg}";
					DebugModule.Log("World temperature text succesfully created", "InitiateWorldTemperatureText");
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ReturnAndDeleteSave>d__25 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public SaveInfo info;

			private string <path>5__2;

			private string <orgName>5__3;

			private int <slotNum>5__4;

			private WaitUntil <inMenu>5__5;

			private WaitUntil <notLoading>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ReturnAndDeleteSave>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<path>5__2 = null;
				<orgName>5__3 = null;
				<inMenu>5__5 = null;
				<notLoading>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<path>5__2 = info.SavePath;
					<orgName>5__3 = info.OrganisationName;
					<slotNum>5__4 = info.SaveSlotNumber;
					Singleton<LoadManager>.Instance.ExitToMenu((SaveInfo)null, (Data)null, false);
					WaitUntil val = new WaitUntil((Func<bool>)(() => Singleton<LoadManager>.Instance.IsLoading));
					<inMenu>5__5 = new WaitUntil((Func<bool>)delegate
					{
						//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)
						Scene activeScene = SceneManager.GetActiveScene();
						return ((Scene)(ref activeScene)).name == "Menu";
					});
					<notLoading>5__6 = new WaitUntil((Func<bool>)(() => !Singleton<LoadManager>.Instance.IsLoading));
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = <inMenu>5__5;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = <notLoading>5__6;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = Flatline.Wait1;
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					DebugModule.Log("Deleting save data...", "ReturnAndDeleteSave");
					try
					{
						if (Directory.Exists(<path>5__2))
						{
							Directory.Delete(<path>5__2, recursive: true);
							DebugModule.Log("Save data deleted succesfully", "ReturnAndDeleteSave");
							Singleton<LoadManager>.Instance.RefreshSaveInfo();
						}
						else
						{
							DebugModule.Log("Save data not found at path: " + <path>5__2, "ReturnAndDeleteSave");
						}
					}
					catch (Exception ex)
					{
						DebugModule.Log("Failed to delete save data: " + ex, "ReturnAndDeleteSave");
					}
					DebugModule.Log("Deleting flatline persist data", "ReturnAndDeleteSave");
					ConfigLoader.RemoveSaveAssociatedData(<orgName>5__3, <slotNum>5__4);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateDiseasesHolder>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateDiseasesHolder>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					if (!((Object)(object)diseaseContainerObj == (Object)null))
					{
						if (PlayerSingleton<PlayerCamera>.Instance.activeUIElementCount > 0 && diseaseContainerObj.activeSelf)
						{
							diseaseContainerObj.SetActive(false);
						}
						else if (PlayerSingleton<PlayerCamera>.Instance.activeUIElementCount == 0 && !diseaseContainerObj.activeSelf)
						{
							diseaseContainerObj.SetActive(true);
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = Flatline.Wait01;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WaitUntilRespawn>d__23 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string originalText;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitUntilRespawn>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					DebugModule.Log("Detected multiplayer instance where permanent death is disabled", "WaitUntilRespawn");
					WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.registered || Player.Local.Health.IsAlive));
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = Flatline.Wait025;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					DebugModule.Log("Player respawned resetting death screen text", "WaitUntilRespawn");
					((TMP_Text)deathTitleText).text = originalText;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static Slider ThirstSlider;

		public static Slider HungerSlider;

		public static Slider EnergySlider;

		public static Slider TemperatureSlider;

		public static Text WorldTemperature;

		public static Button CustomButton;

		public static readonly string celsiusSign = "°C";

		public static readonly string fahrenheitSign = "°F";

		public static RectTransform scoreBoard;

		public static string causeOfDeath = string.Empty;

		public static TextMeshProUGUI deathTitleText;

		public static Dictionary<string, GameObject> diseaseIcons = new Dictionary<string, GameObject>();

		public static GameObject diseaseContainerObj;

		public static void ResetFlatlineUIModule()
		{
			ThirstSlider = null;
			HungerSlider = null;
			EnergySlider = null;
			TemperatureSlider = null;
			CustomButton = null;
			WorldTemperature = null;
			scoreBoard = null;
			causeOfDeath = string.Empty;
			diseaseIcons.Clear();
			diseaseContainerObj = null;
		}

		public static void InitiateSurvivalSliders()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0031: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SurvivalStates");
			val.transform.parent = ((Component)Singleton<HUD>.Instance).transform;
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(700f, 180f);
			obj.anchoredPosition = new Vector2(560f, -435f);
			VerticalLayoutGroup obj2 = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 38f;
			((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
			foreach (string item in new List<string> { "water", "meat", "energy", "temperature" })
			{
				GameObject val2 = new GameObject("Slider_" + item);
				val2.transform.parent = val.transform;
				val2.AddComponent<RectTransform>().sizeDelta = new Vector2(200f, 12f);
				Slider val3 = null;
				switch (item)
				{
				case "water":
					ThirstSlider = val2.AddComponent<Slider>();
					val3 = ThirstSlider;
					break;
				case "meat":
					HungerSlider = val2.AddComponent<Slider>();
					val3 = HungerSlider;
					break;
				case "energy":
					EnergySlider = val2.AddComponent<Slider>();
					val3 = EnergySlider;
					break;
				case "temperature":
					TemperatureSlider = val2.AddComponent<Slider>();
					val3 = TemperatureSlider;
					break;
				}
				GameObject val4 = new GameObject("FillRect");
				val4.transform.parent = val2.transform;
				RectTransform val6 = (val3.fillRect = val4.AddComponent<RectTransform>());
				val6.anchoredPosition = new Vector2(160f, 0f);
				val6.sizeDelta = new Vector2(1f, 1f);
				((Graphic)val4.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.85f);
				GameObject val7 = new GameObject("Logo");
				val7.transform.parent = val2.transform;
				RectTransform obj3 = val7.AddComponent<RectTransform>();
				obj3.anchoredPosition = new Vector2(25f, 0f);
				obj3.sizeDelta = new Vector2(46f, 46f);
				val7.AddComponent<Image>().sprite = ConfigLoader.loadedSprites[item];
			}
		}

		public static void InitiateDiseasesHolder()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_003d: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			diseaseContainerObj = new GameObject("DiseaseIconContainer");
			diseaseContainerObj.transform.parent = ((Component)Singleton<HUD>.Instance).transform;
			RectTransform obj = diseaseContainerObj.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(1000f, 54f);
			((Transform)obj).localPosition = new Vector3(0f, -370f, 0f);
			HorizontalLayoutGroup obj2 = diseaseContainerObj.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 30f;
			((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			foreach (string diseaseName in PlayerDiseaseDamage.diseaseNames)
			{
				if (!ConfigLoader.imageResources.Contains(diseaseName))
				{
					DebugModule.Log("Disease with name " + diseaseName + " does not have a logo in Resources", "InitiateDiseasesHolder");
					continue;
				}
				GameObject val = new GameObject(diseaseName ?? "");
				val.SetActive(false);
				val.transform.parent = diseaseContainerObj.transform;
				RectTransform obj3 = val.AddComponent<RectTransform>();
				((Transform)obj3).localPosition = Vector3.zero;
				obj3.sizeDelta = new Vector2(54f, 54f);
				val.AddComponent<Image>().sprite = ConfigLoader.loadedSprites[diseaseName];
				diseaseIcons.Add(diseaseName, val);
			}
		}

		[IteratorStateMachine(typeof(<UpdateDiseasesHolder>d__16))]
		public static IEnumerator UpdateDiseasesHolder()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateDiseasesHolder>d__16(0);
		}

		[IteratorStateMachine(typeof(<InitiateWorldTemperatureText>d__17))]
		public static IEnumerator InitiateWorldTemperatureText()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitiateWorldTemperatureText>d__17(0);
		}

		public static float FahrenheitToCelsius(float fahreneit)
		{
			return (fahreneit - 32f) * (5f / 9f);
		}

		public static float CelsiusToFahrenheit(float celsius)
		{
			return celsius * 1.8f + 32f;
		}

		public static void InitiateDeathScreen()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			for (int i = 0; i < ((Transform)Singleton<DeathScreen>.Instance.Container).childCount; i++)
			{
				Transform child = ((Transform)Singleton<DeathScreen>.Instance.Container).GetChild(i);
				if (((Object)child).name.ToLower().Contains("respawn"))
				{
					val = Object.Instantiate<GameObject>(((Component)child).gameObject, (Transform)(object)Singleton<DeathScreen>.Instance.Container);
					break;
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				val.transform.position = new Vector3(960f, 510f, 0f);
				((Object)val).name = "Return to Menu";
				val.GetComponent<RectTransform>().sizeDelta = new Vector2(180f, 70f);
				CustomButton = val.GetComponent<Button>();
				((UnityEventBase)CustomButton.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = CustomButton.onClick;
				object obj = <>O.<0>__OnReturnToMenuClicked;
				if (obj == null)
				{
					UnityAction val2 = OnReturnToMenuClicked;
					<>O.<0>__OnReturnToMenuClicked = val2;
					obj = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				if (val.transform.childCount > 0)
				{
					TextMeshProUGUI component = ((Component)val.transform.GetChild(0)).GetComponent<TextMeshProUGUI>();
					((TMP_Text)component).text = "Delete Save and Return to Menu";
					((Graphic)component).color = new Color(1f, 1f, 1f, 1f);
				}
				val.SetActive(true);
				GameObject val3 = new GameObject("Scoreboard");
				val3.transform.parent = (Transform)(object)Singleton<DeathScreen>.Instance.Container;
				val3.transform.localScale = Vector3.one;
				scoreBoard = val3.AddComponent<RectTransform>();
				scoreBoard.sizeDelta = new Vector2(500f, 400f);
				((Transform)scoreBoard).localPosition = Vector3.zero;
				scoreBoard.anchoredPosition = new Vector2(0f, 300f);
				VerticalLayoutGroup obj2 = val3.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)obj2).childAlignment = (TextAnchor)0;
				((HorizontalOrVerticalLayoutGroup)obj2).spacing = 4f;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
				Transform val4 = ((Component)Singleton<DeathScreen>.Instance.Container).transform.Find("Title");
				if ((Object)(object)val4 != (Object)null)
				{
					deathTitleText = ((Component)val4).gameObject.GetComponent<TextMeshProUGUI>();
				}
				DebugModule.Log("DeathScreen elements done", "InitiateDeathScreen");
			}
		}

		[IteratorStateMachine(typeof(<GenerateDeathScreenScore>d__21))]
		public static IEnumerator GenerateDeathScreenScore()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GenerateDeathScreenScore>d__21(0);
		}

		[IteratorStateMachine(typeof(<AnimateRandomLettersInTitle>d__22))]
		public static IEnumerator AnimateRandomLettersInTitle()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateRandomLettersInTitle>d__22(0);
		}

		[IteratorStateMachine(typeof(<WaitUntilRespawn>d__23))]
		public static IEnumerator WaitUntilRespawn(string originalText)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitUntilRespawn>d__23(0)
			{
				originalText = originalText
			};
		}

		public static void OnReturnToMenuClicked()
		{
			DebugModule.Log("Returning to menu...", "OnReturnToMenuClicked");
			SaveInfo activeSaveInfo = Singleton<LoadManager>.Instance.ActiveSaveInfo;
			if (activeSaveInfo == null || activeSaveInfo.SavePath == string.Empty)
			{
				DebugModule.Log("Active save info path is null, cant delete.", "OnReturnToMenuClicked");
				Singleton<LoadManager>.Instance.ExitToMenu((SaveInfo)null, (Data)null, false);
			}
			else
			{
				MelonCoroutines.Start(ReturnAndDeleteSave(activeSaveInfo));
			}
		}

		[IteratorStateMachine(typeof(<ReturnAndDeleteSave>d__25))]
		public static IEnumerator ReturnAndDeleteSave(SaveInfo info)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReturnAndDeleteSave>d__25(0)
			{
				info = info
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}