using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Sadistic Company")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Sadistic Company")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b545d1b4-c426-4c7a-83de-3259a76823f5")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SadisticCompany;

[BepInPlugin("kviks.sadisticcompany", "Sadistic Company", "1.0.0")]
public class SadisticCompanyPlugin : BaseUnityPlugin
{
	internal static ManualLogSource Log;

	internal static bool DebugEnabled;

	internal static float FactorySizeMultiplier;

	internal static float DaySpeedMultiplier;

	internal static float InsidePowerMultiplier;

	internal static float OutsidePowerMultiplier;

	internal static float DaytimePowerMultiplier;

	internal static float InsideDiversityMultiplier;

	internal static float OutsideDiversityMultiplier;

	internal static float SpawnRangeBonus;

	internal static float DaytimeSpawnRangeBonus;

	internal static float HazardMultiplier;

	internal static float OutsidePropMultiplier;

	internal static float DoorLockTimeMultiplier;

	internal static float ExtraDoorLockChance;

	internal static float EnemyMaxCountMultiplier;

	internal static float EnemyDoorSpeedMultiplier;

	internal static float EnemyProbabilityMultiplier;

	internal static float EnemyPowerBudgetMultiplier;

	internal static float EnemyRarityMultiplier;

	internal static float EnemyStunTimeMultiplier;

	internal static float EnemyPushForceMultiplier;

	internal static float EnemyVentDelayMultiplier;

	internal static float EnemyNavSpeedMultiplier;

	internal static float EnemyNavAccelerationMultiplier;

	internal static float EnemyNavAngularSpeedMultiplier;

	internal static int EnemySpawnGroupBonus;

	internal static bool EnemiesIgnoreFog;

	internal static bool DisableEnemyStuns;

	internal static bool UseNamedEnemyBiases;

	internal static float PlayerDamageMultiplier;

	internal static float ScrapWeightMultiplier;

	internal static float ScrapWeightExtraCap;

	internal static float ScrapAmountMultiplier;

	internal static float ScrapValueMultiplier;

	internal static float BatteryLifeMultiplier;

	private static readonly HashSet<int> PatchedLevels = new HashSet<int>();

	private static readonly HashSet<int> PatchedEnemies = new HashSet<int>();

	private static readonly HashSet<int> PatchedItems = new HashSet<int>();

	private static readonly HashSet<int> PatchedEnemyInstances = new HashSet<int>();

	private static Harmony _harmony;

	private ConfigEntry<bool> _debug;

	private ConfigEntry<float> _factorySizeMultiplier;

	private ConfigEntry<float> _daySpeedMultiplier;

	private ConfigEntry<float> _insidePowerMultiplier;

	private ConfigEntry<float> _outsidePowerMultiplier;

	private ConfigEntry<float> _daytimePowerMultiplier;

	private ConfigEntry<float> _insideDiversityMultiplier;

	private ConfigEntry<float> _outsideDiversityMultiplier;

	private ConfigEntry<float> _spawnRangeBonus;

	private ConfigEntry<float> _daytimeSpawnRangeBonus;

	private ConfigEntry<float> _hazardMultiplier;

	private ConfigEntry<float> _outsidePropMultiplier;

	private ConfigEntry<float> _doorLockTimeMultiplier;

	private ConfigEntry<float> _extraDoorLockChance;

	private ConfigEntry<float> _enemyMaxCountMultiplier;

	private ConfigEntry<float> _enemyDoorSpeedMultiplier;

	private ConfigEntry<float> _enemyProbabilityMultiplier;

	private ConfigEntry<float> _enemyPowerBudgetMultiplier;

	private ConfigEntry<float> _enemyRarityMultiplier;

	private ConfigEntry<float> _enemyStunTimeMultiplier;

	private ConfigEntry<float> _enemyPushForceMultiplier;

	private ConfigEntry<float> _enemyVentDelayMultiplier;

	private ConfigEntry<float> _enemyNavSpeedMultiplier;

	private ConfigEntry<float> _enemyNavAccelerationMultiplier;

	private ConfigEntry<float> _enemyNavAngularSpeedMultiplier;

	private ConfigEntry<int> _enemySpawnGroupBonus;

	private ConfigEntry<bool> _enemiesIgnoreFog;

	private ConfigEntry<bool> _disableEnemyStuns;

	private ConfigEntry<bool> _useNamedEnemyBiases;

	private ConfigEntry<float> _playerDamageMultiplier;

	private ConfigEntry<float> _scrapWeightMultiplier;

	private ConfigEntry<float> _scrapWeightExtraCap;

	private ConfigEntry<float> _scrapAmountMultiplier;

	private ConfigEntry<float> _scrapValueMultiplier;

	private ConfigEntry<float> _batteryLifeMultiplier;

	private void Awake()
	{
		//IL_051a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0524: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		_debug = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableDebugLogging", false, "Enables debug logging.");
		_factorySizeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Level", "FactorySizeMultiplier", 1.55f, "Bigger factory generation.");
		_daySpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Level", "DaySpeedMultiplier", 1.45f, "Higher means the day moves faster.");
		_insidePowerMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "InsidePowerMultiplier", 2.8f, "Multiplies inside enemy power budget.");
		_outsidePowerMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "OutsidePowerMultiplier", 2.35f, "Multiplies outside enemy power budget.");
		_daytimePowerMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "DaytimePowerMultiplier", 2.1f, "Multiplies daytime enemy power budget.");
		_insideDiversityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "InsideDiversityMultiplier", 1.9f, "Multiplies inside diversity budget.");
		_outsideDiversityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "OutsideDiversityMultiplier", 1.75f, "Multiplies outside diversity budget.");
		_spawnRangeBonus = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "InsideSpawnRangeBonus", 5f, "Adds to level spawnProbabilityRange.");
		_daytimeSpawnRangeBonus = ((BaseUnityPlugin)this).Config.Bind<float>("Spawns", "DaytimeSpawnRangeBonus", 12f, "Adds to daytimeEnemiesProbabilityRange.");
		_hazardMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Map", "IndoorHazardMultiplier", 2.8f, "Multiplies indoor hazard counts.");
		_outsidePropMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Map", "OutsidePropMultiplier", 2.2f, "Multiplies outside hazard or object counts.");
		_doorLockTimeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Map", "DoorLockTimeMultiplier", 2.25f, "Higher locked-door pick time.");
		_extraDoorLockChance = ((BaseUnityPlugin)this).Config.Bind<float>("Map", "ExtraDoorLockChance", 0.58f, "Chance to lock additional lockable doors after vanilla setup.");
		_enemyMaxCountMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyMaxCountMultiplier", 2.2f, "Higher per-enemy max count.");
		_enemyDoorSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyDoorSpeedMultiplier", 1.65f, "Enemies open doors faster.");
		_enemyProbabilityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyProbabilityMultiplier", 1.45f, "Multiplies enemy probability curves.");
		_enemyPowerBudgetMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyPowerLevelMultiplier", 0.72f, "Lower values let more enemies fit into the power budget.");
		_enemyRarityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyRarityMultiplier", 1.45f, "Multiplies spawn rarity in level enemy lists.");
		_enemyStunTimeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyStunTimeMultiplier", 0.55f, "Lower means enemies recover from stun faster.");
		_enemyPushForceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyPushForceMultiplier", 1.35f, "Higher push force and distance from enemies.");
		_enemyVentDelayMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyVentDelayMultiplier", 0.7f, "Lower means less warning before vent audio and spawn pressure.");
		_enemyNavSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyNavSpeedMultiplier", 1.18f, "Multiplies spawned enemy nav speed.");
		_enemyNavAccelerationMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyNavAccelerationMultiplier", 1.25f, "Multiplies spawned enemy nav acceleration.");
		_enemyNavAngularSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "EnemyNavAngularSpeedMultiplier", 1.18f, "Multiplies spawned enemy turn speed.");
		_enemySpawnGroupBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Enemies", "EnemySpawnGroupBonus", 1, "Adds to spawnInGroupsOf where applicable.");
		_enemiesIgnoreFog = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemies", "EnemiesIgnoreFog", true, "Enemies can see through fog.");
		_disableEnemyStuns = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemies", "DisableEnemyStuns", false, "Enemies cannot be stunned.");
		_useNamedEnemyBiases = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemies", "UseNamedEnemyBiases", true, "Extra buffs for iconic high-threat enemies.");
		_playerDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Player", "DamageTakenMultiplier", 1.35f, "All received damage multiplier.");
		_scrapWeightMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Rewards", "ExtraScrapBurdenMultiplier", 1.08f, "Only scales the weight above vanilla baseline so light scrap stays light.");
		_scrapWeightExtraCap = ((BaseUnityPlugin)this).Config.Bind<float>("Rewards", "ExtraScrapBurdenCap", 0.3f, "Maximum added weight above vanilla baseline.");
		_scrapAmountMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Rewards", "ScrapAmountMultiplier", 1.3f, "Higher means more scrap spawns in the level.");
		_scrapValueMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Rewards", "ScrapValueMultiplier", 1.4f, "Higher means scrap rolls more cash value.");
		_batteryLifeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Player", "BatteryLifeMultiplier", 0.75f, "Lower means batteries drain faster.");
		ApplyConfig();
		HookConfig();
		_harmony = new Harmony("kviks.sadisticcompany");
		_harmony.PatchAll();
		if (DebugEnabled)
		{
			Log.LogInfo((object)"[SC] Loaded risk/reward balanced preset.");
		}
	}

	private void ApplyConfig()
	{
		DebugEnabled = _debug.Value;
		FactorySizeMultiplier = Mathf.Max(1f, _factorySizeMultiplier.Value);
		DaySpeedMultiplier = Mathf.Max(0.5f, _daySpeedMultiplier.Value);
		InsidePowerMultiplier = Mathf.Max(1f, _insidePowerMultiplier.Value);
		OutsidePowerMultiplier = Mathf.Max(1f, _outsidePowerMultiplier.Value);
		DaytimePowerMultiplier = Mathf.Max(1f, _daytimePowerMultiplier.Value);
		InsideDiversityMultiplier = Mathf.Max(1f, _insideDiversityMultiplier.Value);
		OutsideDiversityMultiplier = Mathf.Max(1f, _outsideDiversityMultiplier.Value);
		SpawnRangeBonus = Mathf.Max(0f, _spawnRangeBonus.Value);
		DaytimeSpawnRangeBonus = Mathf.Max(0f, _daytimeSpawnRangeBonus.Value);
		HazardMultiplier = Mathf.Max(1f, _hazardMultiplier.Value);
		OutsidePropMultiplier = Mathf.Max(1f, _outsidePropMultiplier.Value);
		DoorLockTimeMultiplier = Mathf.Max(1f, _doorLockTimeMultiplier.Value);
		ExtraDoorLockChance = Mathf.Clamp01(_extraDoorLockChance.Value);
		EnemyMaxCountMultiplier = Mathf.Max(1f, _enemyMaxCountMultiplier.Value);
		EnemyDoorSpeedMultiplier = Mathf.Max(1f, _enemyDoorSpeedMultiplier.Value);
		EnemyProbabilityMultiplier = Mathf.Max(1f, _enemyProbabilityMultiplier.Value);
		EnemyPowerBudgetMultiplier = Mathf.Clamp(_enemyPowerBudgetMultiplier.Value, 0.2f, 2f);
		EnemyRarityMultiplier = Mathf.Max(1f, _enemyRarityMultiplier.Value);
		EnemyStunTimeMultiplier = Mathf.Clamp(_enemyStunTimeMultiplier.Value, 0.1f, 3f);
		EnemyPushForceMultiplier = Mathf.Max(1f, _enemyPushForceMultiplier.Value);
		EnemyVentDelayMultiplier = Mathf.Clamp(_enemyVentDelayMultiplier.Value, 0.1f, 2f);
		EnemyNavSpeedMultiplier = Mathf.Max(1f, _enemyNavSpeedMultiplier.Value);
		EnemyNavAccelerationMultiplier = Mathf.Max(1f, _enemyNavAccelerationMultiplier.Value);
		EnemyNavAngularSpeedMultiplier = Mathf.Max(1f, _enemyNavAngularSpeedMultiplier.Value);
		EnemySpawnGroupBonus = Mathf.Clamp(_enemySpawnGroupBonus.Value, 0, 5);
		EnemiesIgnoreFog = _enemiesIgnoreFog.Value;
		DisableEnemyStuns = _disableEnemyStuns.Value;
		UseNamedEnemyBiases = _useNamedEnemyBiases.Value;
		PlayerDamageMultiplier = Mathf.Max(1f, _playerDamageMultiplier.Value);
		ScrapWeightMultiplier = Mathf.Clamp(_scrapWeightMultiplier.Value, 1f, 1.5f);
		ScrapWeightExtraCap = Mathf.Clamp(_scrapWeightExtraCap.Value, 0f, 0.5f);
		ScrapAmountMultiplier = Mathf.Clamp(_scrapAmountMultiplier.Value, 1f, 4f);
		ScrapValueMultiplier = Mathf.Clamp(_scrapValueMultiplier.Value, 1f, 4f);
		BatteryLifeMultiplier = Mathf.Clamp(_batteryLifeMultiplier.Value, 0.1f, 1f);
	}

	private void HookConfig()
	{
		_debug.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_factorySizeMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_daySpeedMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_insidePowerMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_outsidePowerMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_daytimePowerMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_insideDiversityMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_outsideDiversityMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_spawnRangeBonus.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_daytimeSpawnRangeBonus.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_hazardMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_outsidePropMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_doorLockTimeMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_extraDoorLockChance.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyMaxCountMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyDoorSpeedMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyProbabilityMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyPowerBudgetMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyRarityMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyStunTimeMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyPushForceMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyVentDelayMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyNavSpeedMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyNavAccelerationMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemyNavAngularSpeedMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemySpawnGroupBonus.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_enemiesIgnoreFog.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_disableEnemyStuns.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_useNamedEnemyBiases.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_playerDamageMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_scrapWeightMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_scrapWeightExtraCap.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_scrapAmountMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_scrapValueMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
		_batteryLifeMultiplier.SettingChanged += delegate
		{
			ApplyConfig();
		};
	}

	internal static void TuneItems(StartOfRound startOfRound)
	{
		if (!((Object)(object)startOfRound == (Object)null) && !((Object)(object)startOfRound.allItemsList == (Object)null) && startOfRound.allItemsList.itemsList != null)
		{
			for (int i = 0; i < startOfRound.allItemsList.itemsList.Count; i++)
			{
				TuneItem(startOfRound.allItemsList.itemsList[i]);
			}
		}
	}

	internal static void TuneLevel(SelectableLevel level)
	{
		if ((Object)(object)level == (Object)null)
		{
			return;
		}
		int instanceID = ((Object)level).GetInstanceID();
		if (!PatchedLevels.Add(instanceID))
		{
			return;
		}
		level.factorySizeMultiplier *= FactorySizeMultiplier;
		level.DaySpeedMultiplier *= DaySpeedMultiplier;
		level.maxEnemyPowerCount = Mathf.Max(1, Mathf.RoundToInt((float)level.maxEnemyPowerCount * InsidePowerMultiplier));
		level.maxOutsideEnemyPowerCount = Mathf.Max(1, Mathf.RoundToInt((float)level.maxOutsideEnemyPowerCount * OutsidePowerMultiplier));
		level.maxDaytimeEnemyPowerCount = Mathf.Max(1, Mathf.RoundToInt((float)level.maxDaytimeEnemyPowerCount * DaytimePowerMultiplier));
		level.maxInsideDiversityPowerCount = Mathf.Max(1, Mathf.RoundToInt((float)level.maxInsideDiversityPowerCount * InsideDiversityMultiplier));
		level.maxOutsideDiversityPowerCount = Mathf.Max(1, Mathf.RoundToInt((float)level.maxOutsideDiversityPowerCount * OutsideDiversityMultiplier));
		level.spawnProbabilityRange += SpawnRangeBonus;
		level.daytimeEnemiesProbabilityRange += DaytimeSpawnRangeBonus;
		level.minScrap = Mathf.Max(0, Mathf.RoundToInt((float)level.minScrap * ScrapAmountMultiplier));
		level.maxScrap = Mathf.Max(level.minScrap + 1, Mathf.RoundToInt((float)level.maxScrap * ScrapAmountMultiplier));
		if (level.enemySpawnChanceThroughoutDay != null)
		{
			level.enemySpawnChanceThroughoutDay = ScaleCurve(level.enemySpawnChanceThroughoutDay, 1.45f, 0f, 0f, 40f);
		}
		if (level.outsideEnemySpawnChanceThroughDay != null)
		{
			level.outsideEnemySpawnChanceThroughDay = ScaleCurve(level.outsideEnemySpawnChanceThroughDay, 1.35f, 0f, 0f, 40f);
		}
		if (level.daytimeEnemySpawnChanceThroughDay != null)
		{
			level.daytimeEnemySpawnChanceThroughDay = ScaleCurve(level.daytimeEnemySpawnChanceThroughDay, 1.3f, 0f, 0f, 40f);
		}
		if (level.indoorMapHazards != null)
		{
			for (int i = 0; i < level.indoorMapHazards.Length; i++)
			{
				if (level.indoorMapHazards[i] != null && level.indoorMapHazards[i].numberToSpawn != null)
				{
					level.indoorMapHazards[i].numberToSpawn = ScaleCurve(level.indoorMapHazards[i].numberToSpawn, HazardMultiplier, 0f, 0f, 200f);
				}
			}
		}
		if (level.spawnableOutsideObjects != null)
		{
			for (int j = 0; j < level.spawnableOutsideObjects.Length; j++)
			{
				if (level.spawnableOutsideObjects[j] != null && level.spawnableOutsideObjects[j].randomAmount != null)
				{
					level.spawnableOutsideObjects[j].randomAmount = ScaleCurve(level.spawnableOutsideObjects[j].randomAmount, OutsidePropMultiplier, 0f, 0f, 200f);
				}
			}
		}
		TuneEnemyList(level.Enemies);
		TuneEnemyList(level.OutsideEnemies);
		TuneEnemyList(level.DaytimeEnemies);
		if (DebugEnabled)
		{
			Log.LogInfo((object)("[SC] Tuned level " + level.PlanetName));
		}
	}

	internal static void ApplyRoundBudgets(RoundManager roundManager)
	{
		if (!((Object)(object)roundManager == (Object)null))
		{
			roundManager.currentMaxInsidePower = Mathf.Max(roundManager.currentMaxInsidePower, roundManager.currentMaxInsidePower * InsidePowerMultiplier);
			roundManager.currentMaxOutsidePower = Mathf.Max(roundManager.currentMaxOutsidePower, roundManager.currentMaxOutsidePower * OutsidePowerMultiplier);
			roundManager.currentMaxInsideDiversityLevel = Mathf.Max(roundManager.currentMaxInsideDiversityLevel, Mathf.RoundToInt((float)roundManager.currentMaxInsideDiversityLevel * InsideDiversityMultiplier));
			roundManager.currentMaxOutsideDiversityLevel = Mathf.Max(roundManager.currentMaxOutsideDiversityLevel, Mathf.RoundToInt((float)roundManager.currentMaxOutsideDiversityLevel * OutsideDiversityMultiplier));
			roundManager.scrapAmountMultiplier = Mathf.Max(roundManager.scrapAmountMultiplier, ScrapAmountMultiplier);
			roundManager.scrapValueMultiplier = Mathf.Max(roundManager.scrapValueMultiplier, ScrapValueMultiplier);
			roundManager.minEnemiesToSpawn = Mathf.Max(roundManager.minEnemiesToSpawn, 2);
		}
	}

	internal static void InflateExtraDoorLocks(Vector3 mainEntrancePosition)
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if (ExtraDoorLockChance <= 0f || (Object)(object)StartOfRound.Instance == (Object)null)
		{
			return;
		}
		Random random = new Random(StartOfRound.Instance.randomMapSeed + 9124);
		DoorLock[] array = Object.FindObjectsOfType<DoorLock>();
		if (array == null || array.Length == 0)
		{
			return;
		}
		foreach (DoorLock val in array)
		{
			if (!((Object)(object)val == (Object)null) && !val.isLocked && val.canBeLocked && !(((Component)val).transform.position.y > -160f) && (!(mainEntrancePosition != Vector3.zero) || !(Vector3.Distance(mainEntrancePosition, ((Component)val).transform.position) < 18f)) && !(random.NextDouble() > (double)ExtraDoorLockChance))
			{
				float num = Mathf.Clamp(24f + (float)random.NextDouble() * 55f, 10f, 120f);
				val.LockDoor(num);
			}
		}
	}

	internal static void TuneEnemyInstance(EnemyAI enemy)
	{
		if ((Object)(object)enemy == (Object)null)
		{
			return;
		}
		int instanceID = ((Object)enemy).GetInstanceID();
		if (PatchedEnemyInstances.Add(instanceID))
		{
			float num = EnemyNavSpeedMultiplier;
			if (UseNamedEnemyBiases && (Object)(object)enemy.enemyType != (Object)null)
			{
				num *= GetNamedEnemyNavBias(enemy.enemyType);
			}
			enemy.openDoorSpeedMultiplier *= EnemyDoorSpeedMultiplier;
			if ((Object)(object)enemy.agent != (Object)null)
			{
				NavMeshAgent agent = enemy.agent;
				agent.speed *= num;
				NavMeshAgent agent2 = enemy.agent;
				agent2.acceleration *= EnemyNavAccelerationMultiplier;
				NavMeshAgent agent3 = enemy.agent;
				agent3.angularSpeed *= EnemyNavAngularSpeedMultiplier;
			}
		}
	}

	private static void TuneEnemyList(List<SpawnableEnemyWithRarity> enemies)
	{
		if (enemies == null)
		{
			return;
		}
		for (int i = 0; i < enemies.Count; i++)
		{
			SpawnableEnemyWithRarity val = enemies[i];
			if (val != null && !((Object)(object)val.enemyType == (Object)null))
			{
				val.rarity = Mathf.Clamp(Mathf.RoundToInt((float)val.rarity * EnemyRarityMultiplier), 1, 999);
				TuneEnemy(val.enemyType);
			}
		}
	}

	private static void TuneEnemy(EnemyType enemy)
	{
		int instanceID = ((Object)enemy).GetInstanceID();
		if (PatchedEnemies.Add(instanceID))
		{
			float maxCountMultiplier = EnemyMaxCountMultiplier;
			float powerBudgetMultiplier = EnemyPowerBudgetMultiplier;
			float probabilityMultiplier = EnemyProbabilityMultiplier;
			float doorSpeedMultiplier = EnemyDoorSpeedMultiplier;
			float navSpeedMultiplier = EnemyNavSpeedMultiplier;
			int spawnGroupBonus = EnemySpawnGroupBonus;
			if (UseNamedEnemyBiases)
			{
				ApplyNamedEnemyBiases(enemy, ref maxCountMultiplier, ref powerBudgetMultiplier, ref probabilityMultiplier, ref doorSpeedMultiplier, ref navSpeedMultiplier, ref spawnGroupBonus);
			}
			enemy.MaxCount = Mathf.Clamp(Mathf.RoundToInt((float)enemy.MaxCount * maxCountMultiplier), 1, 64);
			enemy.PowerLevel = Mathf.Clamp(enemy.PowerLevel * powerBudgetMultiplier, 0.05f, 100f);
			enemy.doorSpeedMultiplier *= doorSpeedMultiplier;
			enemy.stunTimeMultiplier = Mathf.Clamp(enemy.stunTimeMultiplier * EnemyStunTimeMultiplier, 0.1f, 10f);
			enemy.pushPlayerForce *= EnemyPushForceMultiplier;
			enemy.pushPlayerDistance *= Mathf.Lerp(1f, EnemyPushForceMultiplier, 0.5f);
			enemy.timeToPlayAudio = Mathf.Clamp(enemy.timeToPlayAudio * EnemyVentDelayMultiplier, 1f, 60f);
			enemy.canSeeThroughFog = enemy.canSeeThroughFog || EnemiesIgnoreFog;
			enemy.canBeStunned = !DisableEnemyStuns && enemy.canBeStunned;
			if (enemy.spawnInGroupsOf > 0)
			{
				enemy.spawnInGroupsOf = Mathf.Clamp(enemy.spawnInGroupsOf + spawnGroupBonus, 1, 8);
			}
			if (enemy.probabilityCurve != null)
			{
				enemy.probabilityCurve = ScaleCurve(enemy.probabilityCurve, probabilityMultiplier, 0f, 0f, 200f);
			}
			if (enemy.useNumberSpawnedFalloff && enemy.numberSpawnedFalloff != null)
			{
				enemy.numberSpawnedFalloff = ScaleCurve(enemy.numberSpawnedFalloff, 1.2f, 0f, 0f, 200f);
			}
			enemy.nestsSpawned = 0;
			enemy.numberSpawned = 0;
			enemy.hasSpawnedAtLeastOne = false;
		}
	}

	private static float GetNamedEnemyNavBias(EnemyType enemy)
	{
		string text = ((enemy.enemyName == null) ? string.Empty : enemy.enemyName.ToLowerInvariant());
		if (text.Contains("thumper") || text.Contains("crawler") || text.Contains("spider") || text.Contains("centipede"))
		{
			return 1.15f;
		}
		if (text.Contains("forest") || text.Contains("keeper") || text.Contains("dog") || text.Contains("baboon") || text.Contains("hawk"))
		{
			return 1.12f;
		}
		if (text.Contains("coil") || text.Contains("head") || text.Contains("bracken") || text.Contains("masked"))
		{
			return 1.08f;
		}
		return 1f;
	}

	private static void ApplyNamedEnemyBiases(EnemyType enemy, ref float maxCountMultiplier, ref float powerBudgetMultiplier, ref float probabilityMultiplier, ref float doorSpeedMultiplier, ref float navSpeedMultiplier, ref int spawnGroupBonus)
	{
		string text = ((enemy.enemyName == null) ? string.Empty : enemy.enemyName.ToLowerInvariant());
		if (text.Contains("jester") || text.Contains("girl") || text.Contains("dress") || text.Contains("ghost"))
		{
			maxCountMultiplier *= 1.25f;
			powerBudgetMultiplier *= 0.85f;
			probabilityMultiplier *= 1.2f;
		}
		if (text.Contains("coil") || text.Contains("head") || text.Contains("bracken") || text.Contains("masked"))
		{
			maxCountMultiplier *= 1.2f;
			powerBudgetMultiplier *= 0.82f;
			probabilityMultiplier *= 1.15f;
			doorSpeedMultiplier *= 1.15f;
			navSpeedMultiplier *= 1.08f;
		}
		if (text.Contains("thumper") || text.Contains("crawler") || text.Contains("spider") || text.Contains("centipede"))
		{
			maxCountMultiplier *= 1.15f;
			powerBudgetMultiplier *= 0.84f;
			probabilityMultiplier *= 1.18f;
			navSpeedMultiplier *= 1.15f;
		}
		if (text.Contains("forest") || text.Contains("keeper") || text.Contains("dog") || text.Contains("baboon") || text.Contains("hawk"))
		{
			maxCountMultiplier *= 1.2f;
			powerBudgetMultiplier *= 0.8f;
			probabilityMultiplier *= 1.2f;
			navSpeedMultiplier *= 1.12f;
			spawnGroupBonus++;
		}
	}

	private static void TuneItem(Item item)
	{
		if ((Object)(object)item == (Object)null)
		{
			return;
		}
		int instanceID = ((Object)item).GetInstanceID();
		if (PatchedItems.Add(instanceID))
		{
			if (item.isScrap)
			{
				float num = 1f;
				float num2 = Mathf.Max(0f, item.weight - num);
				float num3 = Mathf.Min(num2 * (ScrapWeightMultiplier - 1f), ScrapWeightExtraCap);
				item.weight = num + num2 + num3;
			}
			if (item.requiresBattery)
			{
				item.batteryUsage = Mathf.Clamp(item.batteryUsage * BatteryLifeMultiplier, 0.1f, 999f);
			}
		}
	}

	private static AnimationCurve ScaleCurve(AnimationCurve source, float valueMultiplier, float valueOffset, float minValue, float maxValue)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		if (source == null)
		{
			return null;
		}
		Keyframe[] keys = source.keys;
		for (int i = 0; i < keys.Length; i++)
		{
			Keyframe val = keys[i];
			((Keyframe)(ref val)).value = Mathf.Clamp(((Keyframe)(ref val)).value * valueMultiplier + valueOffset, minValue, maxValue);
			((Keyframe)(ref val)).inTangent = ((Keyframe)(ref val)).inTangent * valueMultiplier;
			((Keyframe)(ref val)).outTangent = ((Keyframe)(ref val)).outTangent * valueMultiplier;
			keys[i] = val;
		}
		return new AnimationCurve(keys)
		{
			preWrapMode = source.preWrapMode,
			postWrapMode = source.postWrapMode
		};
	}
}
[HarmonyPatch]
internal static class SadisticCompanyPatches
{
	[HarmonyPatch(typeof(StartOfRound), "Awake")]
	[HarmonyPostfix]
	private static void StartOfRoundAwakePostfix(StartOfRound __instance)
	{
		SadisticCompanyPlugin.TuneItems(__instance);
	}

	[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
	[HarmonyPostfix]
	private static void LoadNewLevelPostfix(RoundManager __instance, SelectableLevel newLevel)
	{
		SadisticCompanyPlugin.TuneLevel(newLevel ?? __instance.currentLevel);
	}

	[HarmonyPatch(typeof(RoundManager), "RefreshEnemiesList")]
	[HarmonyPostfix]
	private static void RefreshEnemiesListPostfix(RoundManager __instance)
	{
		SadisticCompanyPlugin.ApplyRoundBudgets(__instance);
	}

	[HarmonyPatch(typeof(RoundManager), "SetLockedDoors")]
	[HarmonyPostfix]
	private static void SetLockedDoorsPostfix(Vector3 mainEntrancePosition)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		SadisticCompanyPlugin.InflateExtraDoorLocks(mainEntrancePosition);
	}

	[HarmonyPatch(typeof(DoorLock), "LockDoor")]
	[HarmonyPrefix]
	private static void LockDoorPrefix(ref float timeToLockPick)
	{
		timeToLockPick = Mathf.Clamp(timeToLockPick * SadisticCompanyPlugin.DoorLockTimeMultiplier, 2f, 240f);
	}

	[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
	[HarmonyPrefix]
	private static void DamagePlayerPrefix(ref int damageNumber)
	{
		damageNumber = Mathf.Max(1, Mathf.RoundToInt((float)damageNumber * SadisticCompanyPlugin.PlayerDamageMultiplier));
	}

	[HarmonyPatch(typeof(EnemyAI), "Start")]
	[HarmonyPostfix]
	private static void EnemyStartPostfix(EnemyAI __instance)
	{
		SadisticCompanyPlugin.TuneEnemyInstance(__instance);
	}
}