using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Destructible;
using EntityStates.FalseSon;
using EntityStates.FalseSonBoss;
using EntityStates.Geode;
using EntityStates.GolemMonster;
using EntityStates.Interactables.GoldBeacon;
using EntityStates.LightningStorm;
using EntityStates.MeridianEvent;
using EntityStates.Missions.Goldshores;
using EntityStates.Missions.MiniGeodeTracker;
using EntityStates.PrimeMeridian;
using EntityStates.ShrineRebirth;
using EntityStates.TitanMonster;
using HG;
using HarmonyLib;
using IL.EntityStates.FalseSonBoss;
using IL.EntityStates.Geode;
using IL.RoR2;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On;
using On.EntityStates.Destructible;
using On.EntityStates.FalseSonBoss;
using On.EntityStates.Geode;
using On.EntityStates.Interactables.GoldBeacon;
using On.EntityStates.LightningStorm;
using On.EntityStates.MeridianEvent;
using On.EntityStates.Missions.Goldshores;
using On.EntityStates.PrimeMeridian;
using On.EntityStates.ShrineRebirth;
using On.EntityStates.TitanMonster;
using On.RoR2;
using On.RoR2.Projectile;
using R2API;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Achievements.Artifacts;
using RoR2.AsyncManagement;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.EntitlementManagement;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.PostProcessing;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.Stats;
using RoR2.UI;
using RoR2.UI.MainMenu;
using RoR2BepInExPack.GameAssetPathsBetter;
using StormboundFalseSon.Changes;
using StormboundFalseSon.Modules;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyCompany("StormboundFalseSon")]
[assembly: AssemblyProduct("StormboundFalseSon")]
[assembly: AssemblyTitle("StormboundFalseSon")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StormboundFalseSon
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.Bloonjitsu7.StormboundFalseSon", "StormboundFalseSon", "1.0.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class StormboundFalseSonPlugin : BaseUnityPlugin
	{
		private Main changes;

		public static PluginInfo PInfo { get; private set; }

		public void Awake()
		{
			PInfo = ((BaseUnityPlugin)this).Info;
			Log.Init(((BaseUnityPlugin)this).Logger);
			Configs.SetupConfig(((BaseUnityPlugin)this).Config);
			Configs.UpdateConfigValues();
			new ContentPacks().Initialize();
			changes = new Main();
			changes.Initialize();
		}
	}
	public static class Configs
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static IsDisabledDelegate <0>__CheckDisabled;
		}

		public static float scalingMult;

		public static bool bonusItemEnable;

		public static bool adaptiveArmorEnable;

		public static bool damageCapEnable;

		public static bool freezeImmunityEnable;

		public static float freezeDamage;

		public static bool lunarRuinEnable;

		public static float lunarRuinCap;

		public static float eclipseCooldownMult;

		public static float fsBaseHP1;

		public static float fsLevelHP1;

		public static float fsBaseHP2;

		public static float fsLevelHP2;

		public static float fsBaseHP3;

		public static float fsLevelHP3;

		public static float fsBaseArmor;

		public static float fsLevelArmor;

		public static float lightningRadiusMult;

		public static float baseLightningDelay;

		public static float lightningDamage;

		public static bool lightningDelayScaling;

		public static bool lightningDamageScaling;

		public static bool lightningWarningFX;

		public static bool lightningShakeDisable;

		public static bool pulseEnable;

		public static float pulseDetection;

		public static float pulseTimer;

		public static float pulseDelay;

		public static float pulseCooldown;

		public static float pulseDamage;

		public static float pulseForce;

		public static float pulseRadius;

		public static bool geodeEnable;

		public static bool geodeBuffs;

		public static float geodeSpeedMult;

		public static float geodeSpeedDuration;

		public static float geodeRegenAmount;

		public static float geodeRegenDuration;

		public static bool halcLaser;

		public static int halcHP;

		public static int halcDamage;

		public static bool slamEnable;

		public static float slamCooldown;

		public static bool slamEclipse;

		public static int slamStocks;

		public static float slamWindup1;

		public static float slamWindup2;

		public static float slamDelayMult;

		public static float slamAbilityDelay;

		public static float slamAimSpeed;

		public static int slamFissures;

		public static bool dashEnable;

		public static float dashCooldown;

		public static bool dashEclipse;

		public static float dashWindup;

		public static float dashLightningDelay;

		public static bool dashArmor;

		public static float dashSlamDelay;

		public static bool offeringEnable;

		public static float offeringCooldown;

		public static bool offeringEclipse;

		public static bool offeringStakeEnable;

		public static bool offeringProjectiles;

		public static float offeringSpikeSpeed;

		public static float offeringStakeSpeed;

		public static float offeringAimSpeed;

		public static bool rainEnable;

		public static float rainCooldown;

		public static bool rainEclipse;

		public static float rainWindup;

		public static int crystalCount;

		public static float crystalDuration;

		public static bool crystalAutoDetonate;

		public static float crystalTimer;

		public static float crystalDamage;

		public static bool crystalFalloff;

		public static int crystalFissures;

		public static float crystalOverchargeRadius;

		public static float crystalOverchargeDamage;

		public static bool crystalOverchargeLight;

		public static float laserCooldown;

		public static bool laserEclipse;

		public static bool leapEnable;

		public static float leapDelay;

		public static float leapFrequency;

		public static float leapDuration;

		public static int leapMin;

		public static int leapMax;

		public static float leapPlusMult;

		public static bool laserEnable;

		public static float laserDuration;

		public static float laserDamage;

		public static float laserTickRate;

		public static float laserDecayRate;

		public static bool laserLightEnable;

		public static float laserLightIntensity;

		public static float laserLightAutoDisable;

		public static float devastatorCooldown;

		public static bool devastatorEclipse;

		public static bool devastatorOrbEnable;

		public static float devastatorOrbSpeed;

		public static float devastatorOrbDuration;

		public static float devastatorOrbDamage;

		public static int devastatorOrbCount;

		public static bool devastatorDebuffEnable;

		public static float devastatorDebuffInterval;

		public static float devastatorDebuffFSMult;

		public static float devastatorDebuffHalcMult;

		public static bool devastatorDebuffVFX;

		public static bool artifactEnable;

		public static bool forceHardMode;

		public static bool forceEclipse;

		public static bool thunderBonusItems;

		public static int thunderHPBoost;

		public static bool thunderSlowImmunity;

		public static float thunderLightningDelayMult;

		public static bool thunderPassiveLightning1;

		public static bool thunderPassiveLightning2;

		public static bool thunderPassiveLightning3;

		public static bool thunderLightningLine2;

		public static bool thunderLightningLine3;

		public static float thunderLightningLineDelayMult;

		public static float thunderLightningLineInterval;

		public static int thunderPulseFissures;

		public static float thunderGeodeBarrier;

		public static float thunderGeodeHeal;

		public static bool thunderGeodeElite;

		public static bool thunderGeodeArmor;

		public static int thunderGeodeHP;

		public static bool thunderGeodeGolems;

		public static int thunderGeodeGolemHP;

		public static bool thunderSlamPatterns;

		public static int thunderSlamScatters;

		public static float thunderSlamScatterDelay;

		public static int thunderSlamFissures;

		public static float thunderSlamWindupMult;

		public static bool thunderDashParry;

		public static float thunderDashParryDuration;

		public static bool thunderDashParryAll;

		public static float thunderDashWindup;

		public static bool thunderDashEnable;

		public static float thunderDashCooldown;

		public static float thunderOfferingSpeedMult;

		public static bool thunderOfferingProjectiles;

		public static bool thunderOfferingStakes;

		public static int thunderCrystalCount;

		public static int thunderCrystalShards;

		public static int thunderCrystalFissures;

		public static float thunderLaserDuration;

		public static bool thunderLeapLightningPatterns;

		public static float thunderLeapLightningMult;

		public static float thunderLeapDurationMult;

		public static bool thunderShockwaveEnable;

		public static float thunderShockwaveDelay;

		public static float thunderShockwaveInterval;

		public static int thunderShockwaveCount;

		public static float thunderShockwaveDamage;

		public static bool thunderDevastatorOrbs;

		public static bool eyeEnable;

		public static bool eyeSharing;

		public static float eyeDamage;

		public static int eyeLightningCount;

		public static float eyeLightningDamage;

		public static float eyeLightningDelay;

		public static float eyeLightningInterval;

		public static float eyeLightningRadius;

		public static float eyeLightningRange;

		public static bool auriEnable;

		public static float auriRegen;

		public static bool auriAdaptiveArmor;

		public static bool auriFixedSpawn;

		public static bool auriReducedStats;

		public static float auriDamageMultFS;

		public static float auriSpeedMultFS;

		public static float auriBaseHP;

		public static float auriLevelHP;

		public static float auriBaseArmor;

		public static float auriLevelArmor;

		public static bool auriSwordEnable;

		public static float auriSwordDelay;

		public static float auriSwordInterval;

		public static bool auriCrownEnable;

		public static int auriCrownLasers;

		public static int auriCrownLasersFS;

		public static float auriCrownSpinSpeed;

		public static float auriCrownDuration;

		public static float auriCrownDamage;

		public static float auriCrownDamageDelay;

		public static bool auriCrownBypassArmor;

		public static bool auriBeamEnable;

		public static float auriBeamFrequency;

		public static float auriBeamProjectileDamage;

		public static float auriBeamProjectileSpeed;

		public static float auriBeamProjectileSpread;

		public static float auriBeamProjectileAccuracy;

		public static float auriBeamDuration;

		public static float auriBeamDamage;

		public static float auriBeamRadius;

		public static float auriBeamForce;

		public static bool auriBeamIgnite;

		public static bool coastEnable;

		public static float coastSpawnTimer;

		public static float coastSpawnReduction;

		public static float coastBaseArmor;

		public static float coastBeaconArmor;

		public static int coastBeaconTimer;

		public static int coastBeaconExtension;

		public static float coastGoldMult;

		public static bool coastBonusChest;

		public static string halcyonStages;

		public static float halcyonChanceMult;

		public static bool halcyonStage5;

		public static bool meridianReduceLightning;

		public static float meridianSpawnMult;

		public static float meridianMoneyMult;

		public static bool meridianGeodeSpawns;

		public static float meridianGeodeCredits;

		public static float meridianGeodeScaling;

		public static bool voidGeodes;

		public static int voidGeodeCount;

		public static float voidLightIntensity;

		public static float voidLightRange;

		public static ConfigEntry<bool> knightEnable { get; set; }

		public static ConfigEntry<bool> enableConfigs { get; set; }

		public static ConfigEntry<bool> killGearboxLightning { get; set; }

		public static ConfigEntry<float> CFGscalingMult { get; set; }

		public static ConfigEntry<bool> CFGbonusItemEnable { get; set; }

		public static ConfigEntry<bool> CFGadaptiveArmorEnable { get; set; }

		public static ConfigEntry<bool> CFGdamageCapEnable { get; set; }

		public static ConfigEntry<bool> CFGfreezeImmunityEnable { get; set; }

		public static ConfigEntry<float> CFGfreezeDamage { get; set; }

		public static ConfigEntry<bool> CFGlunarRuinEnable { get; set; }

		public static ConfigEntry<float> CFGlunarRuinCap { get; set; }

		public static ConfigEntry<float> CFGeclipseMult { get; set; }

		public static ConfigEntry<float> CFGfsBaseHP1 { get; set; }

		public static ConfigEntry<float> CFGfsLevelHP1 { get; set; }

		public static ConfigEntry<float> CFGfsBaseHP2 { get; set; }

		public static ConfigEntry<float> CFGfsLevelHP2 { get; set; }

		public static ConfigEntry<float> CFGfsBaseHP3 { get; set; }

		public static ConfigEntry<float> CFGfsLevelHP3 { get; set; }

		public static ConfigEntry<float> CFGfsBaseArmor { get; set; }

		public static ConfigEntry<float> CFGfsLevelArmor { get; set; }

		public static ConfigEntry<float> CFGlightningRadiusMult { get; set; }

		public static ConfigEntry<float> CFGbaseLightningDelay { get; set; }

		public static ConfigEntry<float> CFGlightningDamage { get; set; }

		public static ConfigEntry<bool> CFGlightningDelayScaling { get; set; }

		public static ConfigEntry<bool> CFGlightningDamageScaling { get; set; }

		public static ConfigEntry<bool> CFGlightningWarningFX { get; set; }

		public static ConfigEntry<bool> CFGlightningShakeDisable { get; set; }

		public static ConfigEntry<bool> CFGpulseEnable { get; set; }

		public static ConfigEntry<float> CFGpulseDetection { get; set; }

		public static ConfigEntry<float> CFGpulseTimer { get; set; }

		public static ConfigEntry<float> CFGpulseDelay { get; set; }

		public static ConfigEntry<float> CFGpulseCooldown { get; set; }

		public static ConfigEntry<float> CFGpulseDamage { get; set; }

		public static ConfigEntry<float> CFGpulseForce { get; set; }

		public static ConfigEntry<float> CFGpulseRadius { get; set; }

		public static ConfigEntry<bool> CFGgeodeEnable { get; set; }

		public static ConfigEntry<bool> CFGgeodeBuffs { get; set; }

		public static ConfigEntry<float> CFGgeodeSpeedMult { get; set; }

		public static ConfigEntry<float> CFGgeodeSpeedDuration { get; set; }

		public static ConfigEntry<float> CFGgeodeRegenAmount { get; set; }

		public static ConfigEntry<float> CFGgeodeRegenDuration { get; set; }

		public static ConfigEntry<bool> CFGhalcLaser { get; set; }

		public static ConfigEntry<int> CFGhalcHP { get; set; }

		public static ConfigEntry<int> CFGhalcDamage { get; set; }

		public static ConfigEntry<bool> CFGslamEnable { get; set; }

		public static ConfigEntry<float> CFGslamCooldown { get; set; }

		public static ConfigEntry<bool> CFGslamEclipse { get; set; }

		public static ConfigEntry<int> CFGslamStocks { get; set; }

		public static ConfigEntry<float> CFGslamWindup1 { get; set; }

		public static ConfigEntry<float> CFGslamWindup2 { get; set; }

		public static ConfigEntry<float> CFGslamDelayMult { get; set; }

		public static ConfigEntry<float> CFGslamAbilityDelay { get; set; }

		public static ConfigEntry<float> CFGslamAimSpeed { get; set; }

		public static ConfigEntry<int> CFGslamFissures { get; set; }

		public static ConfigEntry<bool> CFGdashEnable { get; set; }

		public static ConfigEntry<float> CFGdashCooldown { get; set; }

		public static ConfigEntry<bool> CFGdashEclipse { get; set; }

		public static ConfigEntry<float> CFGdashWindup { get; set; }

		public static ConfigEntry<float> CFGdashLightningDelay { get; set; }

		public static ConfigEntry<bool> CFGdashArmor { get; set; }

		public static ConfigEntry<float> CFGdashSlamDelay { get; set; }

		public static ConfigEntry<bool> CFGofferingEnable { get; set; }

		public static ConfigEntry<float> CFGofferingCooldown { get; set; }

		public static ConfigEntry<bool> CFGofferingEclipse { get; set; }

		public static ConfigEntry<bool> CFGofferingStakeEnable { get; set; }

		public static ConfigEntry<bool> CFGofferingProjectiles { get; set; }

		public static ConfigEntry<float> CFGofferingSpikeSpeed { get; set; }

		public static ConfigEntry<float> CFGofferingStakeSpeed { get; set; }

		public static ConfigEntry<float> CFGofferingAimSpeed { get; set; }

		public static ConfigEntry<bool> CFGrainEnable { get; set; }

		public static ConfigEntry<float> CFGrainCooldown { get; set; }

		public static ConfigEntry<bool> CFGrainEclipse { get; set; }

		public static ConfigEntry<float> CFGrainWindup { get; set; }

		public static ConfigEntry<int> CFGcrystalCount { get; set; }

		public static ConfigEntry<float> CFGcrystalDuration { get; set; }

		public static ConfigEntry<bool> CFGcrystalAutoDetonate { get; set; }

		public static ConfigEntry<float> CFGcrystalTimer { get; set; }

		public static ConfigEntry<float> CFGcrystalDamage { get; set; }

		public static ConfigEntry<bool> CFGcrystalFalloff { get; set; }

		public static ConfigEntry<int> CFGcrystalFissures { get; set; }

		public static ConfigEntry<float> CFGcrystalOverchargeRadius { get; set; }

		public static ConfigEntry<float> CFGcrystalOverchargeDamage { get; set; }

		public static ConfigEntry<bool> CFGcrystalOverchargeLight { get; set; }

		public static ConfigEntry<float> CFGlaserCooldown { get; set; }

		public static ConfigEntry<bool> CFGlaserEclipse { get; set; }

		public static ConfigEntry<bool> CFGleapEnable { get; set; }

		public static ConfigEntry<float> CFGleapDelay { get; set; }

		public static ConfigEntry<float> CFGleapFrequency { get; set; }

		public static ConfigEntry<float> CFGleapDuration { get; set; }

		public static ConfigEntry<int> CFGleapMin { get; set; }

		public static ConfigEntry<int> CFGleapMax { get; set; }

		public static ConfigEntry<float> CFGleapPlusMult { get; set; }

		public static ConfigEntry<bool> CFGlaserEnable { get; set; }

		public static ConfigEntry<float> CFGlaserDuration { get; set; }

		public static ConfigEntry<float> CFGlaserDamage { get; set; }

		public static ConfigEntry<float> CFGlaserTickRate { get; set; }

		public static ConfigEntry<float> CFGlaserDecayRate { get; set; }

		public static ConfigEntry<bool> CFGlaserLightEnable { get; set; }

		public static ConfigEntry<float> CFGlaserLightIntensity { get; set; }

		public static ConfigEntry<float> CFGlaserLightAutoDisable { get; set; }

		public static ConfigEntry<float> CFGdevastatorCooldown { get; set; }

		public static ConfigEntry<bool> CFGdevastatorEclipse { get; set; }

		public static ConfigEntry<bool> CFGdevastatorOrbEnable { get; set; }

		public static ConfigEntry<float> CFGdevastatorOrbSpeed { get; set; }

		public static ConfigEntry<float> CFGdevastatorOrbDuration { get; set; }

		public static ConfigEntry<float> CFGdevastatorOrbDamage { get; set; }

		public static ConfigEntry<int> CFGdevastatorOrbCount { get; set; }

		public static ConfigEntry<bool> CFGdevastatorDebuffEnable { get; set; }

		public static ConfigEntry<float> CFGdevastatorDebuffInterval { get; set; }

		public static ConfigEntry<float> CFGdevastatorDebuffFSMult { get; set; }

		public static ConfigEntry<float> CFGdevastatorDebuffHalcMult { get; set; }

		public static ConfigEntry<bool> CFGdevastatorDebuffVFX { get; set; }

		public static ConfigEntry<bool> CFGartifactEnable { get; set; }

		public static ConfigEntry<bool> CFGforceHardMode { get; set; }

		public static ConfigEntry<bool> CFGforceEclipse { get; set; }

		public static ConfigEntry<bool> CFGthunderBonusItems { get; set; }

		public static ConfigEntry<int> CFGthunderHPBoost { get; set; }

		public static ConfigEntry<int> CFGthunderSlowImmunity { get; set; }

		public static ConfigEntry<float> CFGthunderLightningDelayMult { get; set; }

		public static ConfigEntry<bool> CFGthunderPassiveLightning1 { get; set; }

		public static ConfigEntry<bool> CFGthunderPassiveLightning2 { get; set; }

		public static ConfigEntry<bool> CFGthunderPassiveLightning3 { get; set; }

		public static ConfigEntry<bool> CFGthunderLightningLine2 { get; set; }

		public static ConfigEntry<bool> CFGthunderLightningLine3 { get; set; }

		public static ConfigEntry<float> CFGthunderLightningLineDelayMult { get; set; }

		public static ConfigEntry<float> CFGthunderLightningLineInterval { get; set; }

		public static ConfigEntry<int> CFGthunderPulseFissures { get; set; }

		public static ConfigEntry<float> CFGthunderGeodeBarrier { get; set; }

		public static ConfigEntry<float> CFGthunderGeodeHeal { get; set; }

		public static ConfigEntry<bool> CFGthunderGeodeElite { get; set; }

		public static ConfigEntry<bool> CFGthunderGeodeArmor { get; set; }

		public static ConfigEntry<int> CFGthunderGeodeHP { get; set; }

		public static ConfigEntry<bool> CFGthunderGeodeGolems { get; set; }

		public static ConfigEntry<int> CFGthunderGeodeGolemHP { get; set; }

		public static ConfigEntry<bool> CFGthunderSlamPatterns { get; set; }

		public static ConfigEntry<int> CFGthunderSlamScatters { get; set; }

		public static ConfigEntry<float> CFGthunderSlamScatterDelay { get; set; }

		public static ConfigEntry<int> CFGthunderSlamFissures { get; set; }

		public static ConfigEntry<float> CFGthunderSlamWindupMult { get; set; }

		public static ConfigEntry<bool> CFGthunderDashParry { get; set; }

		public static ConfigEntry<float> CFGthunderDashParryDuration { get; set; }

		public static ConfigEntry<bool> CFGthunderDashParryAll { get; set; }

		public static ConfigEntry<float> CFGthunderDashWindup { get; set; }

		public static ConfigEntry<bool> CFGthunderDashEnable { get; set; }

		public static ConfigEntry<float> CFGthunderDashCooldown { get; set; }

		public static ConfigEntry<float> CFGthunderOfferingSpeedMult { get; set; }

		public static ConfigEntry<bool> CFGthunderOfferingProjectiles { get; set; }

		public static ConfigEntry<bool> CFGthunderOfferingStakes { get; set; }

		public static ConfigEntry<int> CFGthunderCrystalCount { get; set; }

		public static ConfigEntry<int> CFGthunderCrystalShards { get; set; }

		public static ConfigEntry<int> CFGthunderCrystalFissures { get; set; }

		public static ConfigEntry<float> CFGthunderLaserDuration { get; set; }

		public static ConfigEntry<bool> CFGthunderLeapLightningPatterns { get; set; }

		public static ConfigEntry<float> CFGthunderLeapLightningMult { get; set; }

		public static ConfigEntry<float> CFGthunderLeapDurationMult { get; set; }

		public static ConfigEntry<float> CFGthunderLaserCooldownMult { get; set; }

		public static ConfigEntry<bool> CFGthunderShockwaveEnable { get; set; }

		public static ConfigEntry<float> CFGthunderShockwaveDelay { get; set; }

		public static ConfigEntry<float> CFGthunderShockwaveInterval { get; set; }

		public static ConfigEntry<int> CFGthunderShockwaveCount { get; set; }

		public static ConfigEntry<float> CFGthunderShockwaveDamage { get; set; }

		public static ConfigEntry<bool> CFGthunderDevastatorOrbs { get; set; }

		public static ConfigEntry<bool> CFGeyeEnable { get; set; }

		public static ConfigEntry<bool> CFGeyeSharing { get; set; }

		public static ConfigEntry<float> CFGeyeDamage { get; set; }

		public static ConfigEntry<int> CFGeyeLightningCount { get; set; }

		public static ConfigEntry<float> CFGeyeLightningDamage { get; set; }

		public static ConfigEntry<float> CFGeyeLightningDelay { get; set; }

		public static ConfigEntry<float> CFGeyeLightningInterval { get; set; }

		public static ConfigEntry<float> CFGeyeLightningRadius { get; set; }

		public static ConfigEntry<float> CFGeyeLightningRange { get; set; }

		public static ConfigEntry<bool> CFGauriEnable { get; set; }

		public static ConfigEntry<float> CFGauriRegen { get; set; }

		public static ConfigEntry<bool> CFGauriAdaptiveArmor { get; set; }

		public static ConfigEntry<bool> CFGauriFixedSpawn { get; set; }

		public static ConfigEntry<bool> CFGauriReducedStats { get; set; }

		public static ConfigEntry<float> CFGauriDamageMultFS { get; set; }

		public static ConfigEntry<float> CFGauriSpeedMultFS { get; set; }

		public static ConfigEntry<float> CFGauriBaseHP { get; set; }

		public static ConfigEntry<float> CFGauriLevelHP { get; set; }

		public static ConfigEntry<float> CFGauriBaseArmor { get; set; }

		public static ConfigEntry<float> CFGauriLevelArmor { get; set; }

		public static ConfigEntry<bool> CFGauriSwordEnable { get; set; }

		public static ConfigEntry<float> CFGauriSwordDelay { get; set; }

		public static ConfigEntry<float> CFGauriSwordInterval { get; set; }

		public static ConfigEntry<bool> CFGauriCrownEnable { get; set; }

		public static ConfigEntry<int> CFGauriCrownLasers { get; set; }

		public static ConfigEntry<int> CFGauriCrownLasersFS { get; set; }

		public static ConfigEntry<float> CFGauriCrownSpinSpeed { get; set; }

		public static ConfigEntry<float> CFGauriCrownDuration { get; set; }

		public static ConfigEntry<float> CFGauriCrownDamage { get; set; }

		public static ConfigEntry<float> CFGauriCrownDamageDelay { get; set; }

		public static ConfigEntry<bool> CFGauriCrownBypassArmor { get; set; }

		public static ConfigEntry<bool> CFGauriBeamEnable { get; set; }

		public static ConfigEntry<float> CFGauriBeamFrequency { get; set; }

		public static ConfigEntry<float> CFGauriBeamProjectileDamage { get; set; }

		public static ConfigEntry<float> CFGauriBeamProjectileSpeed { get; set; }

		public static ConfigEntry<float> CFGauriBeamProjectileSpread { get; set; }

		public static ConfigEntry<float> CFGauriBeamProjectileAccuracy { get; set; }

		public static ConfigEntry<float> CFGauriBeamDuration { get; set; }

		public static ConfigEntry<float> CFGauriBeamDamage { get; set; }

		public static ConfigEntry<float> CFGauriBeamRadius { get; set; }

		public static ConfigEntry<float> CFGauriBeamForce { get; set; }

		public static ConfigEntry<bool> CFGauriBeamIgnite { get; set; }

		public static ConfigEntry<bool> CFGcoastEnable { get; set; }

		public static ConfigEntry<float> CFGcoastSpawnTimer { get; set; }

		public static ConfigEntry<float> CFGcoastSpawnReduction { get; set; }

		public static ConfigEntry<float> CFGcoastBaseArmor { get; set; }

		public static ConfigEntry<float> CFGcoastBeaconArmor { get; set; }

		public static ConfigEntry<int> CFGcoastBeaconTimer { get; set; }

		public static ConfigEntry<int> CFGcoastBeaconExtension { get; set; }

		public static ConfigEntry<float> CFGcoastGoldMult { get; set; }

		public static ConfigEntry<bool> CFGcoastBonusChest { get; set; }

		public static ConfigEntry<string> CFGhalcyonStages { get; set; }

		public static ConfigEntry<float> CFGhalcyonChanceMult { get; set; }

		public static ConfigEntry<bool> CFGhalcyonStage5 { get; set; }

		public static ConfigEntry<bool> CFGmeridianReduceLightning { get; set; }

		public static ConfigEntry<float> CFGmeridianSpawnMult { get; set; }

		public static ConfigEntry<float> CFGmeridianMoneyMult { get; set; }

		public static ConfigEntry<bool> CFGmeridianGeodeSpawns { get; set; }

		public static ConfigEntry<float> CFGmeridianGeodeCredits { get; set; }

		public static ConfigEntry<float> CFGmeridianGeodeScaling { get; set; }

		public static ConfigEntry<bool> CFGvoidGeodes { get; set; }

		public static ConfigEntry<int> CFGvoidGeodeCount { get; set; }

		public static ConfigEntry<float> CFGvoidLightIntensity { get; set; }

		public static ConfigEntry<float> CFGvoidLightRange { get; set; }

		public static void SetupConfig(ConfigFile cfg)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			UpdateConfigValues(SetValues: true);
			enableConfigs = cfg.Bind<bool>("!!!IMPORTANT!!!", "Enable Configuration", false, "This mod is balanced around the default config values, and changing them could potentially lead to a less enjoyable experience. Enable at your own risk.");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(enableConfigs, new CheckBoxConfig()));
			enableConfigs.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			killGearboxLightning = cfg.Bind<bool>("!!!IMPORTANT!!!", "Kill The Gearbox Lightning VFX", true, "Removes the new lightning warning VFX that was added in Hallowed Concepts.");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(killGearboxLightning, new CheckBoxConfig
			{
				restartRequired = true
			}));
			killGearboxLightning.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			CFGlaserLightAutoDisable = cfg.Bind<float>("!!!IMPORTANT!!!", "Laser Light FPS Threshold", 10f, "Automatically disables the Lunar Gaze Light VFX if your FPS dips below this value while it's active.");
			ModSettingsManager.AddOption((BaseOption)new SliderOption(CFGlaserLightAutoDisable, new SliderConfig
			{
				min = 0f,
				max = 60f,
				FormatString = "{0}FPS"
			}));
			CFGlaserLightAutoDisable.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			CFGscalingMult = RegisterConfigFloat(cfg, "False Son", "Scaling Multiplier", scalingMult, "Lightning damage and strike speed are multiplied by this amount, based on how far into the run you are. Only has any effect past stage 5. Scaling level is set to 1/2/3 when False Son is fought past stages 5/8/10 during a run (basically the 2nd, 3rd, and 4th opportunities at which he could be fought).", 1f, 2f);
			CFGbonusItemEnable = RegisterConfigBool(cfg, "False Son", "Bonus Rewards", bonusItemEnable, "Increases the number of items you can take from the False Son reward geode by 1.");
			CFGadaptiveArmorEnable = RegisterConfigBool(cfg, "False Son", "Improved Adaptive Armor", adaptiveArmorEnable, "Increases the adaptive armor that False Son has.");
			CFGdamageCapEnable = RegisterConfigBool(cfg, "False Son", "Soft Damage Cap", damageCapEnable, "Adds a soft damage cap to False Son, making it so that any instance of damage that deals more than 15% of his Max HP in a single hit has the excess damage halved.");
			CFGfreezeImmunityEnable = RegisterConfigBool(cfg, "False Son", "Freeze Immunity", freezeImmunityEnable, "Grants False Son an immunity to being frozen.");
			CFGlunarRuinEnable = RegisterConfigBool(cfg, "False Son", "Enable Lunar Ruin Changes", defaultValue: true, "Enables the changes to the Lunar Ruin debuff. Also affects the False Son survivor.");
			CFGlunarRuinCap = RegisterConfigFloat(cfg, "False Son", "Lunar Ruin Damage Cap", lunarRuinCap, "The max bonus damage multiplier achievable with Lunar Ruin (1 = 100% bonus damage).", 0.5f, 5f);
			CFGeclipseMult = RegisterConfigFloat(cfg, "False Son", "Eclipse 7 Multiplier Override", eclipseCooldownMult, "Overrides the original Eclipse 7 cooldown multiplier with this one for False Son's skills. Each individual skill can be opted out of this change.", 0.25f, 1f);
			CFGfsBaseHP1 = RegisterConfigFloat(cfg, "False Son", "Phase 1 Base Health", fsBaseHP1, "False Son's base max health during phase 1.", 100f, 5000f, percent: false, restart: true);
			CFGfsBaseHP2 = RegisterConfigFloat(cfg, "False Son", "Phase 2 Base Health", fsBaseHP2, "False Son's base max health during phase 2.", 100f, 5000f, percent: false, restart: true);
			CFGfsBaseHP3 = RegisterConfigFloat(cfg, "False Son", "Phase 3 Base Health", fsBaseHP3, "False Son's base max health during phase 3.", 100f, 5000f, percent: false, restart: true);
			CFGfsLevelHP1 = RegisterConfigFloat(cfg, "False Son", "Phase 1 Level Health", fsLevelHP1, "False Son's max health per level during phase 1.", 50f, 1500f, percent: false, restart: true);
			CFGfsLevelHP2 = RegisterConfigFloat(cfg, "False Son", "Phase 2 Level Health", fsLevelHP2, "False Son's max health per level during phase 2.", 50f, 1500f, percent: false, restart: true);
			CFGfsLevelHP3 = RegisterConfigFloat(cfg, "False Son", "Phase 3 Level Health", fsLevelHP3, "False Son's max health per level during phase 3.", 50f, 1500f, percent: false, restart: true);
			CFGfsBaseArmor = RegisterConfigFloat(cfg, "False Son", "Base Armor", fsBaseArmor, "False Son's base armor.", 0f, 150f, percent: false, restart: true);
			CFGfsLevelArmor = RegisterConfigFloat(cfg, "False Son", "Level Armor", fsLevelArmor, "False Son's armor per level.", 0f, 50f, percent: false, restart: true);
			CFGlightningRadiusMult = RegisterConfigFloat(cfg, "False Son - Lightning Changes", "Lightning Radius Multiplier", lightningRadiusMult, "Size multiplier for the lightning strikes.", 0.5f, 2f);
			CFGbaseLightningDelay = RegisterConfigFloat(cfg, "False Son - Lightning Changes", "Base Lightning Delay", baseLightningDelay, "Base amount of time (before multipliers) that it takes for lightning to strike.", 0.5f, 3f);
			CFGlightningDamage = RegisterConfigFloat(cfg, "False Son - Lightning Changes", "Lightning Damage", lightningDamage, "Amount of Max HP damage that each lightning strike deals.", 0.05f, 1f);
			CFGlightningDelayScaling = RegisterConfigBool(cfg, "False Son - Lightning Changes", "Lightning Delay Scaling", lightningDelayScaling, "Makes lightning delay scale based on how far you are into a run, using the Scaling Multiplier.");
			CFGlightningDamageScaling = RegisterConfigBool(cfg, "False Son - Lightning Changes", "Lightning Damage Scaling", lightningDamageScaling, "Makes lightning damage scale based on how far you are into a run, using the Scaling Multiplier.");
			CFGlightningWarningFX = RegisterConfigBool(cfg, "False Son - Lightning Changes", "Lightning Warning VFX", lightningWarningFX, "Makes the lightning warning effect change colour right before it's about to strike.", restart: true);
			CFGlightningShakeDisable = RegisterConfigBool(cfg, "False Son - Lightning Changes", "Disable Lightning Screen Shake", lightningShakeDisable, "Removes the screen shake effects from lightning strikes.", restart: true);
			CFGpulseEnable = RegisterConfigBool(cfg, "False Son - Knockback Pulse", "Enable Pulse", defaultValue: true, "Enables the knockback pulse.");
			CFGpulseDetection = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Detection Range", pulseDetection, "The detection range of the knockback pulse.", 15f, 50f);
			CFGpulseTimer = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Timer", pulseTimer, "The amount of time a player needs to spend in the detection range before the pulse starts to fire.", 1f, 10f);
			CFGpulseDelay = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Delay", pulseDelay, "The amount of time it takes for the pulse to fire after being activated.", 1f, 10f);
			CFGpulseCooldown = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Cooldown", pulseCooldown, "The amount of time it takes before the pulse can start detecting players again after firing.", 1f, 15f);
			CFGpulseDamage = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Damage", pulseDamage, "The base damage dealt by the pulse.", 0.01f, 5f);
			CFGpulseForce = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Knockback Force", pulseForce, "The knockback force inflicted by the pulse.", 5000f, 20000f);
			CFGpulseRadius = RegisterConfigFloat(cfg, "False Son - Knockback Pulse", "Pulse Radius", pulseRadius, "The blast radius of the knockback pulse.", 10f, 50f);
			CFGgeodeEnable = RegisterConfigBool(cfg, "False Son - Geode Mechanics", "Enable Changes", defaultValue: true, "Enables the changes to the geode mechanics during the False Son fight.", restart: true);
			CFGgeodeBuffs = RegisterConfigBool(cfg, "False Son - Geode Mechanics", "Enable Geode Buffs", defaultValue: true, "Enables the buffs granted to the player when a geode is used.");
			CFGgeodeSpeedMult = RegisterConfigFloat(cfg, "False Son - Geode Mechanics", "Geode Speed Boost", geodeSpeedMult, "Speed bonus from the geode speed buff.", 0.1f, 1f);
			CFGgeodeSpeedDuration = RegisterConfigFloat(cfg, "False Son - Geode Mechanics", "Geode Speed Duration", geodeSpeedDuration, "Duration of the geode speed buff.", 1f, 10f);
			CFGgeodeRegenAmount = RegisterConfigFloat(cfg, "False Son - Geode Mechanics", "Geode Regen Boost", geodeRegenAmount, "Percentage of Max HP to regen per second.", 0.01f, 0.2f);
			CFGgeodeRegenDuration = RegisterConfigFloat(cfg, "False Son - Geode Mechanics", "Geode Regen Duration", geodeRegenDuration, "Duration of the geode regen buff.", 1f, 5f);
			CFGhalcLaser = RegisterConfigBool(cfg, "False Son - Geode Mechanics", "Disable Halcyonite Laser", halcLaser, "Disables the tri-laser attack from the Halcyonite spawned by the geodes.");
			CFGhalcHP = RegisterConfigInt(cfg, "False Son - Geode Mechanics", "Halcyonite HP Boosts", halcHP, "Amount of HP Boosts for the Halcyonite to get (1 = 10% bonus).", 0, 50);
			CFGhalcDamage = RegisterConfigInt(cfg, "False Son - Geode Mechanics", "Halcyonite Damage Bonus", halcDamage, "Amount of Damage Boosts for the Halcyonite to get (1 = 10% bonus).", 0, 50);
			CFGslamEnable = RegisterConfigBool(cfg, "False Son - Fissure Slam", "Enable Changes", defaultValue: true, "Enables the changes to Fissure Slam.", restart: true);
			CFGslamCooldown = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Cooldown", slamCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGslamEclipse = RegisterConfigBool(cfg, "False Son - Fissure Slam", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGslamStocks = RegisterConfigInt(cfg, "False Son - Fissure Slam", "Skill Stocks", slamStocks, "The number of stocks for this skill.", 1, 5);
			CFGslamWindup1 = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Phase 1 Windup", slamWindup1, "Windup time multiplier for phase 1.", 0.5f, 3f);
			CFGslamWindup2 = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Phase 2/3 Windup", slamWindup2, "Windup time multiplier for phases 2/3.", 0.5f, 3f);
			CFGslamDelayMult = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Lightning Pattern 2 Delay Multiplier", slamDelayMult, "Lightning delay multiplier for the second lightning pattern.", 1f, 2.5f);
			CFGslamAbilityDelay = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Ability Lockout Time", slamAbilityDelay, "Amount of time that False Son is unable to use his abilities after slamming.", 0f, 3f);
			CFGslamAimSpeed = RegisterConfigFloat(cfg, "False Son - Fissure Slam", "Aim Speed", slamAimSpeed, "Degrees per second that False Son is able to rotate during the slam windup.", 5f, 180f);
			CFGslamFissures = RegisterConfigInt(cfg, "False Son - Fissure Slam", "Fissure Column Count", slamFissures, "Amount of Fissure Columns spawned by the slam.", 0, 6);
			CFGdashEnable = RegisterConfigBool(cfg, "False Son - Corrupted Paths", "Enable Changes", defaultValue: true, "Enables the changes to Corrupted Paths.", restart: true);
			CFGdashCooldown = RegisterConfigFloat(cfg, "False Son - Corrupted Paths", "Cooldown", dashCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGdashEclipse = RegisterConfigBool(cfg, "False Son - Corrupted Paths", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGdashWindup = RegisterConfigFloat(cfg, "False Son - Corrupted Paths", "Dash Windup Time", dashWindup, "Windup time of the dash.", 0.2f, 2f);
			CFGdashLightningDelay = RegisterConfigFloat(cfg, "False Son - Corrupted Paths", "Lightning Delay Multiplier", dashLightningDelay, "Lightning delay multiplier for the lightning spawned by the dash.", 0.2f, 2f);
			CFGdashArmor = RegisterConfigBool(cfg, "False Son - Corrupted Paths", "Dash Armor", dashArmor, "Gives False Son an armor boost during the dash.");
			CFGdashSlamDelay = RegisterConfigFloat(cfg, "False Son - Corrupted Paths", "Slam Delay Time", dashSlamDelay, "Delay time before False Son slams after using the dash.", 0f, 1.5f);
			CFGofferingEnable = RegisterConfigBool(cfg, "False Son - Tainted Offering", "Enable Changes", defaultValue: true, "Enables the changes to Tainted Offering.", restart: true);
			CFGofferingCooldown = RegisterConfigFloat(cfg, "False Son - Tainted Offering", "Cooldown", offeringCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGofferingEclipse = RegisterConfigBool(cfg, "False Son - Tainted Offering", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGofferingStakeEnable = RegisterConfigBool(cfg, "False Son - Tainted Offering", "Lunar Stake", defaultValue: true, "Replaces the central projectile with a lunar stake.");
			CFGofferingProjectiles = RegisterConfigBool(cfg, "False Son - Tainted Offering", "Reduce Projectile Count", defaultValue: true, "Reduces the number of projectiles from 9 to 5.");
			CFGofferingSpikeSpeed = RegisterConfigFloat(cfg, "False Son - Tainted Offering", "Spike Projectile Speed", offeringSpikeSpeed, "Base projectile speed of the lunar spikes. Scales based on False Son's distance to his target.", 10f, 100f);
			CFGofferingStakeSpeed = RegisterConfigFloat(cfg, "False Son - Tainted Offering", "Stake Projectile Speed", offeringStakeSpeed, "Base projectile speed of the lunar stake. Scales based on False Son's distance to his target.", 10f, 100f);
			CFGofferingAimSpeed = RegisterConfigFloat(cfg, "False Son - Tainted Offering", "Aim Speed", offeringAimSpeed, "Degrees per second that False Son is able to rotate during the tainted offering windup.", 5f, 180f);
			CFGrainEnable = RegisterConfigBool(cfg, "False Son - Lunar Rain", "Enable Changes", defaultValue: true, "Enables the changes to Lunar Rain.", restart: true);
			CFGrainCooldown = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Cooldown", rainCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGrainEclipse = RegisterConfigBool(cfg, "False Son - Lunar Rain", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGrainWindup = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Windup Time", rainWindup, "Windup time of Lunar Rain.", 1f, 15f);
			CFGcrystalCount = RegisterConfigInt(cfg, "False Son - Lunar Rain", "Crystal Count", crystalCount, "The number of crystals to spawn.", 5, 20);
			CFGcrystalDuration = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Crystal Duration", crystalDuration, "Time before each crystal automatically detonates.", 5f, 200f, percent: true);
			CFGcrystalAutoDetonate = RegisterConfigBool(cfg, "False Son - Lunar Rain", "Auto-Detonate Crystals", crystalAutoDetonate, "Automatically detonate all remaining crystals each time Lunar Rain is used.");
			CFGcrystalTimer = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Crystal Detonation Timer", crystalTimer, "Warning time after a crystal begins detonating.", 0.5f, 4f);
			CFGcrystalDamage = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Crystal Damage", crystalDamage, "Base damage coefficient of the crystal explosions.", 0.5f, 10f);
			CFGcrystalFalloff = RegisterConfigBool(cfg, "False Son - Lunar Rain", "Crystal Damage Falloff", defaultValue: true, "Changes crystal explosions to have half-linear damage falloff (instead of no falloff).");
			CFGcrystalFissures = RegisterConfigInt(cfg, "False Son - Lunar Rain", "Crystal Fissure Column Count", crystalFissures, "Amount of Fissure Columns to fire around each crystal when spawned.", 0, 6);
			CFGcrystalOverchargeRadius = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Crystal Overcharge Radius Multiplier", crystalOverchargeRadius, "Explosion radius multiplier when a crystal is overcharged.", 1f, 3f, percent: false, restart: true);
			CFGcrystalOverchargeDamage = RegisterConfigFloat(cfg, "False Son - Lunar Rain", "Crystal Overcharge Damage Multiplier", crystalOverchargeDamage, "Explosion damage multiplier when a crystal is overcharged.", 1f, 3f);
			CFGcrystalOverchargeLight = RegisterConfigBool(cfg, "False Son - Lunar Rain", "Enable Overcharge Light VFX", defaultValue: true, "Enables the light VFX for when a crystal is overcharged.");
			CFGlaserCooldown = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Cooldown", laserCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGlaserEclipse = RegisterConfigBool(cfg, "False Son - Lunar Gaze", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGleapEnable = RegisterConfigBool(cfg, "False Son - Lunar Gaze", "Enable Leap Changes", defaultValue: true, "Enables the changes to the Lunar Gaze leap.", restart: true);
			CFGleapDelay = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Leap Lightning Delay Multiplier", leapDelay, "Lightning delay multiplier for the lunar gaze leap.", 0.5f, 5f);
			CFGleapFrequency = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Leap Lightning Frequency", leapFrequency, "Frequency multiplier of the leap lightning volleys. Increasing this value increases the maximum amount of lightning volleys from the leap that can be on screen at once.", 0.1f, 2f);
			CFGleapDuration = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Leap Lightning Duration", leapDuration, "Amount of time that the leap lightning cascade lasts for.", 1f, 5f);
			CFGleapMin = RegisterConfigInt(cfg, "False Son - Lunar Gaze", "Leap Lightning Min Strikes", leapMin, "The minimum number of lightning strikes that can be spawned per volley from the leap.", 1, 10);
			CFGleapMax = RegisterConfigInt(cfg, "False Son - Lunar Gaze", "Leap Lightning Max Strikes", leapMax, "The maximum number of lightning strikes that can be spawned per volley from the leap.", 1, 10);
			CFGleapPlusMult = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Leap Lightning Phase 3 Multiplier", leapPlusMult, "Multiplies the amount of lightning spawned by the leap during phase 3, to account for the smaller arena.", 0.25f, 2f);
			CFGlaserEnable = RegisterConfigBool(cfg, "False Son - Lunar Gaze", "Enable Laser Changes", defaultValue: true, "Enables the changes to the Lunar Gaze laser.", restart: true);
			CFGlaserDuration = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Laser Duration", laserDuration, "Duration of the Lunar Gaze laser.", 5f, 30f);
			CFGlaserDamage = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Laser Damage", laserDamage, "Base damage coefficient per hit from the laser.", 0.5f, 15f);
			CFGlaserTickRate = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Laser Tick Rate", laserTickRate, "Time between hits from the laser. Also impacts how fast targeting builds up.", 0.1f, 1f);
			CFGlaserDecayRate = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Laser Targeting Decay Rate", laserDecayRate, "The amount of time between stacks of the laser targeting debuff being removed.", 0.1f, 1f);
			CFGlaserLightEnable = RegisterConfigBool(cfg, "False Son - Lunar Gaze", "Enable Laser Light/Shadow VFX", defaultValue: true, "Enables the light emission from the meridian statue during Lunar Gaze. If you're experiencing frame drops or general performance issues, try disabling this.");
			CFGlaserLightIntensity = RegisterConfigFloat(cfg, "False Son - Lunar Gaze", "Laser Light/Shadow VFX Intensity", laserLightIntensity, "Intensity of the laser light effects.", 1f, 50f);
			CFGdevastatorCooldown = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Cooldown", devastatorCooldown, "Cooldown time of this skill.", 1f, 100f);
			CFGdevastatorEclipse = RegisterConfigBool(cfg, "False Son - Prime Devastator", "Use New Eclipse 7 Multiplier", defaultValue: true, "Enables the Eclipse 7 Multiplier Override for this skill.");
			CFGdevastatorOrbEnable = RegisterConfigBool(cfg, "False Son - Prime Devastator", "Enable Orb Changes", defaultValue: true, "Enables the changes to the Prime Devastator orbs.", restart: true);
			CFGdevastatorOrbSpeed = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Orb Speed", devastatorOrbSpeed, "The amount of time that it takes for a Prime Devastator orb to do a full rotation of the arena (lower value = faster orb).", 0.5f, 10f, percent: false, restart: true);
			CFGdevastatorOrbDuration = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Orb Duration", devastatorOrbDuration, "The duration of each Prime Devastator orb.", 3f, 30f, percent: false, restart: true);
			CFGdevastatorOrbDamage = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Orb Damage", devastatorOrbDamage, "The base damage coefficient for each Prime Devastator orb.", 0.5f, 10f, percent: false, restart: true);
			CFGdevastatorOrbCount = RegisterConfigInt(cfg, "False Son - Prime Devastator", "Orb Count", devastatorOrbCount, "The amount of orbs for Prime Devastator to spawn.", 1, 10, restart: true);
			CFGdevastatorDebuffEnable = RegisterConfigBool(cfg, "False Son - Prime Devastator", "Enable Debuff Changes", defaultValue: true, "Enables the changes to the Prime Devastator debuff.", restart: true);
			CFGdevastatorDebuffInterval = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Debuff Tick Rate", devastatorDebuffInterval, "Time between hits from the new debuff.", 0.1f, 5f, percent: false, restart: true);
			CFGdevastatorDebuffFSMult = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Debuff Damage Multiplier (False Son)", devastatorDebuffFSMult, "Multiplier for damage dealt to False Son while debuffed.", 0.1f, 1f);
			CFGdevastatorDebuffHalcMult = RegisterConfigFloat(cfg, "False Son - Prime Devastator", "Debuff Damage Multiplier (Halcyonite)", devastatorDebuffHalcMult, "Multiplier for damage dealt to the Geode Mechanics Halcyonite while debuffed.", 1f, 5f);
			CFGdevastatorDebuffVFX = RegisterConfigBool(cfg, "False Son - Prime Devastator", "Enable Debuff VFX", defaultValue: true, "Enables the screen-wide VFX for when you're inflicted with the new debuff (same VFX as the old debuff).", restart: true);
			CFGartifactEnable = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Enable Artifact", defaultValue: true, "Enables the Artifact. If disabled, you can still do Hard Mode using other configs or the Artifact of Thunder puzzle.", restart: true);
			CFGforceHardMode = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Force Hard Mode", defaultValue: false, "Forces Hard Mode to be enabled, regardless of whether the Artifact of Thunder is enabled.");
			CFGforceEclipse = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Force Hard Mode on Eclipse 8", defaultValue: false, "Forces Hard Mode to be enabled when playing on Eclipse 8.");
			CFGthunderBonusItems = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "General - Bonus Rewards", defaultValue: true, "Increases the number of items you can take from the False Son reward geode from 1 to 3 in Hard Mode.");
			CFGthunderHPBoost = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "General - Health Boosts", thunderHPBoost, "The amount of health boosts for False Son to recieve during Hard Mode (1 = 10% boost). Also impacts the soft damage cap.", 0, 20);
			CFGthunderLightningDelayMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Lightning Delay Multiplier", thunderLightningDelayMult, "Multiplier to the lightning strike delay time for pretty much all lightning during Hard Mode. Unchanged by default.", 0.1f, 1f);
			CFGthunderPassiveLightning1 = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Phase 1 Passive Lightning", defaultValue: true, "Enables standard passive lightning during phase 1 in Hard Mode.");
			CFGthunderPassiveLightning2 = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Phase 2 Passive Lightning", defaultValue: false, "Enables standard passive lightning during phase 2 in Hard Mode. Off by default.");
			CFGthunderPassiveLightning3 = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Phase 3 Passive Lightning", defaultValue: false, "Enables standard passive lightning during phase 3 in Hard Mode. Off by default.");
			CFGthunderLightningLine2 = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Phase 2 Lightning Line", defaultValue: true, "Enables the passive lightning line that starts striking in phase 2 (persists into phase 3).");
			CFGthunderLightningLine3 = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Phase 3 Lightning Line", defaultValue: true, "Enables the passive lightning line that starts striking in phase 3.");
			CFGthunderLightningLineDelayMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Lightning Line Delay Multiplier", thunderLightningLineDelayMult, "The delay multiplier for the lightning lines.", 0.5f, 5f);
			CFGthunderLightningLineInterval = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lightning Changes - Lightning Line Interval", thunderLightningLineInterval, "Time between lightning line strikes. Impacted by the scaling multiplier if lightning delay scaling is enabled.", 1f, 20f);
			CFGthunderPulseFissures = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Knockback Pulse - Fissure Count", thunderPulseFissures, "Number of Fissure Columns to spawn each time the Knockback Pulse fires in Hard Mode.", 0, 20);
			CFGthunderGeodeBarrier = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Barrier", thunderGeodeBarrier, "Amount of Barrier for False Son to recieve whenever a geode is broken in Hard Mode.", 0f, 1f);
			CFGthunderGeodeHeal = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Healing", thunderGeodeHeal, "Amount of Healing for False Son to recieve whenever a geode is broken in Hard Mode. Off by default.", 0f, 1f);
			CFGthunderGeodeElite = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Elite Halcyonite", defaultValue: true, "Gives the Halcyonite a random T1 Elite Aspect in Hard Mode (excluding mending).");
			CFGthunderGeodeArmor = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Adaptive Armor", defaultValue: false, "Gives the Halcyonite adaptive armor in Hard Mode. Off by default.");
			CFGthunderGeodeHP = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - HP Boosts", thunderGeodeHP, "Amount of HP Boosts for the Halcyonite to get in Hard Mode (1 = 10% bonus).", 0, 50);
			CFGthunderGeodeGolems = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Golems", defaultValue: true, "Causes 2 Stone Golems to spawn alongside the Halcyonite in Hard Mode.");
			CFGthunderGeodeGolemHP = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Geode Mechanics - Golem HP Boosts", thunderGeodeGolemHP, "Amount of HP Boosts for the Golems to get (1 = 10% bonus).", 0, 50);
			CFGthunderSlamPatterns = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Fissure Slam - Phase 1 Secondary Lightning Patterns", defaultValue: true, "Causes Fissure Slam to use the phase 2/3 lightning patterns during phase 1 in Hard Mode, as well as the increased windup time.");
			CFGthunderSlamScatters = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Fissure Slam - Lightning Scatter Count", thunderSlamScatters, "Amount of lightning strikes to be scattered around False Son while charging up Fissure Slam during phases 2/3 in Hard Mode.", 0, 15);
			CFGthunderSlamScatterDelay = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Fissure Slam - Lightning Scatter Delay Multiplier", thunderSlamScatterDelay, "Lightning delay multiplier for the Hard Mode lightning scatters.", 0.1f, 2f);
			CFGthunderSlamFissures = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Fissure Slam - Fissure Count", thunderSlamFissures, "Amount of Fissure Columns spawned by the slam in Hard Mode.", 0, 20);
			CFGthunderSlamWindupMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Fissure Slam - Windup Multiplier", thunderSlamWindupMult, "Windup multiplier for the slam in Hard Mode. Unchanged by default.", 0.25f, 1f);
			CFGthunderDashParry = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Enable Parry", defaultValue: true, "Enables the parry for Corrupted Paths in Hard Mode.");
			CFGthunderDashParryAll = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Parry Everything", defaultValue: false, "Removes the check that makes the parry only proc on direct skill damage. Off by default.");
			CFGthunderDashParryDuration = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Parry Duration", thunderDashParryDuration, "Duration of the parry.", 0.1f, 1.5f);
			CFGthunderDashWindup = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Windup Increase", thunderDashWindup, "Increases the duration of the Corrupted Paths windup in Hard Mode.", 0f, 1.5f);
			CFGthunderDashEnable = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Enable in Phases 2/3", defaultValue: true, "Allows False Son to use Corrupted Paths during phases 2/3 in Hard Mode.");
			CFGthunderDashCooldown = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Corrupted Paths - Phase 2/3 Cooldown", thunderDashCooldown, "Corrupted Paths cooldown during phases 2/3 in Hard Mode. Unaffected by cooldown modifiers.", 0f, 20f);
			CFGthunderOfferingSpeedMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Tainted Offering - Projectile Speed Multiplier", thunderOfferingSpeedMult, "Increases the speed of the Tainted Offering projectiles in Hard Mode.", 1f, 3f);
			CFGthunderOfferingProjectiles = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Tainted Offering - Increase Projectile Count", defaultValue: false, "Increases the number of projectiles fired from 5 to 9 in Hard Mode, regardless of the normal mode setting. Off by default.");
			CFGthunderOfferingStakes = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Tainted Offering - Oops! All Lunar Stakes", defaultValue: true, "Replaces every projectile from Tainted Offering with a Lunar Stake in Hard Mode.");
			CFGthunderCrystalCount = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Lunar Rain - Crystal Count", thunderCrystalCount, "Amount of crystals for Lunar Rain to spawn in Hard Mode.", 10, 25);
			CFGthunderCrystalShards = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Lunar Rain - Crystal Shards", thunderCrystalShards, "Amount of Lunar Shards fired from Overcharged Lunar Rain crystals in Hard Mode.", 5, 30);
			CFGthunderCrystalFissures = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Lunar Rain - Crystal Fissures", thunderCrystalFissures, "Amount of Fissure Columns fired from each spawned Lunar Rain crystal in Hard Mode. Unchanged by default.", 1, 15);
			CFGthunderLaserDuration = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lunar Gaze - Laser Duration", thunderLaserDuration, "Duration of the Lunar Gaze laser in Hard Mode.", 10f, 25f);
			CFGthunderLeapLightningPatterns = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Lunar Gaze - Lightning Patterns", defaultValue: true, "Enables the lightning patterns from the Lunar Gaze leap in Hard Mode.");
			CFGthunderLeapLightningMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lunar Gaze - Leap Lightning Multiplier", thunderLeapLightningMult, "Multiplies the amount of Lunar Gaze lightning volleys in Hard Mode. Unchanged by default.", 0.5f, 2f);
			CFGthunderLeapDurationMult = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Lunar Gaze - Leap Duration Multiplier", thunderLeapLightningMult, "Multiplies the duration of the Lunar Gaze lightning cascade in Hard Mode. Unchanged by default.", 0.5f, 2f);
			CFGthunderShockwaveEnable = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Enable Shockwave", defaultValue: true, "Enables the shockwave from Prime Devastator in Hard Mode.");
			CFGthunderShockwaveCount = RegisterConfigInt(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Shockwave Count", thunderShockwaveCount, "Amount of shockwaves spawned by Prime Devastator in Hard Mode.", 1, 15);
			CFGthunderShockwaveInterval = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Shockwave Interval", thunderShockwaveInterval, "Time between Prime Devastator shockwaves in Hard Mode. Shockwave duration is equal to this multiplied by the shockwave count.", 0.01f, 0.5f);
			CFGthunderShockwaveDamage = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Shockwave Damage", thunderShockwaveDamage, "Base damage that each shockwave deals to all grounded players.", 0.1f, 15f);
			CFGthunderShockwaveDelay = RegisterConfigFloat(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Delay Time", thunderShockwaveDelay, "Delay time before Prime Devastator strikes in Hard Mode. Changing this value can result in inaccurate warning VFX for the shockwave.", 1f, 4f);
			CFGthunderDevastatorOrbs = RegisterConfigBool(cfg, "False Son - Artifact of Thunder", "Prime Devastator - Double Orbs", defaultValue: false, "Doubles the number of Prime Devastator orbs spawned in Hard Mode. Off by default.", restart: true);
			CFGeyeEnable = RegisterConfigBool(cfg, "False Son - Eye of the Storm", "Enable Item", defaultValue: true, "Enables the Eye of the Storm item.", restart: true);
			CFGeyeSharing = RegisterConfigBool(cfg, "False Son - Eye of the Storm", "Item Sharing", defaultValue: true, "All players get a copy of the Eye of the Storm when it's collected.", restart: true);
			CFGeyeDamage = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Damage Requiement", eyeDamage, "Base amount of damage required before the Eye of the Storm fires lightning. No time limit between damage instances.", 5f, 50f);
			CFGeyeLightningCount = RegisterConfigInt(cfg, "False Son - Eye of the Storm", "Lightning Count", eyeLightningCount, "Amount of lightning strikes fired per activation.", 1, 20);
			CFGeyeLightningDamage = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Lightning Damage", eyeLightningDamage, "Damage coefficient of the lightning strikes.", 0.5f, 15f);
			CFGeyeLightningDelay = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Lightning Strike Delay", eyeLightningDelay, "Delay time before each lightning strike. Setting this too high can cause visual clutter.", 0f, 3f);
			CFGeyeLightningInterval = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Lightning Interval", eyeLightningInterval, "Time between lightning strikes.", 0.1f, 1f);
			CFGeyeLightningRadius = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Lightning Radius", eyeLightningRadius, "Size of each lightning strike.", 2f, 15f);
			CFGeyeLightningRange = RegisterConfigFloat(cfg, "False Son - Eye of the Storm", "Lightning Range", eyeLightningRange, "Maximum range that the lightning can strike from.", 5f, 50f);
			CFGauriEnable = RegisterConfigBool(cfg, "Aurelionite - General Changes", "Enable Changes", defaultValue: true, "Enables the changes to Aurelionite.", restart: true);
			CFGauriRegen = RegisterConfigFloat(cfg, "Aurelionite - General Changes", "Health Regeneration", auriRegen, "The HP fraction that aurelionite should regen per second.", 0f, 0.05f, percent: false, restart: true);
			CFGauriAdaptiveArmor = RegisterConfigBool(cfg, "Aurelionite - General Changes", "Adaptive Armor", auriAdaptiveArmor, "Gives Aurelionite Adaptive Armor during the False Son fight.");
			CFGauriFixedSpawn = RegisterConfigBool(cfg, "Aurelionite - General Changes", "Fixed Spawn", defaultValue: true, "Gives Aurelionite a fixed spawn location in the False Son fight.");
			CFGauriReducedStats = RegisterConfigBool(cfg, "Aurelionite - General Changes", "Reduced Stats", defaultValue: true, "Reduces Aurelionite's stats during the False Son fight.");
			CFGauriBaseHP = RegisterConfigFloat(cfg, "Aurelionite - General Changes", "Base Health", auriBaseHP, "Aurelionite's base max health.", 1f, 10000f, percent: false, restart: true);
			CFGauriLevelHP = RegisterConfigFloat(cfg, "Aurelionite - General Changes", "Level Health", auriLevelHP, "Aurelionite's max health per level.", 1f, 2500f, percent: false, restart: true);
			CFGauriBaseArmor = RegisterConfigFloat(cfg, "Aurelionite - General Changes", "Base Armor", auriBaseArmor, "Aurelionite's base armor.", 0f, 300f, percent: false, restart: true);
			CFGauriLevelArmor = RegisterConfigFloat(cfg, "Aurelionite - General Changes", "Level Armor", auriLevelArmor, "Aurelionite's armor per level.", 0f, 100f, percent: false, restart: true);
			CFGauriSwordEnable = RegisterConfigBool(cfg, "Aurelionite - Stone Sword", "Enable Changes", defaultValue: true, "Enables the changes to Stone Sword.", restart: true);
			CFGauriSwordDelay = RegisterConfigFloat(cfg, "Aurelionite - Stone Sword", "Sword Delay", auriSwordDelay, "Delay time before the first sword strikes from the ground.", 0.1f, 3f);
			CFGauriSwordInterval = RegisterConfigFloat(cfg, "Aurelionite - Stone Sword", "Sword Interval", auriSwordInterval, "Time between each wave of sword strikes.", 0f, 1.5f);
			CFGauriCrownEnable = RegisterConfigBool(cfg, "Aurelionite - Gilded Crown", "Enable Skill", defaultValue: true, "Enables the Gilded Crown skill, replacing Stone Construct as Aurelionie's utility skill.", restart: true);
			CFGauriCrownBypassArmor = RegisterConfigBool(cfg, "Aurelionite - Gilded Crown", "Bypass Armor", defaultValue: true, "Allows the Gilded Crown lasers to bypass armor and blocks.");
			CFGauriCrownLasers = RegisterConfigInt(cfg, "Aurelionite - Gilded Crown", "Laser Count", auriCrownLasers, "Number of lasers fired by the crown.", 6, 32);
			CFGauriCrownLasersFS = RegisterConfigInt(cfg, "Aurelionite - Gilded Crown", "Laser Count (False Son)", auriCrownLasersFS, "Number of lasers fired by the crown during the False Son fight.", 6, 32);
			CFGauriCrownSpinSpeed = RegisterConfigFloat(cfg, "Aurelionite - Gilded Crown", "Laser Spin Speed", auriCrownSpinSpeed, "Degrees per second that the lasers spin while closing in.", 0f, 180f);
			CFGauriCrownDuration = RegisterConfigFloat(cfg, "Aurelionite - Gilded Crown", "Laser Duration", auriCrownDuration, "Duration of the lasers. The lower the duration, the faster they close in.", 3f, 20f);
			CFGauriCrownDamage = RegisterConfigFloat(cfg, "Aurelionite - Gilded Crown", "Laser Damage", auriCrownDamage, "Damage coefficient of the lasers. Once hit, you cannot take additional damage from the lasers for 1s.", 0.5f, 10f);
			CFGauriCrownDamageDelay = RegisterConfigFloat(cfg, "Aurelionite - Gilded Crown", "Grace Period", auriCrownDamageDelay, "Amount of time that must pass before the lasers start dealing damage.", 0f, 3f);
			CFGauriBeamEnable = RegisterConfigBool(cfg, "Aurelionite - Luster Beam", "Enable Skill", defaultValue: true, "Enables the Luster Beam skill, replacing Eye Laser as Aurelionite's special skill.", restart: true);
			CFGauriBeamFrequency = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Projectile Fire Rate", auriBeamFrequency, "Amount of projectiles Aurelionite can fire per second while charging Luster Beam.", 1f, 20f);
			CFGauriBeamProjectileDamage = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Projectile Damage", auriBeamProjectileDamage, "Damage coefficient of the Luster Beam charge projectiles.", 0.1f, 4f);
			CFGauriBeamProjectileSpeed = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Projectile Speed", auriBeamProjectileSpeed, "Projectile speed of the Luster Beam charge projectiles.", 10f, 200f);
			CFGauriBeamProjectileSpread = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Base Projectile Accuracy", auriBeamProjectileSpread, "Base spread angle of the Luster Beam charge projectiles. The lower the value, the more accurate it will be.", 0f, 30f);
			CFGauriBeamProjectileAccuracy = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Projectile Accuracy Scaler", auriBeamProjectileAccuracy, "The amount of spread reduction the projectiles gain for every 1s of charging Luster Beam. The higher the value, the more accurate the projectiles will be over time.", 0f, 10f);
			CFGauriBeamDuration = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Beam Charge Time", auriBeamDuration, "Time it takes for Luster Beam to fire.", 1f, 5f);
			CFGauriBeamDamage = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Beam Damage", auriBeamDamage, "Damage coefficient of the beam.", 0.5f, 10f);
			CFGauriBeamRadius = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Blast Radius", auriBeamRadius, "Radius of the beam explosion.", 0.5f, 15f);
			CFGauriBeamForce = RegisterConfigFloat(cfg, "Aurelionite - Luster Beam", "Knockback Force", auriBeamForce, "Knockback force of the beam explosion.", 0f, 10000f);
			CFGauriBeamIgnite = RegisterConfigBool(cfg, "Aurelionite - Luster Beam", "Ignite on Hit", defaultValue: true, "Causes the beam to ignite on hit for 50% total damage.");
			CFGcoastEnable = RegisterConfigBool(cfg, "Aurelionite - Gilded Coast Mechanics", "Enable Changes", defaultValue: true, "Enables the changes to the Gilded Coast mechanics.", restart: true);
			CFGcoastBonusChest = RegisterConfigBool(cfg, "Aurelionite - Gilded Coast Mechanics", "Bonus Chest", defaultValue: true, "Spawns the bonus large chest in the Gilded Coast.");
			CFGcoastSpawnTimer = RegisterConfigFloat(cfg, "Aurelionite - Gilded Coast Mechanics", "Spawn Timer", coastSpawnTimer, "Amount of time before Aurelionite spawns in the Gilded Coast.", 50f, 300f);
			CFGcoastSpawnReduction = RegisterConfigFloat(cfg, "Aurelionite - Gilded Coast Mechanics", "Spawn Timer Reduction per Beacon", coastSpawnReduction, "Amount of time from the spawn timer that gets skipped whenever a beacon is activated.", 0f, 60f);
			CFGcoastBaseArmor = RegisterConfigFloat(cfg, "Aurelionite - Gilded Coast Mechanics", "Base Beacon Armor", coastBaseArmor, "Amount of armor Aurelionite recieves while at least one beacon is active.", 0f, 500f);
			CFGcoastBeaconArmor = RegisterConfigFloat(cfg, "Aurelionite - Gilded Coast Mechanics", "Beacon Armor", coastBeaconArmor, "Amount of additional armor Aurelionite recieves for each active beacon.", 0f, 500f);
			CFGcoastBeaconTimer = RegisterConfigInt(cfg, "Aurelionite - Gilded Coast Mechanics", "Beacon Extinguish Timer", coastBeaconTimer, "Amount of time before beacons get extinguished after being activated. Does not apply until Aurelionite spawns.", 20, 100);
			CFGcoastBeaconExtension = RegisterConfigInt(cfg, "Aurelionite - Gilded Coast Mechanics", "Beacon Extinguish Timer Extension", coastBeaconExtension, "Amount of time each beacon timer gets extended by whenever you activate a beacon.", 0, 50);
			CFGcoastGoldMult = RegisterConfigFloat(cfg, "Aurelionite - Gilded Coast Mechanics", "Gold Chunk Multiplier", coastGoldMult, "Multiplies the amount of gold that Aurelionite drops when damaging her by this amount.", 0f, 10f);
			CFGhalcyonStages = RegisterConfigString(cfg, "Miscellaneous - Halcyon Shrines", "Guaranteed Spawns", "village,habitat,helminthroost,hollowsummit_wormsworms,hollowsummitnight_wormsworms", "List of stages to get a guaranteed Halcyon Shrine. Does not allow for more than one Halcyon Shrine to spawn per stage, and still uses up scene director credits. Shattered Abodes, Treeborn Colony, Helminth Hatchery, Hollow Summit, and Frozen Summit are selected by default (Hollow/Frozen Summit mod is not required). Stages are separated by commas with no spaces inbetween.");
			CFGhalcyonChanceMult = RegisterConfigFloat(cfg, "Miscellaneous - Halcyon Shrines", "Spawn Chance Multiplier", halcyonChanceMult, "Multiplies the chance of Halcyon Shrines spawning on non-guaranteed stages.", 0.5f, 5f);
			CFGhalcyonStage5 = RegisterConfigBool(cfg, "Miscellaneous - Halcyon Shrines", "Stage 5 Meridian", defaultValue: true, "Causes Halcyon Shrines to take you to the Prime Meridian on stage 5.");
			CFGmeridianReduceLightning = RegisterConfigBool(cfg, "Miscellaneous - Prime Meridian", "Reduce Lightning", defaultValue: true, "Reduces the amount of lightning that spawns on the Prime Meridian.", restart: true);
			CFGmeridianSpawnMult = RegisterConfigFloat(cfg, "Miscellaneous - Prime Meridian", "Monster Spawn Reduction", meridianSpawnMult, "Multiplies the available Prime Merdian monster credits by this value.", 0.1f, 1f);
			CFGmeridianMoneyMult = RegisterConfigFloat(cfg, "Miscellaneous - Prime Meridian", "Gold Reduction", meridianMoneyMult, "Multiplies the amount of gold earned on the Prime Merdian by this value.", 0.1f, 1f);
			CFGmeridianGeodeSpawns = RegisterConfigBool(cfg, "Miscellaneous - Prime Meridian", "Geode Monster Spawns", defaultValue: true, "Causes the geodes on the meridian climb to act like combat shrines when used.");
			CFGmeridianGeodeCredits = RegisterConfigFloat(cfg, "Miscellaneous - Prime Meridian", "Geode Base Credits", meridianGeodeCredits, "Base amount of monster credits given to the director when activating a geode.", 10f, 150f);
			CFGmeridianGeodeScaling = RegisterConfigFloat(cfg, "Miscellaneous - Prime Meridian", "Geode Scaling Credits", meridianGeodeScaling, "Additional monster credits given to the director for each previously activated geode.", 0f, 150f);
			CFGvoidGeodes = RegisterConfigBool(cfg, "Miscellaneous - Void Fields", "Enable Void Fields Mini-Geodes", defaultValue: true, "Enables the mini-geodes to spawn after clearing void fields, allowing you to enter the path of the colossus.", restart: true);
			CFGvoidGeodeCount = RegisterConfigInt(cfg, "Miscellaneous - Void Fields", "Void Fields Geode Count", voidGeodeCount, "The amount of spawned geodes that need to be destroyed to open the green portal in void fields. Setting this to 0 will open the green portal automatically after clearing void fields.", 0, 9);
			CFGvoidLightIntensity = RegisterConfigFloat(cfg, "Miscellaneous - Void Fields", "Geode Light Intensity", voidLightIntensity, "Intensity of the light emission from the void fields geodes. Set this to a higher value to make them easier to spot.", 0f, 10f, percent: false, restart: true);
			CFGvoidLightRange = RegisterConfigFloat(cfg, "Miscellaneous - Void Fields", "Geode Light Range", voidLightRange, "Range of the light emission from the void fields geodes. Set this to a higher value to make them easier to spot.", 0f, 50f, percent: false, restart: true);
		}

		public static void UpdateConfigValues(bool SetValues = false)
		{
			bool flag = false;
			if (!SetValues)
			{
				flag = enableConfigs != null && enableConfigs.Value;
				laserLightAutoDisable = ((CFGlaserLightAutoDisable != null) ? CFGlaserLightAutoDisable.Value : 10f);
			}
			scalingMult = (flag ? CFGscalingMult.Value : 1.2f);
			bonusItemEnable = flag && CFGbonusItemEnable.Value;
			adaptiveArmorEnable = !flag || CFGadaptiveArmorEnable.Value;
			damageCapEnable = !flag || CFGdamageCapEnable.Value;
			freezeImmunityEnable = !flag || CFGfreezeImmunityEnable.Value;
			freezeDamage = 1.5f;
			lunarRuinEnable = !flag || CFGlunarRuinEnable.Value;
			lunarRuinCap = (flag ? CFGlunarRuinCap.Value : 1.5f);
			eclipseCooldownMult = (flag ? CFGeclipseMult.Value : 0.75f);
			fsBaseHP1 = (flag ? CFGfsBaseHP1.Value : 1000f);
			fsLevelHP1 = (flag ? CFGfsLevelHP1.Value : 300f);
			fsBaseHP2 = (flag ? CFGfsBaseHP2.Value : 1100f);
			fsLevelHP2 = (flag ? CFGfsLevelHP2.Value : 330f);
			fsBaseHP3 = (flag ? CFGfsBaseHP3.Value : 1200f);
			fsLevelHP3 = (flag ? CFGfsLevelHP3.Value : 360f);
			fsBaseArmor = (flag ? CFGfsBaseArmor.Value : 25f);
			fsLevelArmor = (flag ? CFGfsLevelArmor.Value : 0f);
			lightningRadiusMult = (flag ? CFGlightningRadiusMult.Value : 0.9f);
			baseLightningDelay = (flag ? CFGbaseLightningDelay.Value : 1.2f);
			lightningDamage = (flag ? CFGlightningDamage.Value : 0.125f);
			lightningDelayScaling = !flag || CFGlightningDelayScaling.Value;
			lightningDamageScaling = !flag || CFGlightningDamageScaling.Value;
			lightningWarningFX = !flag || CFGlightningWarningFX.Value;
			lightningShakeDisable = !flag || CFGlightningShakeDisable.Value;
			pulseEnable = !flag || CFGpulseEnable.Value;
			pulseDetection = (flag ? CFGpulseDetection.Value : 22f);
			pulseTimer = (flag ? CFGpulseTimer.Value : 5f);
			pulseDelay = (flag ? CFGpulseDelay.Value : 3f);
			pulseCooldown = (flag ? CFGpulseCooldown.Value : 3f);
			pulseDamage = (flag ? CFGpulseDamage.Value : 0.75f);
			pulseForce = (flag ? CFGpulseForce.Value : 10000f);
			pulseRadius = (flag ? CFGpulseRadius.Value : 17.5f);
			geodeEnable = !flag || CFGgeodeEnable.Value;
			geodeBuffs = !flag || CFGgeodeBuffs.Value;
			geodeSpeedMult = (flag ? CFGgeodeSpeedMult.Value : 0.5f);
			geodeSpeedDuration = (flag ? CFGgeodeSpeedDuration.Value : 5f);
			geodeRegenAmount = (flag ? CFGgeodeRegenAmount.Value : 0.05f);
			geodeRegenDuration = (flag ? CFGgeodeRegenDuration.Value : 2f);
			halcLaser = !flag || CFGhalcLaser.Value;
			halcHP = (flag ? CFGhalcHP.Value : 10);
			halcDamage = (flag ? CFGhalcDamage.Value : 0);
			slamEnable = !flag || CFGslamEnable.Value;
			slamCooldown = (flag ? CFGslamCooldown.Value : 5.5f);
			slamEclipse = !flag || CFGslamEclipse.Value;
			slamStocks = ((!flag) ? 1 : CFGslamStocks.Value);
			slamWindup1 = (flag ? CFGslamWindup1.Value : 1.2f);
			slamWindup2 = (flag ? CFGslamWindup2.Value : 1.8f);
			slamDelayMult = (flag ? CFGslamDelayMult.Value : 1.5f);
			slamAbilityDelay = (flag ? CFGslamAbilityDelay.Value : 2f);
			slamFissures = (flag ? CFGslamFissures.Value : 3);
			slamAimSpeed = (flag ? CFGslamAimSpeed.Value : 30f);
			dashEnable = !flag || CFGdashEnable.Value;
			dashCooldown = (flag ? CFGdashCooldown.Value : 7f);
			dashEclipse = !flag || CFGdashEclipse.Value;
			dashWindup = (flag ? CFGdashWindup.Value : 0.6f);
			dashLightningDelay = (flag ? CFGdashLightningDelay.Value : 0.4f);
			dashArmor = !flag || CFGdashArmor.Value;
			dashSlamDelay = (flag ? CFGdashSlamDelay.Value : 0.5f);
			offeringEnable = !flag || CFGofferingEnable == null || CFGofferingEnable.Value;
			offeringCooldown = (flag ? CFGofferingCooldown.Value : 6f);
			offeringEclipse = !flag || CFGofferingEclipse.Value;
			offeringStakeEnable = !flag || CFGofferingStakeEnable.Value;
			offeringProjectiles = !flag || CFGofferingProjectiles.Value;
			offeringSpikeSpeed = (flag ? CFGofferingSpikeSpeed.Value : 30f);
			offeringStakeSpeed = (flag ? CFGofferingStakeSpeed.Value : 45f);
			offeringAimSpeed = (flag ? CFGofferingAimSpeed.Value : 10f);
			rainEnable = !flag || CFGrainEnable.Value;
			rainCooldown = (flag ? CFGrainCooldown.Value : 20f);
			rainEclipse = !flag || CFGrainEclipse.Value;
			rainWindup = (flag ? CFGrainWindup.Value : 8f);
			crystalCount = (flag ? CFGcrystalCount.Value : 10);
			crystalDuration = (flag ? CFGcrystalDuration.Value : 120f);
			crystalAutoDetonate = !flag || CFGcrystalAutoDetonate.Value;
			crystalDamage = (flag ? CFGcrystalDamage.Value : 1.4f);
			crystalTimer = (flag ? CFGcrystalTimer.Value : 2.5f);
			crystalFalloff = !flag || CFGcrystalFalloff.Value;
			crystalFissures = ((!flag) ? 1 : CFGcrystalFissures.Value);
			crystalOverchargeDamage = (flag ? CFGcrystalOverchargeDamage.Value : 1.25f);
			crystalOverchargeRadius = (flag ? CFGcrystalOverchargeRadius.Value : 1.5f);
			crystalOverchargeLight = !flag || CFGcrystalOverchargeLight.Value;
			laserCooldown = (flag ? CFGlaserCooldown.Value : 35f);
			laserEclipse = !flag || CFGlaserEclipse.Value;
			leapEnable = !flag || CFGleapEnable.Value;
			leapDelay = (flag ? CFGleapDelay.Value : 1.5f);
			leapFrequency = (flag ? CFGleapFrequency.Value : 1f);
			leapDuration = (flag ? CFGleapDuration.Value : 2.5f);
			leapMin = (flag ? CFGleapMin.Value : 4);
			leapMax = (flag ? CFGleapMax.Value : 5);
			leapPlusMult = (flag ? CFGleapPlusMult.Value : 0.7f);
			laserEnable = !flag || CFGlaserEnable.Value;
			laserLightEnable = !flag || CFGlaserLightEnable == null || CFGlaserLightEnable.Value;
			laserDuration = (flag ? CFGlaserDuration.Value : 13f);
			laserDamage = (flag ? CFGlaserDamage.Value : 3.25f);
			laserTickRate = (flag ? CFGlaserTickRate.Value : 0.25f);
			laserDecayRate = (flag ? CFGlaserDecayRate.Value : 0.2f);
			laserLightIntensity = (flag ? CFGlaserLightIntensity.Value : 12f);
			devastatorCooldown = (flag ? CFGdevastatorCooldown.Value : 45f);
			devastatorEclipse = !flag || CFGdevastatorEclipse.Value;
			devastatorOrbEnable = !flag || CFGdevastatorOrbEnable.Value;
			devastatorOrbSpeed = (flag ? CFGdevastatorOrbSpeed.Value : 4f);
			devastatorOrbDuration = (flag ? CFGdevastatorOrbDuration.Value : 12f);
			devastatorOrbDamage = (flag ? CFGdevastatorOrbDamage.Value : 1.5f);
			devastatorOrbCount = (flag ? CFGdevastatorOrbCount.Value : 6);
			devastatorDebuffEnable = !flag || CFGdevastatorDebuffEnable.Value;
			devastatorDebuffInterval = (flag ? CFGdevastatorDebuffInterval.Value : 1f);
			devastatorDebuffFSMult = (flag ? CFGdevastatorDebuffFSMult.Value : 0.25f);
			devastatorDebuffHalcMult = (flag ? CFGdevastatorDebuffHalcMult.Value : 2f);
			devastatorDebuffVFX = !flag || CFGdevastatorDebuffVFX.Value;
			artifactEnable = !flag || CFGartifactEnable.Value;
			forceHardMode = flag && CFGforceHardMode.Value;
			forceEclipse = flag && CFGforceEclipse.Value;
			thunderBonusItems = !flag || CFGthunderBonusItems.Value;
			thunderHPBoost = (flag ? CFGthunderHPBoost.Value : 5);
			thunderLightningDelayMult = (flag ? CFGthunderLightningDelayMult.Value : 1f);
			thunderPassiveLightning1 = !flag || CFGthunderPassiveLightning1.Value;
			thunderPassiveLightning2 = flag && CFGthunderPassiveLightning2.Value;
			thunderPassiveLightning3 = flag && CFGthunderPassiveLightning3.Value;
			thunderLightningLine2 = !flag || CFGthunderLightningLine2.Value;
			thunderLightningLine3 = !flag || CFGthunderLightningLine3.Value;
			thunderLightningLineInterval = (flag ? CFGthunderLightningLineInterval.Value : 10f);
			thunderLightningLineDelayMult = (flag ? CFGthunderLightningDelayMult.Value : 2f);
			thunderPulseFissures = (flag ? CFGthunderPulseFissures.Value : 6);
			thunderGeodeBarrier = (flag ? CFGthunderGeodeBarrier.Value : 0.25f);
			thunderGeodeHeal = (flag ? CFGthunderGeodeHeal.Value : 0f);
			thunderGeodeElite = !flag || CFGthunderGeodeElite.Value;
			thunderGeodeArmor = flag && CFGthunderGeodeArmor.Value;
			thunderGeodeHP = (flag ? CFGthunderGeodeHP.Value : 15);
			thunderGeodeGolems = !flag || CFGthunderGeodeGolems.Value;
			thunderGeodeGolemHP = (flag ? CFGthunderGeodeGolemHP.Value : 5);
			thunderSlamPatterns = !flag || CFGthunderSlamPatterns.Value;
			thunderSlamScatters = (flag ? CFGthunderSlamScatters.Value : 8);
			thunderSlamScatterDelay = (flag ? CFGthunderSlamScatterDelay.Value : 0.8f);
			thunderSlamWindupMult = (flag ? CFGthunderSlamWindupMult.Value : 1f);
			thunderSlamFissures = (flag ? CFGthunderSlamFissures.Value : 5);
			thunderDashParry = !flag || CFGthunderDashParry.Value;
			thunderDashParryDuration = (flag ? CFGthunderDashParryDuration.Value : 0.4f);
			thunderDashParryAll = flag && CFGthunderDashParryAll.Value;
			thunderDashWindup = (flag ? CFGthunderDashWindup.Value : 0.3f);
			thunderDashEnable = !flag || CFGthunderDashEnable.Value;
			thunderDashCooldown = (flag ? CFGthunderDashCooldown.Value : 6f);
			thunderOfferingSpeedMult = (flag ? CFGthunderOfferingSpeedMult.Value : 1.1f);
			thunderOfferingProjectiles = flag && CFGthunderOfferingProjectiles.Value;
			thunderOfferingStakes = !flag || CFGthunderOfferingStakes.Value;
			thunderCrystalCount = (flag ? CFGthunderCrystalCount.Value : 12);
			thunderCrystalShards = (flag ? CFGthunderCrystalShards.Value : 10);
			thunderCrystalFissures = ((!flag) ? 1 : CFGthunderCrystalFissures.Value);
			thunderLeapLightningPatterns = !flag || CFGthunderLeapLightningPatterns.Value;
			thunderLeapLightningMult = (flag ? CFGthunderLeapLightningMult.Value : 1f);
			thunderLeapDurationMult = (flag ? CFGthunderLeapDurationMult.Value : 1f);
			thunderLaserDuration = (flag ? CFGthunderLaserDuration.Value : 16f);
			thunderDevastatorOrbs = flag && CFGthunderDevastatorOrbs.Value;
			thunderShockwaveEnable = !flag || CFGthunderShockwaveEnable.Value;
			thunderShockwaveDelay = (flag ? CFGthunderShockwaveDelay.Value : 2.75f);
			thunderShockwaveDamage = (flag ? CFGthunderShockwaveDamage.Value : 2.5f);
			thunderShockwaveInterval = (flag ? CFGthunderShockwaveInterval.Value : 0.1f);
			thunderShockwaveCount = (flag ? CFGthunderShockwaveCount.Value : 5);
			eyeEnable = !flag || CFGeyeEnable.Value;
			eyeSharing = !flag || CFGeyeSharing.Value;
			eyeDamage = (flag ? CFGeyeDamage.Value : 20f);
			eyeLightningCount = (flag ? CFGeyeLightningCount.Value : 3);
			eyeLightningDamage = (flag ? CFGeyeLightningDamage.Value : 5f);
			eyeLightningDelay = (flag ? CFGeyeLightningDelay.Value : 0.5f);
			eyeLightningInterval = (flag ? CFGeyeLightningInterval.Value : 0.25f);
			eyeLightningRadius = (flag ? CFGeyeLightningRadius.Value : 6f);
			eyeLightningRange = (flag ? CFGeyeLightningRange.Value : 15f);
			auriEnable = !flag || CFGauriEnable.Value;
			auriRegen = (flag ? CFGauriRegen.Value : 0.004f);
			auriAdaptiveArmor = !flag || CFGauriAdaptiveArmor.Value;
			auriFixedSpawn = !flag || CFGauriFixedSpawn.Value;
			auriReducedStats = !flag || CFGauriReducedStats.Value;
			auriDamageMultFS = 0.75f;
			auriSpeedMultFS = 0.5f;
			auriBaseHP = (flag ? CFGauriBaseHP.Value : 2200f);
			auriLevelHP = (flag ? CFGauriLevelHP.Value : 900f);
			auriBaseArmor = (flag ? CFGauriBaseArmor.Value : 20f);
			auriLevelArmor = (flag ? CFGauriLevelArmor.Value : 0f);
			auriSwordEnable = !flag || CFGauriSwordEnable.Value;
			auriSwordDelay = (flag ? CFGauriSwordDelay.Value : 1.2f);
			auriSwordInterval = (flag ? CFGauriSwordInterval.Value : 0.3f);
			auriCrownEnable = !flag || CFGauriCrownEnable.Value;
			auriCrownLasers = (flag ? CFGauriCrownLasers.Value : 18);
			auriCrownLasersFS = (flag ? CFGauriCrownLasersFS.Value : 12);
			auriCrownSpinSpeed = (flag ? CFGauriCrownSpinSpeed.Value : 50f);
			auriCrownDuration = (flag ? CFGauriCrownDuration.Value : 10f);
			auriCrownDamage = (flag ? CFGauriCrownDamage.Value : 3f);
			auriCrownDamageDelay = (flag ? CFGauriCrownDamageDelay.Value : 1.5f);
			auriCrownBypassArmor = !flag || CFGauriCrownBypassArmor.Value;
			auriBeamEnable = !flag || CFGauriBeamEnable.Value;
			auriBeamFrequency = (flag ? CFGauriBeamFrequency.Value : 8f);
			auriBeamProjectileDamage = (flag ? CFGauriBeamProjectileDamage.Value : 1f);
			auriBeamProjectileSpeed = (flag ? CFGauriBeamProjectileSpeed.Value : 100f);
			auriBeamProjectileSpread = (flag ? CFGauriBeamProjectileSpread.Value : 15f);
			auriBeamProjectileAccuracy = (flag ? CFGauriBeamProjectileAccuracy.Value : 2f);
			auriBeamDuration = (flag ? CFGauriBeamDuration.Value : 3f);
			auriBeamDamage = (flag ? CFGauriBeamDamage.Value : 1.75f);
			auriBeamRadius = (flag ? CFGauriBeamRadius.Value : 3f);
			auriBeamForce = (flag ? CFGauriBeamForce.Value : 3500f);
			auriBeamIgnite = !flag || CFGauriBeamIgnite.Value;
			coastEnable = !flag || CFGcoastEnable.Value;
			coastSpawnTimer = (flag ? CFGcoastSpawnTimer.Value : 150f);
			coastSpawnReduction = (flag ? CFGcoastSpawnReduction.Value : 20f);
			coastBaseArmor = (flag ? CFGcoastBaseArmor.Value : 100f);
			coastBeaconArmor = (flag ? CFGcoastBeaconArmor.Value : 100f);
			coastBeaconTimer = (flag ? CFGcoastBeaconTimer.Value : 75);
			coastBeaconExtension = (flag ? CFGcoastBeaconExtension.Value : 15);
			coastGoldMult = (flag ? CFGcoastGoldMult.Value : 1f);
			coastBonusChest = !flag || CFGcoastBonusChest.Value;
			halcyonStages = (flag ? CFGhalcyonStages.Value : "village,habitat,helminthroost,hollowsummit_wormsworms,hollowsummitnight_wormsworms");
			halcyonStage5 = !flag || CFGhalcyonStage5.Value;
			halcyonChanceMult = (flag ? CFGhalcyonChanceMult.Value : 1.15f);
			meridianReduceLightning = !flag || CFGmeridianReduceLightning.Value;
			meridianSpawnMult = (flag ? CFGmeridianSpawnMult.Value : 0.2f);
			meridianMoneyMult = (flag ? CFGmeridianMoneyMult.Value : 0.4f);
			meridianGeodeSpawns = !flag || CFGmeridianGeodeSpawns.Value;
			meridianGeodeCredits = (flag ? CFGmeridianGeodeCredits.Value : 50f);
			meridianGeodeScaling = (flag ? CFGmeridianGeodeScaling.Value : 20f);
			voidGeodes = !flag || CFGvoidGeodes.Value;
			voidGeodeCount = (flag ? CFGvoidGeodeCount.Value : 3);
			if (voidGeodeCount > 9)
			{
				voidGeodeCount = 9;
			}
			voidLightIntensity = (flag ? CFGvoidLightIntensity.Value : 2f);
			voidLightRange = (flag ? CFGvoidLightRange.Value : 15f);
		}

		public static ConfigEntry<bool> RegisterConfigBool(ConfigFile cfg, string section, string key, bool defaultValue, string description, bool restart = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			ConfigEntry<bool> val = cfg.Bind<bool>(section, key, defaultValue, description);
			CheckBoxConfig val2 = new CheckBoxConfig();
			((BaseOptionConfig)val2).restartRequired = restart;
			object obj = <>O.<0>__CheckDisabled;
			if (obj == null)
			{
				IsDisabledDelegate val3 = CheckDisabled;
				<>O.<0>__CheckDisabled = val3;
				obj = (object)val3;
			}
			((BaseOptionConfig)val2).checkIfDisabled = (IsDisabledDelegate)obj;
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(val, val2));
			val.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			return val;
		}

		public static ConfigEntry<float> RegisterConfigFloat(ConfigFile cfg, string section, string key, float defaultValue, string description, float minValue, float maxValue, bool percent = false, bool restart = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			ConfigEntry<float> val = cfg.Bind<float>(section, key, defaultValue, description);
			SliderConfig val2 = new SliderConfig();
			val2.min = minValue;
			val2.max = maxValue;
			((BaseOptionConfig)val2).restartRequired = restart;
			object obj = <>O.<0>__CheckDisabled;
			if (obj == null)
			{
				IsDisabledDelegate val3 = CheckDisabled;
				<>O.<0>__CheckDisabled = val3;
				obj = (object)val3;
			}
			((BaseOptionConfig)val2).checkIfDisabled = (IsDisabledDelegate)obj;
			val2.FormatString = (percent ? "{0:0}%" : "{0}");
			ModSettingsManager.AddOption((BaseOption)new SliderOption(val, val2));
			val.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			return val;
		}

		public static ConfigEntry<int> RegisterConfigInt(ConfigFile cfg, string section, string key, int defaultValue, string description, int minValue, int maxValue, bool restart = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			ConfigEntry<int> val = cfg.Bind<int>(section, key, defaultValue, description);
			IntSliderConfig val2 = new IntSliderConfig();
			val2.min = minValue;
			val2.max = maxValue;
			((BaseOptionConfig)val2).restartRequired = restart;
			object obj = <>O.<0>__CheckDisabled;
			if (obj == null)
			{
				IsDisabledDelegate val3 = CheckDisabled;
				<>O.<0>__CheckDisabled = val3;
				obj = (object)val3;
			}
			((BaseOptionConfig)val2).checkIfDisabled = (IsDisabledDelegate)obj;
			ModSettingsManager.AddOption((BaseOption)new IntSliderOption(val, val2));
			val.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			return val;
		}

		public static ConfigEntry<string> RegisterConfigString(ConfigFile cfg, string section, string key, string defaultValue, string description, bool restart = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			ConfigEntry<string> val = cfg.Bind<string>(section, key, defaultValue, description);
			InputFieldConfig val2 = new InputFieldConfig();
			((BaseOptionConfig)val2).restartRequired = restart;
			object obj = <>O.<0>__CheckDisabled;
			if (obj == null)
			{
				IsDisabledDelegate val3 = CheckDisabled;
				<>O.<0>__CheckDisabled = val3;
				obj = (object)val3;
			}
			((BaseOptionConfig)val2).checkIfDisabled = (IsDisabledDelegate)obj;
			ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(val, val2));
			val.SettingChanged += delegate
			{
				UpdateConfigValues();
			};
			return val;
		}

		public static bool CheckDisabled()
		{
			if (enableConfigs != null)
			{
				return !enableConfigs.Value;
			}
			return true;
		}
	}
}
namespace StormboundFalseSon.Modules
{
	public static class Assets
	{
		public static AssetBundle mainBundle;

		public const string bundleName = "StormboundFalseSonAssetBundle.bundle";

		public const string assetBundleFolder = "assetbundles";

		public static string AssetBundlePath => Path.Combine(Path.GetDirectoryName(StormboundFalseSonPlugin.PInfo.Location), "StormboundFalseSonAssetBundle.bundle");

		public static void Init()
		{
			mainBundle = AssetBundle.LoadFromFile(AssetBundlePath);
		}
	}
	public static class Unlockables
	{
		internal static List<UnlockableDef> unlockableDefs = new List<UnlockableDef>();

		internal static void AddUnlockableDef(UnlockableDef unlockableDef)
		{
			unlockableDefs.Add(unlockableDef);
		}

		internal static UnlockableDef CreateAndAddUnlockbleDef(string identifier, string nameToken, Sprite achievementIcon)
		{
			UnlockableDef val = ScriptableObject.CreateInstance<UnlockableDef>();
			val.cachedName = identifier;
			val.nameToken = nameToken;
			val.achievementIcon = achievementIcon;
			val.sortScore = 200;
			val.hidden = true;
			AddUnlockableDef(val);
			return val;
		}
	}
	public static class States
	{
		internal static List<Type> entityStates = new List<Type>();

		internal static void RegisterStates()
		{
			entityStates.Add(typeof(FireGoldLaser));
			entityStates.Add(typeof(GeodeRegenerate));
		}
	}
	public static class DamageTypes
	{
		public static ModdedDamageType stormboundLightning = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundLunarRuin = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundLaser = DamageAPI.ReserveDamageType();

		public static ModdedDamageType aurelioniteLaser = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundLaserTargeting = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundLaserCrystal = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundDevastatorCrystal = DamageAPI.ReserveDamageType();

		public static ModdedDamageType stormboundEyeOfTheStormImmunity = DamageAPI.ReserveDamageType();
	}
	public static class Buffs
	{
		internal static List<BuffDef> buffDefs = new List<BuffDef>();

		internal static BuffDef AddNewBuff(string buffName, Sprite buffIcon, Color buffColor, bool canStack, bool isDebuff, bool isCooldown, bool isHidden, bool ignoreNectar)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			BuffDef val = ScriptableObject.CreateInstance<BuffDef>();
			((Object)val).name = buffName;
			val.buffColor = buffColor;
			val.canStack = canStack;
			val.isDebuff = isDebuff;
			val.eliteDef = null;
			val.iconSprite = buffIcon;
			val.isCooldown = isCooldown;
			val.isHidden = isHidden;
			val.ignoreGrowthNectar = ignoreNectar;
			buffDefs.Add(val);
			return val;
		}
	}
	public static class Effects
	{
		public static List<EffectDef> effectDefs = new List<EffectDef>();

		internal static void RegisterEffects()
		{
			FireGoldLaser.tracerEffectPrefab = CreateAurelioniteTracer();
			CoreChanges.lightningWarningEffect = CreateLightningWarning();
			Main.StormboundKnockbackManager.chargePrefab = CreateKnockbackWarning();
			FalseSonChanges.rainWarningPrefab = CreateRainWarning();
			FalseSonChanges.rainOverchargePrefab = CreateOverchargeWarning();
			FalseSonChanges.lunarSpikeExplosion = CreateCrystalExplosion();
			FalseSonChanges.StormboundHardModeController.shockwaveWarningPrefab = CreateShockwaveWarning();
			FalseSonChanges.fissureCirclePrefab = CreateFissureWarning();
			FalseSonChanges.warningPrefab = CreateEyeFlash();
		}

		private static GameObject CreateHalcyoniteTether()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			return CloneObject("RoR2/DLC2/Elites/EliteBead/EliteBeadTether.prefab", "StormboundTetherEffect", new Color(1f, 1f, 0f, 1f), new Color(1f, 1f, 0f, 1f), 1f, 1000f);
		}

		private static GameObject CreateCrystalExplosion()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CloneObject("RoR2/Base/Vagrant/VagrantTrackingBombExplosion.prefab", "StormboundCrystalExplosionEffect", new Color(1f, 0f, 0.4f, 1f), new Color(1f, 0f, 0.4f, 1f), 1f, 1000f, colorMesh: false, "", parentToTransform: false, recolor: false);
			val.GetComponent<EffectComponent>().applyScale = true;
			return val;
		}

		private static GameObject CreateOverchargeWarning()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CloneObject("RoR2/DLC2/FalseSonBoss/LunarRainExplosionWarningVFX.prefab", "StormboundOverchargeWarningEffect", new Color(1f, 0f, 0.25f, 1f), new Color(1f, 0f, 0.25f, 1f), 1f, 1000f);
			val.GetComponent<EffectComponent>().applyScale = true;
			DestroyOnParticleEnd component = val.GetComponent<DestroyOnParticleEnd>();
			if ((Object)(object)compo