using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EnvironmentalAwareness.Data;
using EnvironmentalAwareness.Interface;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using SkillManager;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: AssemblyProduct("EnvironmentalAwareness")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCompany("EnvironmentalAwareness")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyTitle("EnvironmentalAwareness")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<6f593530-c7c4-4c23-b63a-dc6d8177fab8>Embedded]
	internal sealed class <6f593530-c7c4-4c23-b63a-dc6d8177fab8>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<6f593530-c7c4-4c23-b63a-dc6d8177fab8>Embedded]
	[CompilerGenerated]
	internal sealed class <9d033fe9-c380-47d1-b735-cfa82d3b8a67>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <9d033fe9-c380-47d1-b735-cfa82d3b8a67>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <9d033fe9-c380-47d1-b735-cfa82d3b8a67>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<6f593530-c7c4-4c23-b63a-dc6d8177fab8>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace EnvironmentalAwareness
{
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("maxfoxgaming.environmentalawareness", "EnvironmentalAwareness", "1.2.7")]
	public class Main : BaseUnityPlugin
	{
		public const string PluginGUID = "maxfoxgaming.environmentalawareness";

		public const string PluginName = "EnvironmentalAwareness";

		public const string PluginVersion = "1.2.7";

		public const string PluginSavePath = "EnvironmentalAwareness_";

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private static Main instance;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public AssetBundle Bundle;

		public static Harmony harmony = new Harmony("maxfoxgaming.environmentalawareness");

		public static readonly string ModPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public static ManualLogSource Log;

		public static readonly string VitalitySEName = "EA_Vitality";

		public static readonly string EnergySEName = "EA_Energy";

		public static readonly string CapabilitySEName = "EA_Capability";

		public static readonly string PlayerStatsSEName = "EA_PlayerStats";

		public static readonly string HungrySEName = "EA_Hungry";

		public static readonly string HotSEName = "EA_Hot";

		public static readonly string ScorchingSEName = "EA_Scorching";

		public static readonly string ResistanceSkillName = "Resistance";

		public static readonly string FitnessSkillName = "Fitness";

		public static readonly string PerseverenceSkillName = "Perseverence";

		public static readonly int ResistanceHash = StringExtensionMethods.GetStableHashCode(ResistanceSkillName);

		public static readonly int FitnessHash = StringExtensionMethods.GetStableHashCode(FitnessSkillName);

		public static readonly int PerseverenceHash = StringExtensionMethods.GetStableHashCode(PerseverenceSkillName);

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Hungry Hungry;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Hot Hot;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Scorching Scorching;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Vitality Vitality;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Energy Energy;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_Capability Capability;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public SE_PlayerStats PlayerStats;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public Skill Resistance;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public Skill Fitness;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public Skill Assurance;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public Skill Perseverence;

		public TutorialText[] TutorialTexts = (TutorialText[])(object)new TutorialText[8]
		{
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessVitality",
				m_label = "$ea_tutorial_vitality_label",
				m_text = "$ea_tutorial_vitality_text",
				m_topic = "$ea_tutorial_vitality_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessVitalityLow",
				m_label = "$ea_tutorial_vitality_low_label",
				m_text = "$ea_tutorial_vitality_low_text",
				m_topic = "$ea_tutorial_vitality_low_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessEnergy",
				m_label = "$ea_tutorial_energy_label",
				m_text = "$ea_tutorial_energy_text",
				m_topic = "$ea_tutorial_energy_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessEnergyLow",
				m_label = "$ea_tutorial_energy_low_label",
				m_text = "$ea_tutorial_energy_low_text",
				m_topic = "$ea_tutorial_energy_low_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessPotentiality",
				m_label = "$ea_tutorial_potentiality_label",
				m_text = "$ea_tutorial_potentiality_text",
				m_topic = "$ea_tutorial_potentiality_topic"
			},
			new TutorialText
			{
				m_name = "EnvronmentalAwarenessPotentialityLow",
				m_label = "$ea_tutorial_potentiality_low_label",
				m_text = "$ea_tutorial_potentiality_low_text",
				m_topic = "$ea_tutorial_potentiality_low_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessCapability",
				m_label = "$ea_tutorial_capability_low_label",
				m_text = "$ea_tutorial_capability_low_text",
				m_topic = "$ea_tutorial_capability_low_topic"
			},
			new TutorialText
			{
				m_name = "EnvironmentalAwarenessHot",
				m_label = "$ea_tutorial_hot_label",
				m_text = "$ea_tutorial_hot_text",
				m_topic = "$ea_tutorial_hot_topic"
			}
		};

		public static readonly string EAHud = "EAHud";

		private readonly string[] credits = new string[8] { "ProbablyKory: Inspiration from the StormExposure mod.", "Azumatt: Help with Valheim asset ripping and referencing.", "OrianaVenture: Encouragement with trying status effect manipulation and the save system.", "GsiX & HugoTheDwarf: Help with sprite sizes.", "Blaxxun: ServerSync, SkillManager and LocalizationManager.", "Blacks7ar: Help with SkillManager to get level of custom skill.", "love5225: Korean translations.", "Blace: Russian translations." };

		public void Awake()
		{
			Localizer.Load();
			Log = ((BaseUnityPlugin)this).Logger;
			instance = this;
			ConfigManager.CreateConfigValues((BaseUnityPlugin)(object)this);
			SetupWatcher();
			LoadAssets();
			InitializeSEs();
			InitializeSkills();
			SetupCompatibility();
			Harmony val = harmony;
			if (val != null)
			{
				val.PatchAll();
			}
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, "maxfoxgaming.environmentalawareness.cfg");
			fileSystemWatcher.Changed += ConfigManager.OnConfigChangedFromFile;
			fileSystemWatcher.Created += ConfigManager.OnConfigChangedFromFile;
			fileSystemWatcher.Renamed += ConfigManager.OnConfigChangedFromFile;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public void LoadAssets()
		{
			LogMessage(() => "Loading bundles.");
			Bundle = LoadBundle("environmentalsprites");
		}

		public void InitializeSEs()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			LogMessage(() => "Initializing Status Effects.");
			Hungry = ScriptableObject.CreateInstance<SE_Hungry>();
			((Object)Hungry).name = HungrySEName;
			Hot = ScriptableObject.CreateInstance<SE_Hot>();
			((Object)Hot).name = HotSEName;
			((SE_Stats)Hot).m_healthRegenMultiplier = 0.5f;
			((SE_Stats)Hot).m_staminaRegenMultiplier = 0.75f;
			((SE_Stats)Hot).m_eitrRegenMultiplier = 0.75f;
			((SE_Stats)Hot).m_speedModifier = -0.05f;
			Scorching = ScriptableObject.CreateInstance<SE_Scorching>();
			((Object)Scorching).name = ScorchingSEName;
			((SE_Stats)Scorching).m_healthRegenMultiplier = 0.2f;
			((SE_Stats)Scorching).m_staminaRegenMultiplier = 0.5f;
			((SE_Stats)Scorching).m_eitrRegenMultiplier = 0.5f;
			((SE_Stats)Scorching).m_speedModifier = -0.2f;
			((SE_Stats)Scorching).m_mods = new List<DamageModPair>
			{
				new DamageModPair
				{
					m_type = (DamageType)1,
					m_modifier = (DamageModifier)8
				},
				new DamageModPair
				{
					m_type = (DamageType)2,
					m_modifier = (DamageModifier)8
				},
				new DamageModPair
				{
					m_type = (DamageType)4,
					m_modifier = (DamageModifier)8
				}
			};
			Vitality = ScriptableObject.CreateInstance<SE_Vitality>();
			((Object)Vitality).name = VitalitySEName;
			Energy = ScriptableObject.CreateInstance<SE_Energy>();
			((Object)Energy).name = EnergySEName;
			Capability = ScriptableObject.CreateInstance<SE_Capability>();
			((Object)Capability).name = CapabilitySEName;
			PlayerStats = ScriptableObject.CreateInstance<SE_PlayerStats>();
			((Object)PlayerStats).name = PlayerStatsSEName;
		}

		public void InitializeSkills()
		{
			LogMessage(() => "Adding Skills.");
			if (Resistance == null)
			{
				Resistance = new Skill(ResistanceSkillName, Bundle.LoadAsset<Sprite>("vitalityicon1"));
			}
			Resistance.SkillEffectFactor = ConfigManager.ResistanceSkillEffectFactor.Value;
			Resistance.SkillGainFactor = ConfigManager.ResistanceSkillGainFactor.Value;
			Resistance.Configurable = false;
			LogSkill(Resistance, ResistanceSkillName);
			if (Fitness == null)
			{
				Fitness = new Skill(FitnessSkillName, Bundle.LoadAsset<Sprite>("energyicon1"));
			}
			Fitness.SkillEffectFactor = ConfigManager.FitnessSkillEffectFactor.Value;
			Fitness.SkillGainFactor = ConfigManager.FitnessSkillGainFactor.Value;
			Fitness.Configurable = false;
			LogSkill(Fitness, FitnessSkillName);
			if (Perseverence == null)
			{
				Perseverence = new Skill(PerseverenceSkillName, Bundle.LoadAsset<Sprite>("capabilityicon1"));
			}
			Perseverence.SkillEffectFactor = ConfigManager.PerseverenceSkillMaxTimeGain.Value;
			Perseverence.SkillGainFactor = ConfigManager.PerseverenceSkillGainFactor.Value;
			Perseverence.Configurable = false;
			LogSkill(Perseverence, PerseverenceSkillName);
		}

		private void SetupCompatibility()
		{
			LogMessage(() => "Checking for compatible mods...");
			IEnumerable<Type> enumerable = from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.IsClass && t.Namespace == "EnvironmentalAwareness.Compatibility" && t.IsAbstract && t.IsSealed
				select t;
			foreach (Type item in enumerable)
			{
				MethodInfo method = item.GetMethod("Setup", BindingFlags.Static | BindingFlags.Public);
				if (!(method == null))
				{
					method.Invoke(null, null);
				}
			}
		}

		public void OnDestroy()
		{
			Harmony val = harmony;
			if (val != null)
			{
				val.UnpatchSelf();
			}
			instance = null;
		}

		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(2)]
		public static Main GetInstance()
		{
			return instance;
		}

		public static void LogMessage(Func<string> message)
		{
			if (ConfigManager.DebugLogging.Value)
			{
				Log.LogMessage((object)message());
			}
		}

		public static void LogSkill(Skill skill, string name)
		{
			LogMessage(() => string.Join("\n", new List<string>
			{
				$"Skill added with name: {name} (SkillManager Hash: {skill.GetHashCode()}, Stable Hash: {StringExtensionMethods.GetStableHashCode(name)})",
				$"Effect Factor from Config: {skill.SkillEffectFactor}",
				$"Gain Factor from Config: {skill.SkillGainFactor}"
			}));
		}

		public static bool IsInMainScene()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name.Equals("main");
		}

		[return: <9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public static AssetBundle LoadBundle(string name)
		{
			LogMessage(() => "Attempting to load bundle with name " + name + " from assembly.");
			string text = "";
			try
			{
				text = Assembly.GetExecutingAssembly().GetManifestResourceNames().Single((string str) => str.EndsWith(name));
			}
			catch (Exception)
			{
			}
			if (text == "")
			{
				LogMessage(() => $"Could not find path to resource in {Assembly.GetExecutingAssembly().GetName()}.");
				return null;
			}
			AssetBundle result;
			using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text))
			{
				result = AssetBundle.LoadFromStream(stream);
			}
			LogMessage(() => $"Loaded assetbundle {name} from {Assembly.GetExecutingAssembly().GetName()} successfully.");
			return result;
		}
	}
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	public class SE_Capability : SE_SurvivalBase
	{
		public int m_meadsConsumed = 0;

		public int m_maxMeadsConsumed = 6;

		public float m_capabilityPercFromMead = 0f;

		public float m_capabilityPercFromMeadTick = 0f;

		public float m_meadDigestionTime = 0f;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_vitalityMaxModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_energyMaxModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_perserverenceSkillModifier;

		public WarningMessage c_warningTired = new WarningMessage("$ea_capability_warningmessage_tired");

		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.CapabilitySEName);

		protected override string SENameKey => "$ea_se_capability";

		protected override string IconName => "capabilityicon";

		protected override int IconCount => 10;

		protected override string DataKey => "EnvironmentalAwareness_" + Main.CapabilitySEName;

		protected override string TooltipKey => "$ea_player_capability";

		protected override bool DisplayPercentageEnabledConfigEntry => ConfigManager.DisplayCapabilityPercentage.Value;

		protected override bool DisplayWarningTextsConfigEntry => ConfigManager.DisplayCapabilityWarningTexts.Value;

		protected override string[] Statuses => new string[5] { "$ea_capability_status_0", "$ea_capability_status_1", "$ea_capability_status_2", "$ea_capability_status_3", "$ea_capability_status_4" };

		protected override void SetupStatModifiers()
		{
			c_vitalityMaxModifier = new StatModifier(this, null, StatModifier.CalculationType.INVERSEPERCENTAGE)
			{
				m_enabled = ConfigManager.VitalityEnabled.Value,
				m_maxMultiplier = ConfigManager.CVitalityMaxCap.Value,
				m_threshold = ConfigManager.CVitalityMaxCapThreshold.Value,
				m_defaultValue = 100f
			};
			c_energyMaxModifier = new StatModifier(this, null, StatModifier.CalculationType.INVERSEPERCENTAGE)
			{
				m_enabled = ConfigManager.EnergyEnabled.Value,
				m_maxMultiplier = ConfigManager.CEnergyMaxCap.Value,
				m_threshold = ConfigManager.CEnergyMaxCapThreshold.Value,
				m_defaultValue = 100f
			};
			c_perserverenceSkillModifier = new StatModifier(this, c_warningTired, StatModifier.CalculationType.REGULAR)
			{
				m_enabled = ConfigManager.CapabilityEnabled.Value,
				m_maxMultiplier = ConfigManager.PerseverenceSkillGainFactor.Value,
				m_threshold = ConfigManager.PerseverenceSkillMinThreshold.Value,
				m_defaultValue = 0f
			};
		}

		public override void SetupBaseFields()
		{
			base.SetupBaseFields();
			m_baseMaxStatLoss = ConfigManager.CTimeToDrain.Value;
		}

		protected override void SetupExtraFields()
		{
			m_maxMeadsConsumed = ConfigManager.CTastyMeadLimit.Value;
		}

		protected override void LoadExtraFields(List<string> list)
		{
			list[4].AssignAsInt(out m_meadsConsumed);
			list[5].AssignAsFloat(out m_capabilityPercFromMead);
			list[6].AssignAsFloat(out m_capabilityPercFromMeadTick);
			list[7].AssignAsBool(out c_warningTired.m_display);
			list[8].AssignAsFloat(out m_meadDigestionTime);
		}

		protected override void SaveExtraFields(StringBuilder sb)
		{
			sb.AppendStat(m_meadsConsumed);
			sb.AppendStat(m_capabilityPercFromMead);
			sb.AppendStat(m_capabilityPercFromMeadTick);
			sb.AppendStat(c_warningTired.m_display);
			sb.AppendStat(m_meadDigestionTime);
		}

		protected override void UpdateRealtimeExternalStatChanges(float dt)
		{
			UpdateCapabilityFromMead(dt);
			RaisePerserverenceSkill(dt);
		}

		private void UpdateCapabilityFromMead(float dt)
		{
			if ((double)m_capabilityPercFromMead < 0.01)
			{
				m_capabilityPercFromMead = 0f;
				m_capabilityPercFromMeadTick = 0f;
			}
			else
			{
				base.ChangeStatLossByPercentage(-1f * m_capabilityPercFromMeadTick);
				m_capabilityPercFromMead -= m_capabilityPercFromMeadTick;
			}
		}

		public void RaisePerserverenceSkill(float dt)
		{
			((Character)(object)player).RaiseSkill("Perseverence", 0.01f * dt * c_perserverenceSkillModifier.CalculateMultiplier());
		}

		protected override void UpdateTutorial()
		{
			if (m_statLossPerc > 60f)
			{
				player.ShowTutorial("EnvironmentalAwarenessCapability", false);
			}
		}

		protected override void UpdateStatValue()
		{
			ProcessDigestion();
			if (pes.PlayerLayingInBed && !pes.PlayerSleeping)
			{
				ApplyCapabilityGainFromLayingInBed();
			}
			else
			{
				m_statLoss = Mathf.Clamp(m_statLoss + m_statChange, 0f, m_maxStatLoss);
			}
		}

		public override void Recalculate()
		{
			base.Recalculate();
			m_statChange = CalculateTotalMultiplier();
		}

		private void ProcessDigestion()
		{
			if (m_meadDigestionTime <= 0f)
			{
				m_meadDigestionTime = ConfigManager.CTastyMeadDigestionTime.Value;
			}
			if (m_meadsConsumed > 0)
			{
				float num = ((pes.PlayerLayingInBed && !pes.PlayerSleeping) ? ConfigManager.CTastyMeadDigestionInBedMultiplier.Value : 1f);
				m_meadDigestionTime -= num;
				if (m_meadDigestionTime <= 0f)
				{
					DecreaseMeadConsumption();
				}
			}
		}

		private float CalculateTotalMultiplier()
		{
			return CalculateVitalityMultiplier() * CalculateEnergyMultiplier() * CalculateRestedMultiplier();
		}

		private float CalculateVitalityMultiplier()
		{
			if (!ConfigManager.VitalityEnabled.Value)
			{
				return 1f;
			}
			float vitalityPercentage = pes.VitalityPercentage;
			if (vitalityPercentage >= ConfigManager.CVitalityResistThreshold.Value)
			{
				return ConfigManager.CVitalityResist.Value;
			}
			if (vitalityPercentage < ConfigManager.CLowVitalityLossThreshold.Value)
			{
				return ConfigManager.CLowVitalityLoss.Value;
			}
			return 1f;
		}

		private float CalculateEnergyMultiplier()
		{
			if (!ConfigManager.EnergyEnabled.Value)
			{
				return 1f;
			}
			float energyPercentage = pes.EnergyPercentage;
			if (energyPercentage >= ConfigManager.CEnergyResistThreshold.Value)
			{
				return ConfigManager.CEnergyResist.Value;
			}
			if (energyPercentage < ConfigManager.CLowEnergyLossThreshold.Value)
			{
				return ConfigManager.CLowEnergyLoss.Value;
			}
			return 1f;
		}

		private float CalculateRestedMultiplier()
		{
			return pes.PlayerRested ? ConfigManager.CRestedResist.Value : 1f;
		}

		protected override float CalculateAdditionalMaxStat()
		{
			float num = pes.PerseverenceSkillLevel / 100f;
			return num * ConfigManager.PerseverenceSkillMaxTimeGain.Value;
		}

		protected override void UpdateEffects()
		{
			UpdateStatusEffectModifiers();
		}

		private void UpdateStatusEffectModifiers()
		{
			pes.VitalityMaxPercentage = c_vitalityMaxModifier.CalculateMultiplier();
			pes.EnergyMaxPercentage = c_energyMaxModifier.CalculateMultiplier();
		}

		public void ApplyCapabilityGainFromMead()
		{
			if (IncreaseMeadConsumption())
			{
				m_capabilityPercFromMead += ConfigManager.CTastyMeadLossRemove.Value;
				m_capabilityPercFromMeadTick = ConfigManager.CTastyMeadLossRemove.Value / 100f;
			}
		}

		public void ApplyCapabilityGainFromLayingInBed()
		{
			base.ChangeStatLossByPercentage(-1f * ConfigManager.CInBedLossRemove.Value);
		}

		public void ApplyCapabilityGainFromSleep()
		{
			base.ChangeStatLossByPercentage(-1f * ConfigManager.CSleepLossRemove.Value);
			DecreaseMeadConsumption(ConfigManager.CTastyMeadSleepRemove.Value);
		}

		private bool IncreaseMeadConsumption()
		{
			if (m_meadsConsumed >= m_maxMeadsConsumed)
			{
				return false;
			}
			m_meadsConsumed++;
			return true;
		}

		private void DecreaseMeadConsumption(int amount = 1)
		{
			if (m_meadsConsumed != 0)
			{
				m_meadsConsumed = Mathf.Max(m_meadsConsumed - amount, 0);
			}
		}

		protected override void LogStatistics()
		{
			Main.LogMessage(() => string.Join("\n", new List<string>
			{
				"Capability SE UPDATE",
				$"Capability: {Mathf.Round(100f - m_statLossPerc)} ({m_maxStatLoss - m_statLoss} / {m_maxStatLoss})",
				$"Change OT: {m_statChange}"
			}));
		}

		public override void GetAdditionalDebugStrings(StringBuilder sb)
		{
			base.GetAdditionalDebugStrings(sb);
			sb.AppendFormat("m_meadsConsumed: {0}\n", m_meadsConsumed);
			sb.AppendFormat("m_maxMeadsConsumed: {0}\n", m_maxMeadsConsumed);
			sb.AppendFormat("m_capabilityPercFromMead: {0}\n", m_capabilityPercFromMead);
			sb.AppendFormat("m_capabilityPercFromMeadTick: {0}\n", m_capabilityPercFromMeadTick);
			sb.AppendFormat("m_meadDigestionTime {0}\n", m_meadDigestionTime);
		}
	}
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	public class SE_Energy : SE_SurvivalBase
	{
		public float m_staminaRegenDelay = 0f;

		public float m_staminaReductionMultiplier = 1f;

		public float m_energyFromFood = 0f;

		public float m_energyFromFoodTick = 0f;

		public float m_energyRegenSpeed = 0.5f;

		public float m_timeSinceRested = 0f;

		public float m_fitnessSkillMultiplier = 1f;

		public float m_seasonMultiplier = 1f;

		public float m_lossEnergyRestedMult = 1f;

		public float m_lossEnergyCarryWeightAdd = 0f;

		public float m_lossEnergyMovementAdd = 0f;

		public float m_staminaMeadMult = 1f;

		public float m_noRestMultiplier = 1f;

		public float s_totalStaminaUseInCycle = 0f;

		public float s_totalEnergyUseInCycle = 0f;

		public float s_lastRawLossInCycle;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_carryWeightModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_restedRemoveModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_damageModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_speedModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_skillGainModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_staminaReductionModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_staminaRegenModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_staminaDelayModifier;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public StatModifier c_energyLossResistModifier;

		public WarningMessage c_warningWeight = new WarningMessage("$ea_energy_warningmessage_weight");

		public WarningMessage c_warningDamage = new WarningMessage("$ea_energy_warningmessage_damage");

		public WarningMessage c_warningSpeed = new WarningMessage("$ea_energy_warningmessage_movement");

		public WarningMessage c_warningSkillGain = new WarningMessage("$ea_energy_warningmessage_skillgain");

		public WarningMessage c_warningStaminaReduction = new WarningMessage("$ea_energy_warningmessage_maxstamina");

		public WarningMessage c_warningStaminaRegen = new WarningMessage("$ea_energy_warningmessage_staminaregen");

		public WarningMessage c_warningStaminaDelay = new WarningMessage("$ea_energy_warningmessage_staminadelay");

		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.EnergySEName);

		protected override string SENameKey => "$ea_se_energy";

		protected override string IconName => "energyicon";

		protected override int IconCount => 15;

		protected override string DataKey => "EnvironmentalAwareness_" + Main.EnergySEName;

		protected override string TooltipKey => "$ea_player_energy";

		protected override bool DisplayPercentageEnabledConfigEntry => ConfigManager.DisplayEnergyPercentage.Value;

		protected override bool DisplayWarningTextsConfigEntry => ConfigManager.DisplayEnergyWarningTexts.Value;

		protected override string[] Statuses => new string[5] { "$ea_energy_status_0", "$ea_energy_status_1", "$ea_energy_status_2", "$ea_energy_status_3", "$ea_energy_status_4" };

		protected override void SetupStatModifiers()
		{
			c_carryWeightModifier = new StatModifier(this, c_warningWeight, StatModifier.CalculationType.REGULAR)
			{
				m_enabled = true,
				m_maxMultiplier = ConfigManager.ELossHeavyLoadAdd.Value,
				m_threshold = ConfigManager.ELossHeavyLoadThreshold.Value,
				m_defaultValue = 0f
			};
			c_restedRemoveModifier = new StatModifier(this, null, StatModifier.CalculationType.ONEZERO)
			{
				m_enabled = ConfigManager.ERestedLossEnabled.Value,
				m_maxMultiplier = 1f,
				m_threshold = ConfigManager.ERestedLossThreshold.Value,
				m_defaultValue = 0f
			};
			c_damageModifier = new StatModifier(this, c_warningDamage, StatModifier.CalculationType.INVERSE)
			{
				m_enabled = ConfigManager.EDamageReductionEnabled.Value,
				m_maxMultiplier = ConfigManager.EDamageMaxReduction.Value,
				m_threshold = ConfigManager.EDamageReductionThreshold.Value,
				m_defaultValue = 1f
			};
			c_speedModifier = new StatModifier(this, c_warningSpeed, StatModifier.CalculationType.NEGATIVE)
			{
				m_enabled = ConfigManager.EMoveSpeedReductionEnabled.Value,
				m_maxMultiplier = ConfigManager.EMoveSpeedMaxReduction.Value,
				m_threshold = ConfigManager.EMoveSpeedReductionMinThreshold.Value,
				m_defaultValue = 0f
			};
			c_skillGainModifier = new StatModifier(this, c_warningSkillGain, StatModifier.CalculationType.NEGATIVE)
			{
				m_enabled = ConfigManager.ESkillGainReductionEnabled.Value,
				m_maxMultiplier = ConfigManager.EMoveSpeedMaxReduction.Value,
				m_threshold = ConfigManager.EMoveSpeedReductionMinThreshold.Value,
				m_defaultValue = 0f
			};
			c_staminaReductionModifier = new StatModifier(this, c_warningStaminaReduction, StatModifier.CalculationType.INVERSE)
			{
				m_enabled = ConfigManager.EMaxStaminaReductionEnabled.Value,
				m_maxMultiplier = ConfigManager.EMaxStaminaReduction.Value,
				m_threshold = ConfigManager.EMaxStaminaReductionThreshold.Value,
				m_defaultValue = 1f
			};
			c_staminaRegenModifier = new StatModifier(this, c_warningStaminaRegen, StatModifier.CalculationType.INVERSE)
			{
				m_enabled = ConfigManager.EStaminaRegenEnabled.Value,
				m_maxMultiplier = ConfigManager.EStaminaRegenMaxReduction.Value,
				m_threshold = ConfigManager.EStaminaRegenMinThreshold.Value,
				m_defaultValue = 1f
			};
			c_staminaDelayModifier = new StatModifier(this, c_warningStaminaDelay, StatModifier.CalculationType.REGULAR)
			{
				m_enabled = ConfigManager.EStaminaRegenDelayEnabled.Value,
				m_maxMultiplier = ConfigManager.EStaminaRegenDelayMaxMultiplier.Value,
				m_threshold = ConfigManager.EStaminaRegenDelayMinThreshold.Value,
				m_defaultValue = 0f
			};
			c_energyLossResistModifier = new StatModifier(this, null, StatModifier.CalculationType.INVERSE)
			{
				m_enabled = true,
				m_maxMultiplier = ConfigManager.ELossLowEnergyResist.Value,
				m_threshold = ConfigManager.ELossLowEnergyThreshold.Value,
				m_defaultValue = 1f
			};
		}

		protected override void SetupExtraFields()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((SE_Stats)this).m_modifyAttackSkill = (SkillType)999;
			((SE_Stats)this).m_raiseSkill = (SkillType)999;
			((SE_Stats)this).m_raiseSkillModifier = 0f;
			m_staminaRegenDelay = 0f;
			m_staminaReductionMultiplier = 1f;
			m_seasonMultiplier = 1f;
			m_lossEnergyRestedMult = 1f;
			m_lossEnergyCarryWeightAdd = 0f;
			m_lossEnergyMovementAdd = 0f;
			m_staminaMeadMult = 1f;
			m_noRestMultiplier = 1f;
		}

		protected override void LoadExtraFields(List<string> list)
		{
			list[4].AssignAsFloat(out m_staminaRegenDelay);
			list[5].AssignAsFloat(out m_staminaReductionMultiplier);
			list[6].AssignAsFloat(out m_energyFromFood);
			list[7].AssignAsFloat(out m_energyFromFoodTick);
			list[8].AssignAsFloat(out m_energyRegenSpeed);
			list[9].AssignAsFloat(out m_timeSinceRested);
			list[10].AssignAsFloat(out m_fitnessSkillMultiplier);
			list[11].AssignAsFloat(out m_seasonMultiplier);
			list[12].AssignAsFloat(out m_lossEnergyRestedMult);
			list[13].AssignAsFloat(out m_lossEnergyCarryWeightAdd);
			list[14].AssignAsFloat(out m_lossEnergyMovementAdd);
			list[15].AssignAsFloat(out m_staminaMeadMult);
			list[16].AssignAsFloat(out m_noRestMultiplier);
			list[17].AssignAsBool(out c_warningSpeed.m_display);
			list[18].AssignAsBool(out c_warningStaminaRegen.m_display);
			list[19].AssignAsBool(out c_warningStaminaDelay.m_display);
			list[20].AssignAsBool(out c_warningSkillGain.m_display);
			list[21].AssignAsBool(out c_warningStaminaReduction.m_display);
			list[22].AssignAsBool(out c_warningDamage.m_display);
			list[23].AssignAsBool(out c_warningWeight.m_display);
		}

		protected override void SaveExtraFields(StringBuilder sb)
		{
			sb.AppendStat(m_staminaRegenDelay);
			sb.AppendStat(m_staminaReductionMultiplier);
			sb.AppendStat(m_energyFromFood);
			sb.AppendStat(m_energyFromFoodTick);
			sb.AppendStat(m_energyRegenSpeed);
			sb.AppendStat(m_timeSinceRested);
			sb.AppendStat(m_fitnessSkillMultiplier);
			sb.AppendStat(m_seasonMultiplier);
			sb.AppendStat(m_lossEnergyRestedMult);
			sb.AppendStat(m_lossEnergyCarryWeightAdd);
			sb.AppendStat(m_lossEnergyMovementAdd);
			sb.AppendStat(m_staminaMeadMult);
			sb.AppendStat(m_noRestMultiplier);
			sb.AppendStat(c_warningSpeed.m_display);
			sb.AppendStat(c_warningStaminaRegen.m_display);
			sb.AppendStat(c_warningStaminaDelay.m_display);
			sb.AppendStat(c_warningSkillGain.m_display);
			sb.AppendStat(c_warningStaminaReduction.m_display);
			sb.AppendStat(c_warningDamage.m_display);
			sb.AppendStat(c_warningWeight.m_display);
		}

		protected override void GetPlayerHintStrings(StringBuilder sb)
		{
			if (pes.EnergyMaxPercentage <= 99f)
			{
				sb.AppendFormat("$ea_player_energy_capped \n", Mathf.RoundToInt(pes.EnergyMaxPercentage));
			}
			if (pes.PlayerStaminaMead)
			{
				sb.Append("$ea_player_stamina_mead \n");
			}
			if (m_energyFromFood > 0f)
			{
				sb.Append("$ea_player_food_recover_energy \n");
			}
			if (m_timeSinceRested > ConfigManager.ELossNoRestThreshold.Value / 2f)
			{
				sb.Append("$ea_player_need_rest_energy \n");
			}
			if (m_statLossPerc > ConfigManager.ERestedLossThreshold.Value)
			{
				sb.Append("$ea_player_cannot_stay_rested \n");
			}
		}

		protected override void GetStatLossHintStrings(StringBuilder sb)
		{
			if (!pes.PlayerSheltered)
			{
				if (pes.PlayerCold || pes.PlayerFreezing)
				{
					sb.Append("$ea_player_coldfreezing_energy \n");
				}
				if (pes.PlayerHot || pes.PlayerScorching)
				{
					sb.Append("$ea_player_hotscorching_energy \n");
				}
			}
			if (pes.PlayerWet)
			{
				sb.Append("$ea_player_wet_energy \n");
			}
			if (pes.PlayerHungry)
			{
				sb.Append("$ea_player_hungry_energy \n");
			}
		}

		protected override void GetStatGainHintStrings(StringBuilder sb)
		{
			sb.Append("$ea_player_recovering_energy \n");
		}

		protected override void GetStatChangeStrings(StringBuilder sb)
		{
			if (m_staminaReductionMultiplier != 1f)
			{
				sb.AppendFormat("$ea_se_maxstaminamultiplier: <color=orange>{0}x</color> \n", Mathf.Floor(101f * m_staminaReductionMultiplier) / 100f);
			}
			if (m_staminaRegenDelay > 0f)
			{
				sb.AppendFormat("$ea_se_staminaregendelay: <color=orange>{0}s</color> \n", (Mathf.Floor(10f * m_staminaRegenDelay) / 10f).ToString("+0;-0"));
			}
			if (m_staminaMeadMult != 1f)
			{
				sb.AppendFormat("$ea_se_energylossresist: <color=green>{0}%</color> \n", Mathf.Floor(100f * m_staminaMeadMult));
			}
		}

		protected override void UpdateRealtimeExternalStatChanges(float dt)
		{
			UpdateStaminaRegenDelay();
			UpdateEnergyFromFood(dt);
		}

		private void UpdateStaminaRegenDelay()
		{
			if (!((Object)(object)pes == (Object)null))
			{
				player.m_staminaRegenDelay = pes.PlayerStaminaRegenDelay + m_staminaRegenDelay;
			}
		}

		private void UpdateEnergyFromFood(float dt)
		{
			if ((double)m_energyFromFood < 0.01)
			{
				m_energyFromFood = 0f;
				m_energyFromFoodTick = 0f;
				return;
			}
			m_energyFromFoodTick = m_maxStatLoss / m_baseMaxStatLoss * Mathf.Min(m_energyRegenSpeed, m_energyFromFood) * dt;
			m_statLoss -= m_energyFromFoodTick;
			float num = (100f - pes.EnergyMaxPercentage) * m_maxStatLoss / 100f;
			if (m_statLoss < num)
			{
				m_statLoss = num;
			}
			m_energyFromFood -= m_energyFromFoodTick;
		}

		protected override void UpdateTutorial()
		{
			if (m_statLossPerc > 10f)
			{
				player.ShowTutorial("EnvironmentalAwarenessEnergy", false);
			}
			if (m_statLossPerc > 60f)
			{
				player.ShowTutorial("EnvironmentalAwarenessEnergyLow", false);
			}
		}

		protected override void UpdatePerSecondStateChanges()
		{
			UpdateNonRestedState();
			UpdateMovementState();
		}

		private void UpdateNonRestedState()
		{
			if (pes.PlayerRested)
			{
				m_timeSinceRested = 0f;
				m_noRestMultiplier = 1f;
			}
			else
			{
				m_timeSinceRested += 1f;
				m_noRestMultiplier = 1f + Mathf.Min(m_timeSinceRested / ConfigManager.ELossNoRestThreshold.Value, 1f) * (ConfigManager.ELossNoRestMultiplier.Value - 1f);
			}
		}

		private void UpdateMovementState()
		{
			m_lossEnergyMovementAdd = (pes.PlayerMoving ? (m_noRestMultiplier * m_seasonMultiplier * m_fitnessSkillMultiplier * m_lossEnergyRestedMult * ConfigManager.ELossMotionAdd.Value) : 0f);
		}

		protected override void UpdateStatValue()
		{
			float num = c_energyLossResistModifier.CalculateMultiplier() * (m_statChange + m_lossEnergyMovementAdd);
			m_statLoss = Mathf.Clamp(m_statLoss + num, 0f, m_maxStatLoss);
			m_statLoss = Mathf.Max((100f - pes.EnergyMaxPercentage) * m_maxStatLoss / 100f, m_statLoss);
		}

		public override void Recalculate()
		{
			base.Recalculate();
			m_lossEnergyRestedMult = CalculateRestedMultiplier();
			m_lossEnergyCarryWeightAdd = CalculateCarryWeightAdd();
			m_seasonMultiplier = CalculateSeasonMultiplier();
			m_staminaMeadMult = CalculateStaminaMeadMultiplier();
			m_fitnessSkillMultiplier = CalculateFitnessSkillMultiplier();
			m_statChange = m_staminaMeadMult * m_seasonMultiplier * m_fitnessSkillMultiplier * CalculatePassiveLosses() - (CalculateGainsFromRest() + CalculateGainsFromStaminaMead());
		}

		private float CalculateRestedMultiplier()
		{
			return pes.PlayerRested ? ConfigManager.ELossRestedResist.Value : 1f;
		}

		private float CalculateCarryWeightAdd()
		{
			return c_carryWeightModifier.CalculateMultiplier(pes.PlayerCarryWeightPerc);
		}

		private float CalculatePassiveLosses()
		{
			float num = 0f;
			if (pes.PlayerCold)
			{
				num += ConfigManager.ELossColdAdd.Value;
			}
			if (pes.PlayerFreezing)
			{
				num += ConfigManager.ELossFreezingAdd.Value;
			}
			if (pes.PlayerHot)
			{
				num += ConfigManager.ELossHotAdd.Value;
			}
			if (pes.PlayerScorching)
			{
				num += ConfigManager.ELossScorchingAdd.Value;
			}
			if (pes.PlayerWet)
			{
				num += ConfigManager.ELossWetAdd.Value;
			}
			if (pes.PlayerHungry)
			{
				num += ConfigManager.ELossHungryAdd.Value;
			}
			return m_lossEnergyRestedMult * num;
		}

		private float CalculateGainsFromRest()
		{
			float num = 0f;
			if (pes.PlayerSitting)
			{
				num += ConfigManager.ELossSittingRemove.Value;
			}
			if (pes.PlayerResting)
			{
				num += ConfigManager.ELossRestingRemove.Value;
			}
			if (pes.PlayerRested && !pes.PlayerResting && !pes.PlayerHasBadEnvironmentalStatus)
			{
				num += ConfigManager.ELossRestedRemove.Value;
			}
			if (pes.PlayerSitting && pes.PlayerResting)
			{
				num *= ConfigManager.ELossSittingRestingMultiplier.Value;
			}
			if (pes.PlayerSitting && pes.PlayerResting && pes.PlayerSheltered)
			{
				num *= ConfigManager.ELossSittingRestingShelterMultiplier.Value;
			}
			return m_maxStatLoss / m_baseMaxStatLoss * num;
		}

		private float CalculateGainsFromStaminaMead()
		{
			return pes.PlayerStaminaMead ? (ConfigManager.ELossStaminaMeadRemove.Value * m_maxStatLoss) : 0f;
		}

		protected override float CalculateAdditionalMaxStat()
		{
			float num = pes.FitnessSkillLevel / 100f;
			float num2 = ConfigManager.FitnessSkillMaxEnergyGain.Value - m_baseMaxStatLoss;
			return num * num2;
		}

		private float CalculateSeasonMultiplier()
		{
			if (pes.PlayerInSeasonExcludedBiome)
			{
				return m_seasonMultiplier = 1f;
			}
			return pes.EnvironmentSeasonState switch
			{
				EnvManHelper.Season.Spring => m_seasonMultiplier = ConfigManager.ESpringSeasonMultiplier.Value, 
				EnvManHelper.Season.Summer => m_seasonMultiplier = ConfigManager.ESummerSeasonMultiplier.Value, 
				EnvManHelper.Season.Fall => m_seasonMultiplier = ConfigManager.EFallSeasonMultiplier.Value, 
				EnvManHelper.Season.Winter => m_seasonMultiplier = ConfigManager.EWinterSeasonMultiplier.Value, 
				_ => m_seasonMultiplier = 1f, 
			};
		}

		private float CalculateStaminaMeadMultiplier()
		{
			return m_staminaMeadMult = (pes.PlayerStaminaMead ? (1f - ConfigManager.ELossStaminaMeadResist.Value) : 1f);
		}

		private float CalculateFitnessSkillMultiplier()
		{
			return 1f - pes.FitnessSkillFactor;
		}

		protected override void UpdateEffects()
		{
			UpdateRemoveRested();
			UpdateStatusEffectModifiers();
		}

		private void UpdateRemoveRested()
		{
			if (c_restedRemoveModifier.CalculateMultiplier() > 0f && pes.PlayerRested && !pes.PlayerResting)
			{
				StatusEffect statusEffect = ((Character)player).m_seman.GetStatusEffect(SEMan.s_statusEffectRested);
				SE_Rested val = (SE_Rested)(object)((statusEffect is SE_Rested) ? statusEffect : null);
				if (!((Object)(object)val == (Object)null))
				{
					((Character)player).m_seman.RemoveStatusEffect((StatusEffect)(object)val, false);
				}
			}
		}

		private void UpdateStatusEffectModifiers()
		{
			((SE_Stats)this).m_damageModifier = c_damageModifier.CalculateMultiplier();
			((SE_Stats)this).m_speedModifier = c_speedModifier.CalculateMultiplier();
			((SE_Stats)this).m_raiseSkillModifier = c_skillGainModifier.CalculateMultiplier();
			m_staminaReductionMultiplier = c_staminaReductionModifier.CalculateMultiplier();
			((SE_Stats)this).m_staminaRegenMultiplier = c_staminaRegenModifier.CalculateMultiplier();
			m_staminaRegenDelay = c_staminaDelayModifier.CalculateMultiplier();
		}

		public void ApplyEnergyGainFromFood(float stamina)
		{
			if (!pes.PlayerNoSkillDrain && !(countdownTimer > 0f))
			{
				float num = stamina * ConfigManager.ELossFoodStaminaRemove.Value;
				float num2 = m_maxStatLoss / m_baseMaxStatLoss;
				m_energyFromFood += num * num2;
			}
		}

		public void ApplyEnergyGainFromSleeping()
		{
			base.ChangeStatLossByPercentage(-1f * ConfigManager.ELossPercentageSleepRemove.Value);
		}

		public void ApplyEnergyLossFromStamina(float stamina)
		{
			if (!pes.PlayerNoSkillDrain && !(countdownTimer > 0f))
			{
				float num = stamina * (ConfigManager.ELossStaminaPointUsedAdd.Value + m_lossEnergyCarryWeightAdd);
				float num2 = m_lossEnergyRestedMult * m_seasonMultiplier * m_fitnessSkillMultiplier * m_noRestMultiplier * (1f - pes.FitnessSkillFactor) * num;
				m_statLoss += num2;
				if (m_statLoss > m_maxStatLoss)
				{
					num = m_statLoss - m_maxStatLoss;
					m_statLoss = m_maxStatLoss;
				}
				RaiseFitnessSkill(num);
				s_totalStaminaUseInCycle += stamina;
				s_totalEnergyUseInCycle += num2;
				s_lastRawLossInCycle = num;
			}
		}

		public void RaiseFitnessSkill(float amount)
		{
			((StatusEffect)this).m_character.RaiseSkill("Fitness", 0.2f * amount * ConfigManager.FitnessSkillGainFactor.Value);
		}

		protected override void LogStatistics()
		{
			Main.LogMessage(() => string.Join("\n", new List<string>
			{
				"ENERGY SE UPDATE",
				$"Energy: {Mathf.Round(100f - m_statLossPerc)} ({m_maxStatLoss - m_statLoss} / {m_maxStatLoss})",
				$"Rested Resist Mult: {m_lossEnergyRestedMult}",
				$"No Rested Debuffs: +{m_noRestMultiplier}x ({m_timeSinceRested}s since last rested)",
				$"Stamina Regen Multiplier: {((SE_Stats)this).m_staminaRegenMultiplier}x",
				$"Stamina Regen Delay: +{m_staminaRegenDelay}s",
				$"Seasonal Multiplier: {m_seasonMultiplier}x",
				$"Fitness Skill Multiplier {m_fitnessSkillMultiplier}x",
				$"Stamina Use in Cycle: {s_totalStaminaUseInCycle}",
				$"Energy Loss from Stamina in Cycle: {s_totalEnergyUseInCycle}",
				$"Last Raw Loss in Cycle: {s_lastRawLossInCycle}"
			}));
		}

		protected override void ResetCycleStats()
		{
			s_totalStaminaUseInCycle = 0f;
			s_totalEnergyUseInCycle = 0f;
			s_lastRawLossInCycle = 0f;
		}

		public override void GetAdditionalDebugStrings(StringBuilder sb)
		{
			base.GetAdditionalDebugStrings(sb);
			sb.AppendFormat("m_staminaRegenDelay: {0}\n", m_staminaRegenDelay);
			sb.AppendFormat("m_staminaReductionMultiplier: {0}\n", m_staminaReductionMultiplier);
			sb.AppendFormat("m_energyFromFood: {0}\n", m_energyFromFood);
			sb.AppendFormat("m_energyFromFoodTick: {0}\n", m_energyFromFoodTick);
			sb.AppendFormat("m_energyRegenSpeed: {0}\n", m_energyRegenSpeed);
			sb.AppendFormat("m_timeSinceRested: {0}\n", m_timeSinceRested);
			sb.AppendFormat("m_fitnessSkillMultiplier: {0}\n", m_fitnessSkillMultiplier);
			sb.AppendFormat("m_seasonMultiplier: {0}\n", m_seasonMultiplier);
			sb.AppendFormat("m_lossEnergyRestedMult: {0}\n", m_lossEnergyRestedMult);
			sb.AppendFormat("m_lossEnergyCarryWeightAdd: {0}\n", m_lossEnergyCarryWeightAdd);
			sb.AppendFormat("m_lossEnergyMovementAdd: {0}\n", m_lossEnergyMovementAdd);
			sb.AppendFormat("m_staminaMeadMult: {0}\n", m_staminaMeadMult);
			sb.AppendFormat("m_noRestMultiplier: {0}\n", m_noRestMultiplier);
		}
	}
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	public class SE_Hot : SE_Stats
	{
		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.HotSEName);

		public float m_iconTimer;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(new byte[] { 2, 1 })]
		public Sprite[] m_icons;

		public override void Setup(Character character)
		{
			((StatusEffect)this).m_startMessage = "$ea_player_hot_status";
			((SE_Stats)this).Setup(character);
			((StatusEffect)this).m_name = "$ea_se_hot";
			LoadIcons();
			UpdateIcon();
			base.m_healthRegenMultiplier = 0.5f;
			base.m_staminaRegenMultiplier = 0.75f;
			base.m_eitrRegenMultiplier = 0.75f;
			base.m_speedModifier = -0.05f;
		}

		public override void UpdateStatusEffect(float dt)
		{
			m_iconTimer += dt;
			if (m_iconTimer > 5f)
			{
				UpdateIcon();
				m_iconTimer -= 5f;
			}
			((SE_Stats)this).UpdateStatusEffect(dt);
		}

		protected virtual void LoadIcons()
		{
			m_icons = (Sprite[])(object)new Sprite[2]
			{
				Main.GetInstance().Bundle.LoadAsset<Sprite>("hoticon"),
				Main.GetInstance().Bundle.LoadAsset<Sprite>("hoticon2")
			};
		}

		protected virtual void UpdateIcon()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			Character character = ((StatusEffect)this).m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (!((Object)(object)val == (Object)null))
			{
				((StatusEffect)this).m_icon = m_icons[((int)val.GetCurrentBiome() == 32 && EnvMan.IsNight()) ? 1 : 0];
			}
		}

		public override string GetIconText()
		{
			return "";
		}

		public override string GetTooltipString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("$ea_player_hot_status \n");
			stringBuilder.Append(((SE_Stats)this).GetTooltipString());
			return stringBuilder.ToString();
		}
	}
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	public class SE_Hungry : SE_Stats
	{
		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.HungrySEName);

		public override void Setup(Character character)
		{
			((StatusEffect)this).m_startMessage = "$ea_player_hungry_status";
			((SE_Stats)this).Setup(character);
			((StatusEffect)this).m_name = "$ea_se_hungry";
			((StatusEffect)this).m_icon = Main.GetInstance().Bundle.LoadAsset<Sprite>("hungryicon");
			((StatusEffect)this).m_ttl = 1f;
		}

		public override string GetIconText()
		{
			return "";
		}

		public override void UpdateStatusEffect(float dt)
		{
			if (!(((StatusEffect)this).m_time > ((StatusEffect)this).m_ttl))
			{
				((SE_Stats)this).UpdateStatusEffect(dt);
				((StatusEffect)this).m_time = 0f;
			}
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			((StatusEffect)this).m_ttl = 1f;
		}

		public override string GetTooltipString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("$ea_player_hungry_status \n");
			stringBuilder.Append(((SE_Stats)this).GetTooltipString());
			return stringBuilder.ToString();
		}
	}
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	public class SE_PlayerStats : StatusEffect, ILoadSave
	{
		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(0)]
		private delegate void HandleSurvivalSEs();

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		public Player player;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private HandleSurvivalSEs HandleSurvivalSE;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private SE_Vitality vitality;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private SE_Energy energy;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private SE_Capability capability;

		private List<string> playerState = new List<string>();

		private List<string> environmentState = new List<string>();

		private float player_base_health;

		private float player_base_stamina;

		private float player_base_stamina_regen_delay;

		private float player_carry_weight_perc;

		private bool player_no_skill_drain;

		private float player_health_percentage;

		private float player_body_armor;

		private bool player_healing_mead;

		private bool player_stamina_mead;

		private bool player_eitr_mead;

		private float player_time_since_final_food_digested;

		private float player_time_since_eaten_with_good_hp;

		private Biome player_in_biome = (Biome)895;

		private bool player_in_excluded_environment;

		private bool player_moving;

		private bool player_poison_resistant;

		private bool player_poison_very_resistant;

		private bool player_fire_resistant;

		private bool player_fire_very_resistant;

		private bool player_lightning_resistant;

		private bool player_lightning_very_resistant;

		private bool player_frost_resistant;

		private bool player_frost_very_resistant;

		private bool player_sheltered;

		private bool player_sitting;

		private bool player_laying_in_bed;

		private bool player_sleeping;

		private bool player_near_fire;

		private bool player_resting;

		private bool player_rested;

		private bool player_wet;

		private bool player_cold;

		private bool player_freezing;

		private bool player_hot;

		private bool player_scorching;

		private bool player_hungry;

		private bool player_poisoned;

		private bool player_burning;

		private bool player_shocked;

		private bool player_frozen;

		private bool player_blood_protected;

		private bool environment_wet;

		private bool environment_cold;

		private bool environment_freezing;

		private bool environment_hot;

		private bool environment_scorching;

		private float environment_wind_intensity;

		private EnvManHelper.Season environment_season_state;

		private float resistance_skill_level;

		private float resistance_skill_factor;

		private float fitness_skill_level;

		private float fitness_skill_factor;

		private float perseverence_skill_level;

		private float perseverence_skill_factor;

		private float resistance_extra_attack_multiplier = 1f;

		private float resistance_extra_mead_duration_multiplier = 1f;

		private float fitness_food_burn_multiplier = 1f;

		private float fitness_speed_penalty_reduction = 0f;

		private int perseverence_comfort_bonus = 0;

		private float perseverence_max_adrenaline_multiplier = 1f;

		private float vitality_max_percentage = 100f;

		private float energy_max_percentage = 100f;

		private bool recalculate = false;

		public float lastUpdateTime = 0f;

		public float lastLogTime = 0f;

		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.PlayerStatsSEName);

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private PlayerFoodCache player_food_cache;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		private SE_Stats_Modifiers se_stats_modifiers;

		public List<string> PlayerState => playerState;

		public List<string> EnvironmentState => environmentState;

		public float PlayerBaseHealth => player_base_health;

		public float PlayerBaseStamina => player_base_stamina;

		public float PlayerStaminaRegenDelay => player_base_stamina_regen_delay;

		public float PlayerCarryWeightPerc
		{
			get
			{
				return player_carry_weight_perc;
			}
			set
			{
				if (Helper.Approximately(player_carry_weight_perc, value))
				{
					player_carry_weight_perc = value;
					return;
				}
				Main.LogMessage(() => $"Player carry weight changed to {value}%.");
				player_carry_weight_perc = value;
				recalculate = true;
			}
		}

		public bool PlayerNoSkillDrain
		{
			get
			{
				return player_no_skill_drain;
			}
			set
			{
				if (player_no_skill_drain != value)
				{
					Main.LogMessage(() => "Player no skill drain changed.");
					player_no_skill_drain = value;
					recalculate = true;
					playerState.CheckState(value, "No Skill Drain");
				}
			}
		}

		public float PlayerHealthPercentage
		{
			get
			{
				return player_health_percentage;
			}
			set
			{
				if (!(Mathf.Abs(player_health_percentage - value) < 0.001f))
				{
					Main.LogMessage(() => $"Player HP percentage changed to {value}%.");
					player_health_percentage = value;
					recalculate = true;
				}
			}
		}

		public float PlayerBodyArmor
		{
			get
			{
				return player_body_armor;
			}
			set
			{
				if (Helper.Approximately(player_body_armor, value))
				{
					player_body_armor = value;
					return;
				}
				Main.LogMessage(() => $"Player armor changed to {value}.");
				player_body_armor = value;
				recalculate = true;
			}
		}

		public bool PlayerHealingMead
		{
			get
			{
				return player_healing_mead;
			}
			set
			{
				if (player_healing_mead != value)
				{
					Main.LogMessage(() => "Player healing mead changed.");
					player_healing_mead = value;
					recalculate = true;
					playerState.CheckState(value, "Using Healing Mead");
				}
			}
		}

		public bool PlayerStaminaMead
		{
			get
			{
				return player_stamina_mead;
			}
			set
			{
				if (player_stamina_mead != value)
				{
					Main.LogMessage(() => "Player stamina mead changed.");
					player_stamina_mead = value;
					recalculate = true;
					playerState.CheckState(value, "Using Stamina Mead");
				}
			}
		}

		public bool PlayerEitrMead
		{
			get
			{
				return player_eitr_mead;
			}
			set
			{
				if (player_eitr_mead != value)
				{
					Main.LogMessage(() => "Player eitr mead changed.");
					player_eitr_mead = value;
					recalculate = true;
					playerState.CheckState(value, "Using Eitr Mead");
				}
			}
		}

		public float PlayerTimeSinceEatenWithGoodHP
		{
			get
			{
				return player_time_since_eaten_with_good_hp;
			}
			set
			{
				if (!Helper.Approximately(player_time_since_eaten_with_good_hp, value))
				{
					Main.LogMessage(() => $"Player time since eaten with good HP set to {value}");
					if (value == 0f || (value > 60f && player_time_since_eaten_with_good_hp <= 60f))
					{
						recalculate = true;
					}
					player_time_since_eaten_with_good_hp = value;
				}
			}
		}

		public float PlayerTimeSinceFinalFoodDigested
		{
			get
			{
				return player_time_since_final_food_digested;
			}
			set
			{
				if (!Helper.Approximately(player_time_since_final_food_digested, value))
				{
					Main.LogMessage(() => $"Player time since final food digested set to {value}.");
					player_time_since_final_food_digested = value;
				}
			}
		}

		public bool PlayerInSeasonExcludedBiome => (int)PlayerInBiome == 64 || (int)PlayerInBiome == 32 || (int)PlayerInBiome == 4;

		public Biome PlayerInBiome
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return player_in_biome;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				if (player_in_biome != value)
				{
					Main.LogMessage(() => $"Change to biome. Player now in biome {value}.");
					player_in_biome = value;
					recalculate = true;
				}
			}
		}

		public bool PlayerInHarshBiome => new List<Biome>
		{
			(Biome)32,
			(Biome)64
		}.Contains(PlayerInBiome);

		public bool PlayerInExcludedEnvironment
		{
			get
			{
				return player_in_excluded_environment;
			}
			set
			{
				if (player_in_excluded_environment != value)
				{
					Main.LogMessage(() => "Change to excluded enviornment.");
					player_in_excluded_environment = value;
					recalculate = true;
					playerState.CheckState(value, "In Excluded Environment");
				}
			}
		}

		public bool PlayerMoving
		{
			get
			{
				return player_moving;
			}
			set
			{
				if (player_moving != value)
				{
					Main.LogMessage(() => "Change to movement.");
					player_moving = value;
					playerState.CheckState(value, "Moving");
				}
			}
		}

		public bool PlayerPoisonResistant
		{
			get
			{
				return player_poison_resistant;
			}
			set
			{
				if (player_poison_resistant != value)
				{
					Main.LogMessage(() => "Change to poison resistant.");
					player_poison_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Resistant vs Poison");
				}
			}
		}

		public bool PlayerPoisonVeryResistant
		{
			get
			{
				return player_poison_very_resistant;
			}
			set
			{
				if (player_poison_very_resistant != value)
				{
					Main.LogMessage(() => "Change to poison very resistant.");
					player_poison_very_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Very Resistant vs Poison");
				}
			}
		}

		public bool PlayerFireResistant
		{
			get
			{
				return player_fire_resistant;
			}
			set
			{
				if (player_fire_resistant != value)
				{
					Main.LogMessage(() => "Change to fire resistant.");
					player_fire_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Resistant vs Fire");
				}
			}
		}

		public bool PlayerFireVeryResistant
		{
			get
			{
				return player_fire_very_resistant;
			}
			set
			{
				if (player_fire_very_resistant != value)
				{
					Main.LogMessage(() => "Change to fire very resistant.");
					player_fire_very_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Very Resistant vs Fire");
				}
			}
		}

		public bool PlayerLightningResistant
		{
			get
			{
				return player_lightning_resistant;
			}
			set
			{
				if (player_lightning_resistant != value)
				{
					Main.LogMessage(() => "Change to lightning resistant.");
					player_lightning_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Resistant vs Lightning");
				}
			}
		}

		public bool PlayerLightningVeryResistant
		{
			get
			{
				return player_lightning_very_resistant;
			}
			set
			{
				if (player_lightning_very_resistant != value)
				{
					Main.LogMessage(() => "Change to lightning very resistant.");
					player_lightning_very_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Very Resistant vs Lightning");
				}
			}
		}

		public EnvManHelper.Season EnvironmentSeasonState
		{
			get
			{
				return environment_season_state;
			}
			set
			{
				if (environment_season_state != value)
				{
					Main.LogMessage(() => $"Change to season. Now in season {value}");
					environment_season_state = value;
					recalculate = true;
				}
			}
		}

		public bool PlayerFrostResistant
		{
			get
			{
				return player_frost_resistant;
			}
			set
			{
				if (player_frost_resistant != value)
				{
					Main.LogMessage(() => "Change to frost resistant.");
					player_frost_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Resistant vs Frost");
				}
			}
		}

		public bool PlayerFrostVeryResistant
		{
			get
			{
				return player_frost_very_resistant;
			}
			set
			{
				if (player_frost_very_resistant != value)
				{
					Main.LogMessage(() => "Change to frost very resistant.");
					player_frost_very_resistant = value;
					recalculate = true;
					playerState.CheckState(value, "Very Resistant vs Frost");
				}
			}
		}

		public bool PlayerSitting
		{
			get
			{
				return player_sitting;
			}
			set
			{
				if (player_sitting != value)
				{
					Main.LogMessage(() => "Change to sitting.");
					player_sitting = value;
					recalculate = true;
					playerState.CheckState(value, "Sitting");
				}
			}
		}

		public bool PlayerLayingInBed
		{
			get
			{
				return player_laying_in_bed;
			}
			set
			{
				if (player_laying_in_bed != value)
				{
					Main.LogMessage(() => "Change to laying in bed.");
					player_laying_in_bed = value;
					recalculate = true;
					playerState.CheckState(value, "Laying in a bed");
				}
			}
		}

		public bool PlayerSleeping
		{
			get
			{
				return player_sleeping;
			}
			set
			{
				if (player_sleeping != value)
				{
					Main.LogMessage(() => "Change to sleeping.");
					player_sleeping = value;
					recalculate = true;
					playerState.CheckState(value, "Sleeping");
				}
			}
		}

		public bool PlayerSheltered
		{
			get
			{
				return player_sheltered;
			}
			set
			{
				if (player_sheltered != value)
				{
					Main.LogMessage(() => "Change to sheltered.");
					player_sheltered = value;
					recalculate = true;
					playerState.CheckState(value, "In Shelter");
				}
			}
		}

		public bool PlayerNearFire
		{
			get
			{
				return player_near_fire;
			}
			set
			{
				if (player_near_fire != value)
				{
					Main.LogMessage(() => "Change to near fire.");
					player_near_fire = value;
					recalculate = true;
					playerState.CheckState(value, "Near Fire");
				}
			}
		}

		public bool PlayerResting
		{
			get
			{
				return player_resting;
			}
			set
			{
				if (player_resting != value)
				{
					Main.LogMessage(() => "Change to resting.");
					player_resting = value;
					recalculate = true;
					playerState.CheckState(value, "Resting");
				}
			}
		}

		public bool PlayerRested
		{
			get
			{
				return player_rested;
			}
			set
			{
				if (player_rested != value)
				{
					Main.LogMessage(() => "Change to rested.");
					player_rested = value;
					recalculate = true;
					playerState.CheckState(value, "Rested");
				}
			}
		}

		public bool PlayerWet
		{
			get
			{
				return player_wet;
			}
			set
			{
				if (player_wet != value)
				{
					Main.LogMessage(() => "Change to player wet.");
					player_wet = value;
					recalculate = true;
					playerState.CheckState(value, "Wet");
				}
			}
		}

		public bool PlayerCold
		{
			get
			{
				return player_cold;
			}
			set
			{
				if (player_cold != value)
				{
					Main.LogMessage(() => "Change to player cold.");
					player_cold = value;
					recalculate = true;
					playerState.CheckState(value, "Cold");
				}
			}
		}

		public bool PlayerFreezing
		{
			get
			{
				return player_freezing;
			}
			set
			{
				if (player_freezing != value)
				{
					Main.LogMessage(() => "Change to player freezing.");
					player_freezing = value;
					recalculate = true;
					playerState.CheckState(value, "Freezing");
				}
			}
		}

		public bool PlayerHot
		{
			get
			{
				return player_hot;
			}
			set
			{
				if (player_hot != value)
				{
					Main.LogMessage(() => "Change to player hot.");
					player_hot = value;
					recalculate = true;
					playerState.CheckState(value, "Hot");
				}
			}
		}

		public bool PlayerScorching
		{
			get
			{
				return player_scorching;
			}
			set
			{
				if (player_scorching != value)
				{
					Main.LogMessage(() => "Change to player scorching.");
					player_scorching = value;
					recalculate = true;
					playerState.CheckState(value, "Scorching");
				}
			}
		}

		public bool PlayerHungry
		{
			get
			{
				return player_hungry;
			}
			set
			{
				if (player_hungry != value)
				{
					Main.LogMessage(() => "Change to player hungry.");
					player_hungry = value;
					recalculate = true;
					playerState.CheckState(value, "Hungry");
				}
			}
		}

		public bool PlayerPoisoned
		{
			get
			{
				return player_poisoned;
			}
			set
			{
				if (player_poisoned != value)
				{
					Main.LogMessage(() => "Change to player poisoned.");
					player_poisoned = value;
					recalculate = true;
					playerState.CheckState(value, "Poisoned");
				}
			}
		}

		public bool PlayerBurning
		{
			get
			{
				return player_burning;
			}
			set
			{
				if (player_burning != value)
				{
					Main.LogMessage(() => "Change to player burning.");
					player_burning = value;
					recalculate = true;
					playerState.CheckState(value, "Burning");
				}
			}
		}

		public bool PlayerShocked
		{
			get
			{
				return player_shocked;
			}
			set
			{
				if (player_shocked != value)
				{
					Main.LogMessage(() => "Change to player shocked.");
					player_shocked = value;
					recalculate = true;
					playerState.CheckState(value, "Shocked");
				}
			}
		}

		public bool PlayerFrozen
		{
			get
			{
				return player_frozen;
			}
			set
			{
				if (player_frozen != value)
				{
					Main.LogMessage(() => "Change to player frozen.");
					player_frozen = value;
					recalculate = true;
					playerState.CheckState(value, "Frozen");
				}
			}
		}

		public bool PlayerBloodProtected
		{
			get
			{
				return player_blood_protected;
			}
			set
			{
				if (player_blood_protected != value)
				{
					Main.LogMessage(() => "Change to player blood protected.");
					player_blood_protected = value;
					recalculate = true;
					playerState.CheckState(value, "Blood Protected");
				}
			}
		}

		public bool PlayerHasBadElementalStatus => PlayerPoisoned || PlayerBurning || PlayerShocked || PlayerFrozen;

		public bool PlayerHasBadEnvironmentalStatus => PlayerWet || PlayerCold || PlayerFreezing || PlayerInHarshBiome;

		public PlayerFoodCache PlayerFoodCache
		{
			get
			{
				if (player_food_cache == null)
				{
					RefreshFoodCacheRefereces();
				}
				return player_food_cache;
			}
		}

		public SE_Stats_Modifiers StatsModifiers
		{
			get
			{
				if (se_stats_modifiers == null)
				{
					se_stats_modifiers = new SE_Stats_Modifiers(this);
				}
				return se_stats_modifiers;
			}
		}

		public bool EnvironmentWet
		{
			get
			{
				return environment_wet;
			}
			set
			{
				if (environment_wet != value)
				{
					Main.LogMessage(() => "Change to environment wet.");
					environment_wet = value;
					recalculate = true;
					environmentState.CheckState(value, "Wet");
				}
			}
		}

		public bool EnvironmentCold
		{
			get
			{
				return environment_cold;
			}
			set
			{
				if (environment_cold != value)
				{
					Main.LogMessage(() => "Change to environment cold.");
					environment_cold = value;
					recalculate = true;
					environmentState.CheckState(value, "Cold");
				}
			}
		}

		public bool EnvironmentFreezing
		{
			get
			{
				return environment_freezing;
			}
			set
			{
				if (environment_freezing != value)
				{
					Main.LogMessage(() => "Change to enviornment freezing.");
					environment_freezing = value;
					recalculate = true;
					environmentState.CheckState(value, "Freezing");
				}
			}
		}

		public bool EnvironmentHot
		{
			get
			{
				return environment_hot;
			}
			set
			{
				if (environment_hot != value)
				{
					Main.LogMessage(() => "Change to enviornment hot.");
					environment_hot = value;
					recalculate = true;
					environmentState.CheckState(value, "Hot");
				}
			}
		}

		public bool EnvironmentScorching
		{
			get
			{
				return environment_scorching;
			}
			set
			{
				if (environment_scorching != value)
				{
					Main.LogMessage(() => "Change to enviornment scorching.");
					environment_scorching = value;
					recalculate = true;
					environmentState.CheckState(value, "Scorching");
				}
			}
		}

		public float EnvironmentWindIntensity
		{
			get
			{
				return environment_wind_intensity;
			}
			set
			{
				if (!Helper.Approximately(environment_wind_intensity, value))
				{
					Main.LogMessage(() => "Change to enviornment wind intensity.");
					environment_wind_intensity = value;
					recalculate = true;
				}
			}
		}

		public float ResistanceSkillLevel
		{
			get
			{
				return resistance_skill_level;
			}
			set
			{
				if (!Helper.IntEqual(resistance_skill_level, value))
				{
					Main.LogMessage(() => $"Change to resistance skill level: {value}");
					resistance_skill_level = value;
					CalculateResistanceExtraAttackMultiplier();
					CalculateResistanceExtraMeadDurationMultiplier();
					RecalculateStatusEffectModifiers();
					recalculate = true;
				}
			}
		}

		public float ResistanceSkillFactor
		{
			get
			{
				return resistance_skill_factor;
			}
			set
			{
				if (!Helper.Approximately(resistance_skill_factor, value))
				{
					Main.LogMessage(() => $"Change to resistance skill factor: {value}");
					resistance_skill_factor = value;
				}
			}
		}

		public float FitnessSkillLevel
		{
			get
			{
				return fitness_skill_level;
			}
			set
			{
				if (!Helper.IntEqual(fitness_skill_level, value))
				{
					Main.LogMessage(() => $"Change to fitness skill level: {value}");
					fitness_skill_level = value;
					CalculateFitnessFoodBurnMultiplier();
					CalculateFitnessSpeedPenaltyReduction();
					recalculate = true;
				}
			}
		}

		public float FitnessSkillFactor
		{
			get
			{
				return fitness_skill_factor;
			}
			set
			{
				if (!Helper.Approximately(fitness_skill_factor, value))
				{
					Main.LogMessage(() => $"Change to fitness skill factor: {value}");
					fitness_skill_factor = value;
				}
			}
		}

		public float PerseverenceSkillLevel
		{
			get
			{
				return perseverence_skill_level;
			}
			set
			{
				if (!Helper.IntEqual(perseverence_skill_level, value))
				{
					Main.LogMessage(() => $"Change to perseverence skill level: {value}");
					perseverence_skill_level = value;
					CalculatePerseverenceComfortBonus();
					CalculatePerseverenceMaxAdrenalineMultiplier();
					recalculate = true;
				}
			}
		}

		public float PerseverenceSkillFactor
		{
			get
			{
				return perseverence_skill_factor;
			}
			set
			{
				if (!Helper.Approximately(perseverence_skill_factor, value))
				{
					Main.LogMessage(() => $"Change to perseverence skill factor: {value}");
					perseverence_skill_factor = value;
				}
			}
		}

		public float VitalityPercentage
		{
			get
			{
				if ((Object)(object)vitality == (Object)null)
				{
					return 100f;
				}
				return 100f - vitality.m_statLossPerc;
			}
		}

		public float EnergyPercentage
		{
			get
			{
				if ((Object)(object)energy == (Object)null)
				{
					return 100f;
				}
				return 100f - energy.m_statLossPerc;
			}
		}

		public float VitalityMaxPercentage
		{
			get
			{
				return vitality_max_percentage;
			}
			set
			{
				vitality_max_percentage = Mathf.Clamp(value, 0f, 100f);
			}
		}

		public float EnergyMaxPercentage
		{
			get
			{
				return energy_max_percentage;
			}
			set
			{
				energy_max_percentage = Mathf.Clamp(value, 0f, 100f);
			}
		}

		public float ResistanceExtraAttackMultiplier => resistance_extra_attack_multiplier;

		public float ResistanceExtraMeadDurationMultiplier => resistance_extra_mead_duration_multiplier;

		public float FitnessFoodBurnMultiplier => fitness_food_burn_multiplier;

		public float FitnessSpeedPenaltyReduction => fitness_speed_penalty_reduction;

		public int PerseverenceComfortBonus => perseverence_comfort_bonus;

		public float PerseverenceMaxAdrenalineMultiplier => perseverence_max_adrenaline_multiplier;

		protected virtual string DataKey => "EnvironmentalAwareness_" + Main.PlayerStatsSEName;

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			base.m_ttl = 1f;
			base.m_name = "$ea_se_playerstats";
			if (!base.m_character.IsPlayer())
			{
				base.m_time = base.m_ttl;
				return;
			}
			ref Player reference = ref player;
			Character character2 = base.m_character;
			reference = (Player)(object)((character2 is Player) ? character2 : null);
			if ((Object)(object)player == (Object)null)
			{
				base.m_time = base.m_ttl + 1f;
				Main.LogMessage(() => "Survival stats not applied to player. Removing.");
			}
			else
			{
				CheckBaseStats();
				player_food_cache = new PlayerFoodCache(player);
				se_stats_modifiers = new SE_Stats_Modifiers(this);
				LoadData();
				HandleStatusEffectSetup();
			}
		}

		public void HandleStatusEffectSetup()
		{
			if (ConfigManager.VitalityEnabled.Value)
			{
				HandleSurvivalSE = (HandleSurvivalSEs)Delegate.Combine(HandleSurvivalSE, new HandleSurvivalSEs(HandleVitality));
			}
			else
			{
				FlashStatusEffect<SE_Vitality>(SE_Vitality.Hash);
			}
			if (ConfigManager.EnergyEnabled.Value)
			{
				HandleSurvivalSE = (HandleSurvivalSEs)Delegate.Combine(HandleSurvivalSE, new HandleSurvivalSEs(HandleEnergy));
			}
			else
			{
				FlashStatusEffect<SE_Energy>(SE_Energy.Hash);
			}
			if (ConfigManager.CapabilityEnabled.Value)
			{
				HandleSurvivalSE = (HandleSurvivalSEs)Delegate.Combine(HandleSurvivalSE, new HandleSurvivalSEs(HandleCapability));
			}
			else
			{
				FlashStatusEffect<SE_Capability>(SE_Capability.Hash);
			}
		}

		public void CleanupAndRemoveSurvivalEffects()
		{
			SaveAndRemoveStatusEffect<SE_Vitality>(SE_Vitality.Hash);
			SaveAndRemoveStatusEffect<SE_Energy>(SE_Energy.Hash);
			SaveAndRemoveStatusEffect<SE_Capability>(SE_Capability.Hash);
			SaveData();
			base.m_time = base.m_ttl + 1f;
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			base.m_time = 0f;
			lastUpdateTime += dt;
			lastLogTime += dt;
			if (lastUpdateTime > 1f)
			{
				CheckPlayerAndEnvironmentalState();
				UpdateFoodCache();
				ApplyStatusModifiers();
				HandleSurvivalSE?.Invoke();
				AfterRecalculate();
				lastUpdateTime -= 1f;
			}
			if (lastLogTime > ConfigManager.DebugUpdateTime.Value)
			{
				LogStats();
				lastLogTime -= ConfigManager.DebugUpdateTime.Value;
			}
		}

		public virtual void LoadData()
		{
			Main.LogMessage(() => "Loading data for Player Stats");
			PlayerFoodCache.LoadData();
			if ((Object)(object)player == (Object)null)
			{
				Main.LogMessage(() => "No player found. Cannot load data.");
				return;
			}
			if (!player.m_customData.TryGetValue(DataKey, out var data))
			{
				Main.LogMessage(() => "No save data found for the player profile.");
				return;
			}
			if (string.IsNullOrEmpty(data))
			{
				Main.LogMessage(() => "No save data found in entry " + DataKey);
				return;
			}
			Main.LogMessage(() => "Loaded data: " + data);
			try
			{
				string[] array = data.Split(new char[1] { ',' });
				array[0].AssignAsFloat(out player_time_since_eaten_with_good_hp);
				array[1].AssignAsFloat(out player_time_since_final_food_digested);
				player.m_customData.Remove(DataKey);
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Exception e = ex2;
				Main.LogMessage(() => "Could not parse data for " + DataKey + ". Cancelling load.\n" + e.Message);
			}
			finally
			{
			}
		}

		public virtual void SaveData()
		{
			Main.LogMessage(() => "Saving data for Player Stats.");
			if ((Object)(object)player == (Object)null)
			{
				Main.LogMessage(() => "Player not found. Cancelling save.");
				return;
			}
			PlayerFoodCache.SaveData();
			if (player.m_customData.TryGetValue(DataKey, out var _))
			{
				Main.LogMessage(() => "Previous save data found. Replacing...");
				player.m_customData.Remove(DataKey);
			}
			List<string> list = new List<string>
			{
				player_time_since_eaten_with_good_hp.ToString(),
				player_time_since_final_food_digested.ToString()
			};
			string data = string.Join(",", list.ToArray());
			player.m_customData.Add(DataKey, data);
			Main.LogMessage(() => "Saved data: " + data);
		}

		public virtual void UpdateFoodCache()
		{
			RefreshFoodCacheRefereces();
			PlayerFoodCache.RemoveDigestedFoods();
		}

		public virtual void RefreshFoodCacheRefereces()
		{
			if (!((Object)(object)PlayerFoodCache.player != (Object)null) && !((Object)(object)player == (Object)null))
			{
				Main.LogMessage(() => "Player reference not found in food cache. Resetting.");
				player_food_cache = new PlayerFoodCache(player);
				PlayerFoodCache.LoadData();
			}
		}

		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(0)]
		public void SaveAndRemoveStatusEffect<T>(int hash) where T : SE_SurvivalBase
		{
			if (!((Character)player).m_seman.HaveStatusEffect(hash))
			{
				Main.LogMessage(() => $"Player does not have {typeof(T)} for save.");
				return;
			}
			T val = ((Character)player).m_seman.GetStatusEffect(hash) as T;
			if ((Object)(object)val == (Object)null)
			{
				Main.LogMessage(() => $"Cannot find status effect of type {typeof(T)}");
			}
			else
			{
				val.SaveData();
				((StatusEffect)val).m_time = ((StatusEffect)val).m_ttl + 1f;
			}
		}

		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(0)]
		public void FlashStatusEffect<T>(int hash) where T : SE_SurvivalBase
		{
			if (!((Character)player).m_seman.HaveStatusEffect(hash))
			{
				((Character)player).m_seman.AddStatusEffect(hash, false, 0, 0f);
				Main.LogMessage(() => $"Added {typeof(T)} for flash");
			}
			T val = ((Character)player).m_seman.GetStatusEffect(hash) as T;
			if ((Object)(object)val == (Object)null)
			{
				Main.LogMessage(() => $"Cannot find status effect of type {typeof(T)}");
				return;
			}
			val.ClearSaveData();
			val.SetupBaseFields();
			val.Recalculate();
			((StatusEffect)val).m_time = ((StatusEffect)val).m_ttl + 1f;
		}

		public void HandleVitality()
		{
			if (!((Character)player).m_seman.HaveStatusEffect(SE_Vitality.Hash))
			{
				((Character)player).m_seman.AddStatusEffect(SE_Vitality.Hash, false, 0, 0f);
				Main.LogMessage(() => "Vitality status effect initialized");
			}
			vitality = ((Character)player).m_seman.GetStatusEffect(SE_Vitality.Hash) as SE_Vitality;
			if (ShouldRecalculate())
			{
				vitality?.Recalculate();
			}
		}

		public void HandleEnergy()
		{
			if (!((Character)player).m_seman.HaveStatusEffect(SE_Energy.Hash))
			{
				((Character)player).m_seman.AddStatusEffect(SE_Energy.Hash, false, 0, 0f);
				Main.LogMessage(() => "Energy status effect initialized");
			}
			SEMan seman = ((Character)player).m_seman;
			energy = ((seman != null) ? seman.GetStatusEffect(SE_Energy.Hash) : null) as SE_Energy;
			if (ShouldRecalculate())
			{
				energy?.Recalculate();
			}
		}

		public void HandleCapability()
		{
			if (!((Character)player).m_seman.HaveStatusEffect(SE_Capability.Hash))
			{
				((Character)player).m_seman.AddStatusEffect(SE_Capability.Hash, false, 0, 0f);
				Main.LogMessage(() => "Capability status effect initialized");
			}
			SEMan seman = ((Character)player).m_seman;
			capability = ((seman != null) ? seman.GetStatusEffect(SE_Capability.Hash) : null) as SE_Capability;
			if (ShouldRecalculate())
			{
				capability?.Recalculate();
			}
		}

		public void CheckBaseStats()
		{
			player_base_health = player.m_baseHP;
			player_base_stamina = player.m_baseStamina;
			player_base_stamina_regen_delay = player.m_staminaRegenDelay;
		}

		public void CheckPlayerAndEnvironmentalState()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			DamageModifiers damageModifiers = ((Character)player).GetDamageModifiers((WeakSpot)null);
			DamageModifier modifier = ((DamageModifiers)(ref damageModifiers)).GetModifier((DamageType)256);
			DamageModifier modifier2 = ((DamageModifiers)(ref damageModifiers)).GetModifier((DamageType)32);
			DamageModifier modifier3 = ((DamageModifiers)(ref damageModifiers)).GetModifier((DamageType)128);
			DamageModifier modifier4 = ((DamageModifiers)(ref damageModifiers)).GetModifier((DamageType)64);
			PlayerInBiome = GetCurrentBiome();
			PlayerCarryWeightPerc = GetCarryWeightPerc();
			PlayerInExcludedEnvironment = CheckExcludedEnvironment();
			PlayerBodyArmor = ((Character)player).GetBodyArmor();
			PlayerHealthPercentage = ((Character)player).GetHealthPercentage();
			PlayerHealingMead = HasStatusCategory("healthpotion");
			PlayerStaminaMead = HasStatusCategory("staminapotion");
			PlayerEitrMead = HasStatusCategory("eitrpotion");
			PlayerTimeSinceEatenWithGoodHP = TickTimeSinceFoodEaten();
			PlayerTimeSinceFinalFoodDigested = TickTimeSinceFinalFoodDigested();
			PlayerPoisonResistant = GetResistance(modifier) == 1;
			PlayerPoisonVeryResistant = GetResistance(modifier) == 2;
			PlayerFireResistant = GetResistance(modifier2) == 1;
			PlayerFireVeryResistant = GetResistance(modifier2) == 2;
			PlayerLightningResistant = GetResistance(modifier3) == 1;
			PlayerLightningVeryResistant = GetResistance(modifier3) == 2;
			PlayerFrostResistant = GetResistance(modifier4) == 1;
			PlayerFrostVeryResistant = GetResistance(modifier4) == 2;
			PlayerMoving = PlayerIsMoving();
			PlayerSitting = PlayerIsSitting();
			PlayerLayingInBed = PlayerIsLayingInBed();
			PlayerSleeping = PlayerIsSleeping();
			PlayerSheltered = PlayerIsSheltered();
			PlayerHungry = PlayerIsHungry();
			PlayerNoSkillDrain = HasStatusEffect(SEMan.s_statusEffectSoftDeath) && ConfigManager.DeathGrantsImmunity.Value;
			PlayerNearFire = HasStatusEffect(SEMan.s_statusEffectCampFire);
			PlayerResting = HasStatusEffect(SEMan.s_statusEffectResting);
			PlayerRested = HasStatusEffect(SEMan.s_statusEffectRested);
			PlayerCold = HasStatusEffect(SEMan.s_statusEffectCold);
			PlayerFreezing = HasStatusEffect(SEMan.s_statusEffectFreezing);
			PlayerHot = HasStatusEffect(SE_Hot.Hash);
			PlayerScorching = HasStatusEffect(SE_Scorching.Hash);
			PlayerWet = HasStatusEffect(SEMan.s_statusEffectWet);
			PlayerPoisoned = HasStatusEffect(SEMan.s_statusEffectPoison);
			PlayerBurning = HasStatusEffect(SEMan.s_statusEffectBurning);
			PlayerShocked = HasStatusEffect(SEMan.s_statusEffectLightning);
			PlayerFrozen = HasStatusEffect(SEMan.s_statusEffectFrost);
			PlayerBloodProtected = HasStatusEffect(StringExtensionMethods.GetStableHashCode("MagicBarrier"));
			EnvironmentWet = GetEnvironmentState("wet");
			EnvironmentCold = GetEnvironmentState("cold");
			EnvironmentFreezing = GetEnvironmentState("freezing");
			EnvironmentHot = GetEnvironmentState("hot");
			EnvironmentScorching = GetEnvironmentState("scorching");
			EnvironmentWindIntensity = GetEnvironmentWindIntensity();
			EnvironmentSeasonState = GetSeason();
			ResistanceSkillLevel = GetSkillLevel(Main.ResistanceHash);
			ResistanceSkillFactor = GetSkillEffectFactor(Main.ResistanceSkillName);
			FitnessSkillLevel = GetSkillLevel(Main.FitnessHash);
			FitnessSkillFactor = GetSkillEffectFactor(Main.FitnessSkillName);
			PerseverenceSkillLevel = GetSkillLevel(Main.PerseverenceHash);
			PerseverenceSkillFactor = GetSkillEffectFactor(Main.PerseverenceSkillName);
		}

		private void RecalculateStatusEffectModifiers()
		{
			StatsModifiers?.RecalculateAllModifiers();
		}

		private void ApplyStatusModifiers()
		{
			StatsModifiers?.ApplyModifiersToActiveEffects();
		}

		private Biome GetCurrentBiome()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Player obj = player;
			Vector3? obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				GameObject gameObject = ((Component)obj).gameObject;
				if (gameObject == null)
				{
					obj2 = null;
				}
				else
				{
					Transform transform = gameObject.transform;
					obj2 = ((transform != null) ? new Vector3?(transform.position) : null);
				}
			}
			Vector3 val = (Vector3)(((??)obj2) ?? Vector3.zero);
			return (Biome)(((Vector3)(ref val)).Equals(Vector3.zero) ? 895 : ((int)Heightmap.FindBiome(val)));
		}

		private float GetCarryWeightPerc()
		{
			float valueOrDefault = (((Humanoid)(player?)).m_inventory?.m_totalWeight).GetValueOrDefault();
			Player obj = player;
			float num = ((obj != null) ? obj.GetMaxCarryWeight() : 300f);
			return Mathf.Floor(100f * Mathf.Clamp(valueOrDefault / num, 0f, 1f));
		}

		private bool CheckExcludedEnvironment()
		{
			EnvMan instance = EnvMan.instance;
			string item = ((instance == null) ? null : instance.GetCurrentEnvironment()?.m_name) ?? "";
			return ConfigManager.VIgnoredEnvironments.Contains(item);
		}

		private int GetResistance(DamageModifier modifier)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)modifier != 1)
			{
				if ((int)modifier == 5)
				{
					return 2;
				}
				return 0;
			}
			return 1;
		}

		private bool HasStatusEffect(int status)
		{
			Player obj = player;
			bool? obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				SEMan seman = ((Character)obj).m_seman;
				obj2 = ((seman != null) ? new bool?(seman.HaveStatusEffect(status)) : null);
			}
			bool? flag = obj2;
			return flag.GetValueOrDefault();
		}

		private bool HasStatusCategory(string category)
		{
			Player obj = player;
			bool? obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				SEMan seman = ((Character)obj).m_seman;
				obj2 = ((seman != null) ? new bool?(seman.HaveStatusEffectCategory(category)) : null);
			}
			bool? flag = obj2;
			return flag.GetValueOrDefault();
		}

		private bool PlayerIsMoving()
		{
			//IL_002a: 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)
			Player obj = player;
			float? obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				Rigidbody body = ((Character)obj).m_body;
				if (body == null)
				{
					obj2 = null;
				}
				else
				{
					Vector3 velocity = body.velocity;
					obj2 = ((Vector3)(ref velocity)).magnitude;
				}
			}
			float? num = obj2;
			float valueOrDefault = num.GetValueOrDefault();
			return valueOrDefault > 0.01f;
		}

		private bool PlayerIsSitting()
		{
			Player obj = player;
			return obj != null && ((Character)obj).IsSitting();
		}

		private bool PlayerIsLayingInBed()
		{
			Player obj = player;
			return obj != null && ((Character)obj).InBed();
		}

		private bool PlayerIsSleeping()
		{
			Player obj = player;
			return obj != null && obj.IsSleeping();
		}

		private bool PlayerIsSheltered()
		{
			Player obj = player;
			return obj != null && obj.InShelter();
		}

		private bool PlayerIsHungry()
		{
			if (ConfigManager.HungerEnabled.Value)
			{
				return HasStatusEffect(SE_Hungry.Hash);
			}
			int valueOrDefault = (player?.m_foods?.Count).GetValueOrDefault();
			return valueOrDefault == 0;
		}

		private float TickTimeSinceFoodEaten()
		{
			float num = player_time_since_eaten_with_good_hp;
			return num + 1f;
		}

		private float TickTimeSinceFinalFoodDigested()
		{
			int valueOrDefault = (player?.m_foods?.Count).GetValueOrDefault();
			float num = player_time_since_final_food_digested;
			return num + ((valueOrDefault == 0) ? 1f : 0f);
		}

		private bool GetEnvironmentState(string state)
		{
			return state switch
			{
				"scorching" => EnvManHelper.IsScorching(), 
				"hot" => EnvManHelper.IsHot(), 
				"wet" => EnvMan.IsWet(), 
				"cold" => EnvMan.IsCold(), 
				"freezing" => EnvMan.IsFreezing(), 
				_ => false, 
			};
		}

		private float GetEnvironmentWindIntensity()
		{
			EnvMan instance = EnvMan.instance;
			return (instance != null) ? instance.GetWindIntensity() : 0f;
		}

		private EnvManHelper.Season GetSeason()
		{
			return EnvManHelper.GetSeason();
		}

		private float GetSkillLevel(int hash)
		{
			return ((Character)(object)player)?.GetSkillLevel(hash) ?? 0f;
		}

		private float GetSkillEffectFactor(string name)
		{
			return ((Character)(object)player)?.GetSkillFactor(name) ?? 0f;
		}

		private void CalculateResistanceExtraAttackMultiplier()
		{
			Main.LogMessage(() => "Calculating Extra Attack Multiplier from Resistance skill.");
			if (!ConfigManager.VitalityEnabled.Value)
			{
				resistance_extra_attack_multiplier = 1f;
				return;
			}
			float num = CalculateSkillThresholdFactor(ResistanceSkillLevel, ConfigManager.ResistanceSkillMissingHPDamageMultiplierStartLevel.Value);
			resistance_extra_attack_multiplier = 1f + num * (ConfigManager.ResistanceSkillMissingHPDamageMultiplier.Value - 1f);
		}

		private void CalculateResistanceExtraMeadDurationMultiplier()
		{
			Main.LogMessage(() => "Calculating Extra Mead Duration Multiplier from Resistance skill.");
			if (!ConfigManager.VitalityEnabled.Value)
			{
				resistance_extra_mead_duration_multiplier = 1f;
				return;
			}
			float num = CalculateSkillThresholdFactor(ResistanceSkillLevel, ConfigManager.ResistanceSkillElementalMeadMultiplierStartLevel.Value);
			resistance_extra_mead_duration_multiplier = 1f + num * (ConfigManager.ResistanceSkillElementalMeadMultiplier.Value - 1f);
		}

		private void CalculateFitnessFoodBurnMultiplier()
		{
			Main.LogMessage(() => "Calculating Food Burn Multiplier from Fitness skill.");
			if (!ConfigManager.EnergyEnabled.Value)
			{
				fitness_food_burn_multiplier = 1f;
				return;
			}
			float num = CalculateSkillThresholdFactor(FitnessSkillLevel, ConfigManager.FitnessSkillFoodBurnMultiplierStartLevel.Value);
			fitness_food_burn_multiplier = 1f + num * (ConfigManager.FitnessSkillFoodBurnMultiplier.Value - 1f);
		}

		private void CalculateFitnessSpeedPenaltyReduction()
		{
			Main.LogMessage(() => "Calculating Fitness Speed Penalty Reduction from Fitness skill.");
			if (!ConfigManager.EnergyEnabled.Value)
			{
				fitness_speed_penalty_reduction = 0f;
				return;
			}
			float num = CalculateSkillThresholdFactor(FitnessSkillLevel, ConfigManager.FitnessSkillSpeedPenaltyRemoveStartLevel.Value);
			fitness_speed_penalty_reduction = num * (ConfigManager.FitnessSkillSpeedPenaltyRemove.Value / 100f);
		}

		private void CalculatePerseverenceComfortBonus()
		{
			Main.LogMessage(() => "Calculating Comfort Bonus from Perseverence skill.");
			if (!ConfigManager.CapabilityEnabled.Value)
			{
				perseverence_comfort_bonus = 0;
				return;
			}
			float num = CalculateSkillThresholdFactor(PerseverenceSkillLevel, ConfigManager.PerseverenceSkillComfortBonusStartLevel.Value);
			perseverence_comfort_bonus = Mathf.CeilToInt(num * (float)ConfigManager.PerseverenceSkillComfortBonus.Value);
		}

		private void CalculatePerseverenceMaxAdrenalineMultiplier()
		{
			Main.LogMessage(() => "Calculating Max Adrenaline Multiplier from Perseverence skill.");
			if (!ConfigManager.CapabilityEnabled.Value)
			{
				perseverence_max_adrenaline_multiplier = 1f;
				return;
			}
			float num = CalculateSkillThresholdFactor(PerseverenceSkillLevel, ConfigManager.PerseverenceSkillMaxAdrenalineMultiplierStartLevel.Value);
			perseverence_max_adrenaline_multiplier = 1f - num * (1f - ConfigManager.PerseverenceSkillMaxAdrenalineMultiplier.Value);
		}

		public float CalculateSkillThresholdFactor(float level, int threshold)
		{
			return Mathf.Clamp((level - (float)threshold) / (100f - (float)threshold), 0f, 1f);
		}

		public bool ShouldRecalculate()
		{
			return recalculate;
		}

		public void AfterRecalculate()
		{
			recalculate = false;
		}

		public void LogStats()
		{
			Main.LogMessage(() => string.Join("\n", new List<string>
			{
				"PLAYER STATUSES",
				$"Environment Stats for Player {player.GetPlayerID()}",
				"Player State: " + string.Join(", ", PlayerState),
				$"Resistance: {resistance_skill_level} : {resistance_skill_factor}",
				$"Fitness: {fitness_skill_level} : {fitness_skill_factor}",
				$"Perseverence: {perseverence_skill_level} : {perseverence_skill_factor}",
				"Environment State: " + string.Join(", ", EnvironmentState),
				$"Season: {EnvironmentSeasonState}"
			}));
		}
	}
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	public class SE_Scorching : SE_Stats
	{
		public static readonly int Hash = StringExtensionMethods.GetStableHashCode(Main.ScorchingSEName);

		public override void Setup(Character character)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).m_startMessage = "$ea_player_scorching_status";
			((SE_Stats)this).Setup(character);
			((StatusEffect)this).m_name = "$ea_se_scorching";
			((StatusEffect)this).m_icon = Main.GetInstance().Bundle.LoadAsset<Sprite>("scorchingicon");
			base.m_healthRegenMultiplier = 0.2f;
			base.m_staminaRegenMultiplier = 0.5f;
			base.m_eitrRegenMultiplier = 0.5f;
			base.m_speedModifier = -0.2f;
			base.m_mods = new List<DamageModPair>
			{
				new DamageModPair
				{
					m_type = (DamageType)1,
					m_modifier = (DamageModifier)8
				},
				new DamageModPair
				{
					m_type = (DamageType)2,
					m_modifier = (DamageModifier)8
				},
				new DamageModPair
				{
					m_type = (DamageType)4,
					m_modifier = (DamageModifier)8
				}
			};
		}

		public override string GetIconText()
		{
			return "";
		}

		public override string GetTooltipString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("$ea_player_scorching_status \n");
			stringBuilder.Append(((SE_Stats)this).GetTooltipString());
			return stringBuilder.ToString();
		}
	}
	public class SE_Stats_Extended : SE_Stats
	{
		public float m_attackEitrUseModifier;

		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
		public override string GetTooltipString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(((SE_Stats)this).GetTooltipString());
			if (m_attackEitrUseModifier != 0f)
			{
				stringBuilder.AppendFormat("$ea_se_attackeitr: <color=orange>{0}%</color>\n", (m_attackEitrUseModifier * 100f).ToString("+0;-0"));
			}
			return stringBuilder.ToString();
		}

		public virtual void ModifyAttackEitrUsage(float baseEitrUse, ref float eitrUse)
		{
			eitrUse += baseEitrUse * m_attackEitrUseModifier;
		}
	}
	[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
	[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
	public class SE_SurvivalBase : SE_Stats_Extended, ILoadSave
	{
		[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(0)]
		public class StatModifier
		{
			public enum CalculationType
			{
				REGULAR,
				NEGATIVE,
				INVERSE,
				PLUSONESHIFT,
				PERCENTAGE,
				INVERSEPERCENTAGE,
				ONEZERO
			}

			[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(1)]
			public SE_SurvivalBase m_statusEffect;

			[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
			public WarningMessage m_warning;

			public CalculationType m_calculationType;

			public bool m_enabled = true;

			public float m_defaultValue = 0f;

			public float m_threshold = 0f;

			public float m_maxMultiplier = 1f;

			[<b5852da6-aaeb-459b-ab30-d4f403af32ff>NullableContext(1)]
			public StatModifier(SE_SurvivalBase m_statusEffect, [<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)] WarningMessage m_warning, CalculationType m_calculationType)
			{
				this.m_statusEffect = m_statusEffect;
				this.m_warning = m_warning;
				this.m_calculationType = m_calculationType;
			}

			public float CalculateMultiplier()
			{
				return CalculateMultiplier(m_statusEffect.m_statLossPerc);
			}

			public float CalculateMultiplier(float externalValue)
			{
				float defaultValue = m_defaultValue;
				if (!m_enabled)
				{
					return defaultValue;
				}
				if (externalValue < m_threshold)
				{
					m_statusEffect.SetWarningDisplay(m_warning);
					return defaultValue;
				}
				m_statusEffect.SendWarningMessage(m_warning);
				float num = m_statusEffect.CalculateThresholdMultiplierForStat(m_threshold);
				return m_calculationType switch
				{
					CalculationType.REGULAR => num * m_maxMultiplier, 
					CalculationType.INVERSE => 1f - num * m_maxMultiplier, 
					CalculationType.NEGATIVE => -1f * num * m_maxMultiplier, 
					CalculationType.PLUSONESHIFT => 1f + num * (m_maxMultiplier - 1f), 
					CalculationType.PERCENTAGE => Mathf.Clamp(num * m_maxMultiplier, 0f, 100f), 
					CalculationType.INVERSEPERCENTAGE => Mathf.Clamp(100f - num * (100f - m_maxMultiplier), 0f, 100f), 
					CalculationType.ONEZERO => Mathf.CeilToInt(num), 
					_ => m_maxMultiplier, 
				};
			}
		}

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(0)]
		public class WarningMessage
		{
			public bool m_display = false;

			public string m_message = "";

			public float m_lastMessageTime = 0f;

			public WarningMessage(string m_message)
			{
				this.m_message = m_message;
			}
		}

		public float m_statLoss = 0f;

		public float m_maxStatLoss = 100f;

		public float m_baseMaxStatLoss = 100f;

		public float m_statLossPerc = 0f;

		public float m_statChange = 0f;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(new byte[] { 2, 1 })]
		protected Sprite[] m_icons;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		protected Sprite m_iconNoSkillDrain;

		[<9d033fe9-c380-47d1-b735-cfa82d3b8a67>Nullable(2)]
		protected Sprite m_iconNewSpawn;