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 IEnum
