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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("DangerousEnemies.SMALLEdition")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DangerousEnemies.SMALLEdition")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d65d0009-4513-4664-9cfb-9cfc9f1c3f45")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("gabdao.dangerousenemies.SMALLedition", "DangerousEnemies SMALL Edition", "1.0.0")]
public class DangerousEnemiesSMALLEditionPlugin : BaseUnityPlugin
{
	public static ConfigEntry<bool> EnableDebugLogging;

	public static ConfigEntry<float> GreylingCircleInterval;

	public static ConfigEntry<float> GreylingCircleDuration;

	public static ConfigEntry<float> GreylingCircleDistance;

	public static ConfigEntry<float> GreylingAttackIntervalMin;

	public static ConfigEntry<float> GreylingAttackIntervalMax;

	public static ConfigEntry<float> GreydwarfCircleInterval;

	public static ConfigEntry<float> GreydwarfCircleDuration;

	public static ConfigEntry<float> GreydwarfCircleDistance;

	public static ConfigEntry<float> GreydwarfAttackIntervalMin;

	public static ConfigEntry<float> GreydwarfAttackIntervalMax;

	public static ConfigEntry<float> GreydwarfBruteCircleInterval;

	public static ConfigEntry<float> GreydwarfBruteCircleDuration;

	public static ConfigEntry<float> GreydwarfBruteCircleDistance;

	public static ConfigEntry<float> GreydwarfBruteAttackIntervalMin;

	public static ConfigEntry<float> GreydwarfBruteAttackIntervalMax;

	public static ConfigEntry<float> GreydwarfShamanCircleInterval;

	public static ConfigEntry<float> GreydwarfShamanCircleDuration;

	public static ConfigEntry<float> GreydwarfShamanCircleDistance;

	public static ConfigEntry<float> GreydwarfShamanAttackIntervalMin;

	public static ConfigEntry<float> GreydwarfShamanAttackIntervalMax;

	public static ConfigEntry<float> BoarCircleInterval;

	public static ConfigEntry<float> BoarCircleDuration;

	public static ConfigEntry<float> BoarCircleDistance;

	public static ConfigEntry<float> BoarAttackIntervalMin;

	public static ConfigEntry<float> BoarAttackIntervalMax;

	public static ConfigEntry<float> NeckCircleInterval;

	public static ConfigEntry<float> NeckCircleDuration;

	public static ConfigEntry<float> NeckCircleDistance;

	public static ConfigEntry<float> NeckAttackIntervalMin;

	public static ConfigEntry<float> NeckAttackIntervalMax;

	public static ConfigEntry<float> SkeletonCircleInterval;

	public static ConfigEntry<float> SkeletonCircleDuration;

	public static ConfigEntry<float> SkeletonCircleDistance;

	public static ConfigEntry<float> SkeletonAttackIntervalMin;

	public static ConfigEntry<float> SkeletonAttackIntervalMax;

	public static ConfigEntry<float> DraugrCircleInterval;

	public static ConfigEntry<float> DraugrCircleDuration;

	public static ConfigEntry<float> DraugrCircleDistance;

	public static ConfigEntry<float> DraugrAttackIntervalMin;

	public static ConfigEntry<float> DraugrAttackIntervalMax;

	public static ConfigEntry<float> HatchlingCircleInterval;

	public static ConfigEntry<float> HatchlingCircleDuration;

	public static ConfigEntry<float> HatchlingCircleDistance;

	public static ConfigEntry<float> HatchlingAttackIntervalMin;

	public static ConfigEntry<float> HatchlingAttackIntervalMax;

	public static ConfigEntry<float> GoblinCircleInterval;

	public static ConfigEntry<float> GoblinCircleDuration;

	public static ConfigEntry<float> GoblinCircleDistance;

	public static ConfigEntry<float> GoblinAttackIntervalMin;

	public static ConfigEntry<float> GoblinAttackIntervalMax;

	public static ConfigEntry<float> GoblinShamanCircleInterval;

	public static ConfigEntry<float> GoblinShamanCircleDuration;

	public static ConfigEntry<float> GoblinShamanCircleDistance;

	public static ConfigEntry<float> UlvCircleInterval;

	public static ConfigEntry<float> UlvCircleDuration;

	public static ConfigEntry<float> UlvCircleDistance;

	public static ConfigEntry<float> UlvAttackIntervalMin;

	public static ConfigEntry<float> UlvAttackIntervalMax;

	public static ConfigEntry<float> WraithCircleInterval;

	public static ConfigEntry<float> WraithCircleDuration;

	public static ConfigEntry<float> WraithCircleDistance;

	public static ConfigEntry<float> WraithAttackIntervalMin;

	public static ConfigEntry<float> WraithAttackIntervalMax;

	public static ConfigEntry<float> SurtlingCircleInterval;

	public static ConfigEntry<float> SurtlingCircleDuration;

	public static ConfigEntry<float> SurtlingCircleDistance;

	public static ConfigEntry<float> SurtlingAttackIntervalMin;

	public static ConfigEntry<float> SurtlingAttackIntervalMax;

	public static ConfigEntry<float> BlobCircleInterval;

	public static ConfigEntry<float> BlobCircleDuration;

	public static ConfigEntry<float> BlobCircleDistance;

	public static ConfigEntry<float> BlobAttackIntervalMin;

	public static ConfigEntry<float> BlobAttackIntervalMax;

	public static ConfigEntry<float> BlobEliteCircleInterval;

	public static ConfigEntry<float> BlobEliteCircleDuration;

	public static ConfigEntry<float> BlobEliteCircleDistance;

	public static ConfigEntry<float> BlobEliteAttackIntervalMin;

	public static ConfigEntry<float> BlobEliteAttackIntervalMax;

	public static ConfigEntry<float> BlobTarCircleInterval;

	public static ConfigEntry<float> BlobTarCircleDuration;

	public static ConfigEntry<float> BlobTarCircleDistance;

	public static ConfigEntry<float> BlobTarAttackIntervalMin;

	public static ConfigEntry<float> BlobTarAttackIntervalMax;

	public static ConfigEntry<float> BlobLavaCircleInterval;

	public static ConfigEntry<float> BlobLavaCircleDuration;

	public static ConfigEntry<float> BlobLavaCircleDistance;

	public static ConfigEntry<float> BlobLavaAttackIntervalMin;

	public static ConfigEntry<float> BlobLavaAttackIntervalMax;

	public static ConfigEntry<float> FenringCircleInterval;

	public static ConfigEntry<float> FenringCircleDuration;

	public static ConfigEntry<float> FenringCircleDistance;

	public static ConfigEntry<float> FenringAttackIntervalMin;

	public static ConfigEntry<float> FenringAttackIntervalMax;

	public static ConfigEntry<float> LoxCircleInterval;

	public static ConfigEntry<float> LoxCircleDuration;

	public static ConfigEntry<float> LoxCircleDistance;

	public static ConfigEntry<float> DeathsquitoCircleInterval;

	public static ConfigEntry<float> DeathsquitoCircleDuration;

	public static ConfigEntry<float> DeathsquitoCircleDistance;

	public static ConfigEntry<float> DeathsquitoAttackIntervalMin;

	public static ConfigEntry<float> DeathsquitoAttackIntervalMax;

	public static ConfigEntry<float> SeekerCircleInterval;

	public static ConfigEntry<float> SeekerCircleDuration;

	public static ConfigEntry<float> SeekerCircleDistance;

	public static ConfigEntry<float> SeekerAttackIntervalMin;

	public static ConfigEntry<float> SeekerAttackIntervalMax;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_0f0e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f18: Expected O, but got Unknown
		EnableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugLogging", false, "Enable debug logging for circling modifications");
		GreylingCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Greyling", "CircleInterval", 0f, "Circle target interval for Greyling (0 = disable circling)");
		GreylingCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Greyling", "CircleDuration", 0f, "Circle target duration for Greyling (0 = disable circling)");
		GreylingCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Greyling", "CircleDistance", 0f, "Circle target distance for Greyling (0 = disable circling)");
		GreylingAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Greyling", "AttackIntervalMin", 0f, "Minimum attack interval for Greyling (seconds)");
		GreylingAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Greyling", "AttackIntervalMax", 3f, "Maximum attack interval for Greyling (seconds)");
		GreydwarfCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf", "CircleInterval", 0f, "Circle target interval for Greydwarf (0 = disable circling)");
		GreydwarfCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf", "CircleDuration", 0f, "Circle target duration for Greydwarf (0 = disable circling)");
		GreydwarfCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf", "CircleDistance", 0f, "Circle target distance for Greydwarf (0 = disable circling)");
		GreydwarfAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf", "AttackIntervalMin", 0f, "Minimum attack interval for Greydwarf (seconds)");
		GreydwarfAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf", "AttackIntervalMax", 3f, "Maximum attack interval for Greydwarf (seconds)");
		GreydwarfBruteCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Brute", "CircleInterval", 0f, "Circle target interval for Greydwarf Brute (0 = disable circling)");
		GreydwarfBruteCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Brute", "CircleDuration", 0f, "Circle target duration for Greydwarf Brute (0 = disable circling)");
		GreydwarfBruteCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Brute", "CircleDistance", 0f, "Circle target distance for Greydwarf Brute (0 = disable circling)");
		GreydwarfBruteAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Brute", "AttackIntervalMin", 0f, "Minimum attack interval for Greydwarf Brute (seconds)");
		GreydwarfBruteAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Brute", "AttackIntervalMax", 3f, "Maximum attack interval for Greydwarf Brute (seconds)");
		GreydwarfShamanCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Shaman", "CircleInterval", 0f, "Circle target interval for Greydwarf Shaman (0 = disable circling)");
		GreydwarfShamanCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Shaman", "CircleDuration", 0f, "Circle target duration for Greydwarf Shaman (0 = disable circling)");
		GreydwarfShamanCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Shaman", "CircleDistance", 0f, "Circle target distance for Greydwarf Shaman (0 = disable circling)");
		GreydwarfShamanAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Shaman", "AttackIntervalMin", 2f, "Minimum attack interval for Greydwarf Shaman (seconds)");
		GreydwarfShamanAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Greydwarf Shaman", "AttackIntervalMax", 10f, "Maximum attack interval for Greydwarf Shaman (seconds)");
		BoarCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Boar", "CircleInterval", 0f, "Circle target interval for Boar (0 = disable circling)");
		BoarCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Boar", "CircleDuration", 0f, "Circle target duration for Boar (0 = disable circling)");
		BoarCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Boar", "CircleDistance", 0f, "Circle target distance for Boar (0 = disable circling)");
		BoarAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Boar", "AttackIntervalMin", 0f, "Minimum attack interval for Boar (seconds)");
		BoarAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Boar", "AttackIntervalMax", 4f, "Maximum attack interval for Boar (seconds)");
		NeckCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Neck", "CircleInterval", 0f, "Circle target interval for Neck (0 = disable circling)");
		NeckCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Neck", "CircleDuration", 0f, "Circle target duration for Neck (0 = disable circling)");
		NeckCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Neck", "CircleDistance", 0f, "Circle target distance for Neck (0 = disable circling)");
		NeckAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Neck", "AttackIntervalMin", 0f, "Minimum attack interval for Neck (seconds)");
		NeckAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Neck", "AttackIntervalMax", 4f, "Maximum attack interval for Neck (seconds)");
		SkeletonCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Skeleton", "CircleInterval", 0f, "Circle target interval for Skeleton (0 = disable circling)");
		SkeletonCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Skeleton", "CircleDuration", 0f, "Circle target duration for Skeleton (0 = disable circling)");
		SkeletonCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Skeleton", "CircleDistance", 0f, "Circle target distance for Skeleton (0 = disable circling)");
		SkeletonAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Skeleton", "AttackIntervalMin", 0f, "Minimum attack interval for Skeleton (seconds)");
		SkeletonAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Skeleton", "AttackIntervalMax", 6f, "Maximum attack interval for Skeleton (seconds)");
		DraugrCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Draugr", "CircleInterval", 0f, "Circle target interval for Draugr (0 = disable circling)");
		DraugrCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Draugr", "CircleDuration", 0f, "Circle target duration for Draugr (0 = disable circling)");
		DraugrCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Draugr", "CircleDistance", 0f, "Circle target distance for Draugr (0 = disable circling)");
		DraugrAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Draugr", "AttackIntervalMin", 0f, "Minimum attack interval for Draugr (seconds)");
		DraugrAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Draugr", "AttackIntervalMax", 6f, "Maximum attack interval for Draugr (seconds)");
		HatchlingCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Hatchling", "CircleInterval", 0f, "Circle target interval for Hatchling (0 = disable circling)");
		HatchlingCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Hatchling", "CircleDuration", 0f, "Circle target duration for Hatchling (0 = disable circling)");
		HatchlingCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Hatchling", "CircleDistance", 0f, "Circle target distance for Hatchling (0 = disable circling)");
		HatchlingAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Hatchling", "AttackIntervalMin", 3f, "Minimum attack interval for Hatchling (seconds)");
		HatchlingAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Hatchling", "AttackIntervalMax", 8f, "Maximum attack interval for Hatchling (seconds)");
		GoblinCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin", "CircleInterval", 0f, "Circle target interval for Goblin (0 = disable circling)");
		GoblinCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin", "CircleDuration", 0f, "Circle target duration for Goblin (0 = disable circling)");
		GoblinCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin", "CircleDistance", 0f, "Circle target distance for Goblin (0 = disable circling)");
		GoblinAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin", "AttackIntervalMin", 2f, "Minimum attack interval for Goblin (seconds)");
		GoblinAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin", "AttackIntervalMax", 8f, "Maximum attack interval for Goblin (seconds)");
		GoblinShamanCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin Shaman", "CircleInterval", 0f, "Circle target interval for Goblin Shaman (0 = disable circling)");
		GoblinShamanCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin Shaman", "CircleDuration", 0f, "Circle target duration for Goblin Shaman (0 = disable circling)");
		GoblinShamanCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Goblin Shaman", "CircleDistance", 0f, "Circle target distance for Goblin Shaman (0 = disable circling)");
		UlvCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Ulv", "CircleInterval", 0f, "Circle target interval for Ulv (0 = disable circling)");
		UlvCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Ulv", "CircleDuration", 0f, "Circle target duration for Ulv (0 = disable circling)");
		UlvCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Ulv", "CircleDistance", 0f, "Circle target distance for Ulv (0 = disable circling)");
		UlvAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Ulv", "AttackIntervalMin", 0f, "Minimum attack interval for Ulv (seconds)");
		UlvAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Ulv", "AttackIntervalMax", 4f, "Maximum attack interval for Ulv (seconds)");
		WraithCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Wraith", "CircleInterval", 0f, "Circle target interval for Wraith (0 = disable circling)");
		WraithCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Wraith", "CircleDuration", 0f, "Circle target duration for Wraith (0 = disable circling)");
		WraithCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Wraith", "CircleDistance", 0f, "Circle target distance for Wraith (0 = disable circling)");
		WraithAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Wraith", "AttackIntervalMin", 0f, "Minimum attack interval for Wraith (seconds)");
		WraithAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Wraith", "AttackIntervalMax", 4f, "Maximum attack interval for Wraith (seconds)");
		SurtlingCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Surtling", "CircleInterval", 0f, "Circle target interval for Surtling (0 = disable circling)");
		SurtlingCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Surtling", "CircleDuration", 0f, "Circle target duration for Surtling (0 = disable circling)");
		SurtlingCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Surtling", "CircleDistance", 0f, "Circle target distance for Surtling (0 = disable circling)");
		SurtlingAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Surtling", "AttackIntervalMin", 0f, "Minimum attack interval for Surtling (seconds)");
		SurtlingAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Surtling", "AttackIntervalMax", 5f, "Maximum attack interval for Surtling (seconds)");
		BlobCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "CircleInterval", 0f, "Circle target interval for Blob (0 = disable circling)");
		BlobCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "CircleDuration", 0f, "Circle target duration for Blob (0 = disable circling)");
		BlobCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "CircleDistance", 0f, "Circle target distance for Blob (0 = disable circling)");
		BlobAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "AttackIntervalMin", 2f, "Minimum attack interval for Blob (seconds)");
		BlobAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "AttackIntervalMax", 6f, "Maximum attack interval for Blob (seconds)");
		BlobEliteCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("BlobElite", "CircleInterval", 0f, "Circle target interval for BlobElite (0 = disable circling)");
		BlobEliteCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("BlobElite", "CircleDuration", 0f, "Circle target duration for BlobElite (0 = disable circling)");
		BlobEliteCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("BlobElite", "CircleDistance", 0f, "Circle target distance for BlobElite (0 = disable circling)");
		BlobEliteAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("BlobElite", "AttackIntervalMin", 2f, "Minimum attack interval for BlobElite (seconds)");
		BlobEliteAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("BlobElite", "AttackIntervalMax", 6f, "Maximum attack interval for BlobElite (seconds)");
		BlobTarCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("BlobTar", "CircleInterval", 0f, "Circle target interval for BlobTar (0 = disable circling)");
		BlobTarCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("BlobTar", "CircleDuration", 0f, "Circle target duration for BlobTar (0 = disable circling)");
		BlobTarCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("BlobTar", "CircleDistance", 0f, "Circle target distance for BlobTar (0 = disable circling)");
		BlobTarAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("BlobTar", "AttackIntervalMin", 3f, "Minimum attack interval for BlobTar (seconds)");
		BlobTarAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("BlobTar", "AttackIntervalMax", 10f, "Maximum attack interval for BlobTar (seconds)");
		BlobLavaCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("BlobLava", "CircleInterval", 0f, "Circle target interval for BlobLava (0 = disable circling)");
		BlobLavaCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("BlobLava", "CircleDuration", 0f, "Circle target duration for BlobLava (0 = disable circling)");
		BlobLavaCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("BlobLava", "CircleDistance", 0f, "Circle target distance for BlobLava (0 = disable circling)");
		BlobLavaAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("BlobLava", "AttackIntervalMin", 2f, "Minimum attack interval for BlobLava (seconds)");
		BlobLavaAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("BlobLava", "AttackIntervalMax", 6f, "Maximum attack interval for BlobLava (seconds)");
		FenringCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Fenring", "CircleInterval", 0f, "Circle target interval for Fenring (0 = disable circling)");
		FenringCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Fenring", "CircleDuration", 0f, "Circle target duration for Fenring (0 = disable circling)");
		FenringCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Fenring", "CircleDistance", 0f, "Circle target distance for Fenring (0 = disable circling)");
		FenringAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Fenring", "AttackIntervalMin", 1f, "Minimum attack interval for Fenring (seconds)");
		FenringAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Fenring", "AttackIntervalMax", 5f, "Maximum attack interval for Fenring (seconds)");
		LoxCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Lox", "CircleInterval", 0f, "Circle target interval for Lox (0 = disable circling)");
		LoxCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Lox", "CircleDuration", 0f, "Circle target duration for Lox (0 = disable circling)");
		LoxCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Lox", "CircleDistance", 0f, "Circle target distance for Lox (0 = disable circling)");
		DeathsquitoCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Deathsquito", "CircleInterval", 0f, "Circle target interval for Deathsquito (0 = disable circling)");
		DeathsquitoCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Deathsquito", "CircleDuration", 0f, "Circle target duration for Deathsquito (0 = disable circling)");
		DeathsquitoCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Deathsquito", "CircleDistance", 0f, "Circle target distance for Deathsquito (0 = disable circling)");
		DeathsquitoAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Deathsquito", "AttackIntervalMin", 3f, "Minimum attack interval for Deathsquito (seconds)");
		DeathsquitoAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Deathsquito", "AttackIntervalMax", 10f, "Maximum attack interval for Deathsquito (seconds)");
		SeekerCircleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Seeker", "CircleInterval", 0f, "Circle target interval for Seeker (0 = disable circling)");
		SeekerCircleDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Seeker", "CircleDuration", 0f, "Circle target duration for Seeker (0 = disable circling)");
		SeekerCircleDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Seeker", "CircleDistance", 0f, "Circle target distance for Seeker (0 = disable circling)");
		SeekerAttackIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Seeker", "AttackIntervalMin", 2f, "Minimum attack interval for Seeker (seconds)");
		SeekerAttackIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Seeker", "AttackIntervalMax", 10f, "Maximum attack interval for Seeker (seconds)");
		_harmony = new Harmony("gabdao.enemycirclingcontrol");
		_harmony.PatchAll();
		if (EnableDebugLogging.Value)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Enemy Circling Control loaded with individual enemy configurations");
		}
	}

	private void OnDestroy()
	{
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		EnemyCirclingPatch.Cleanup();
		EnemyAttackIntervalPatch.Cleanup();
	}
}
[HarmonyPatch(typeof(MonsterAI), "Awake")]
public static class EnemyCirclingPatch
{
	private struct EnemyConfig
	{
		public float CircleInterval;

		public float CircleDuration;

		public float CircleDistance;

		public bool Found;

		public static readonly EnemyConfig NotFound = new EnemyConfig(0f, 0f, 0f, found: false);

		public EnemyConfig(float interval, float duration, float distance, bool found = true)
		{
			CircleInterval = interval;
			CircleDuration = duration;
			CircleDistance = distance;
			Found = found;
		}
	}

	private static readonly Dictionary<string, EnemyConfig> s_configCache = new Dictionary<string, EnemyConfig>();

	private static HashSet<string> s_customEnemies = null;

	private static string s_lastCustomEnemyConfig = null;

	private static float s_lastCleanupTime = 0f;

	private const float CLEANUP_INTERVAL = 300f;

	private static void Postfix(MonsterAI __instance)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || string.IsNullOrWhiteSpace(component.m_name))
			{
				return;
			}
			PeriodicCleanup();
			string name = component.m_name;
			if (!s_configCache.TryGetValue(name, out var value))
			{
				value = GetEnemyConfig(name);
				s_configCache[name] = value;
			}
			if (value.Found)
			{
				__instance.m_circleTargetInterval = value.CircleInterval;
				__instance.m_circleTargetDuration = value.CircleDuration;
				__instance.m_circleTargetDistance = value.CircleDistance;
				if (DangerousEnemiesSMALLEditionPlugin.EnableDebugLogging.Value)
				{
					Debug.Log((object)("[EnemyCirclingControl] Modified circling for: " + name + " " + $"(Interval: {value.CircleInterval}, Duration: {value.CircleDuration}, Distance: {value.CircleDistance})"));
				}
			}
		}
		catch (Exception arg)
		{
			Debug.LogError((object)$"[EnemyCirclingControl] Exception in circling patch: {arg}");
		}
	}

	private static EnemyConfig GetEnemyConfig(string characterName)
	{
		string text = characterName.ToLowerInvariant();
		if (text.Contains("greyling"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GreylingCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GreylingCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GreylingCircleDistance.Value);
		}
		if (text.Contains("greydwarf"))
		{
			if (text.Contains("brute"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GreydwarfBruteCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfBruteCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfBruteCircleDistance.Value);
			}
			if (text.Contains("shaman"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GreydwarfShamanCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfShamanCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfShamanCircleDistance.Value);
			}
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GreydwarfCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfCircleDistance.Value);
		}
		if (text.Contains("boar"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.BoarCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.BoarCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.BoarCircleDistance.Value);
		}
		if (text.Contains("neck"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.NeckCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.NeckCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.NeckCircleDistance.Value);
		}
		if (text.Contains("skeleton"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.SkeletonCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.SkeletonCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.SkeletonCircleDistance.Value);
		}
		if (text.Contains("draugr"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.DraugrCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.DraugrCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.DraugrCircleDistance.Value);
		}
		if (text.Contains("hatchling") || text.Contains("drake"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.HatchlingCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.HatchlingCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.HatchlingCircleDistance.Value);
		}
		if (text.Contains("goblin"))
		{
			if (text.Contains("brute"))
			{
				return EnemyConfig.NotFound;
			}
			if (text.Contains("shaman"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDistance.Value);
			}
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GoblinCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GoblinCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GoblinCircleDistance.Value);
		}
		if (text.Contains("ulv"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.UlvCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.UlvCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.UlvCircleDistance.Value);
		}
		if (text.Contains("wraith"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.WraithCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.WraithCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.WraithCircleDistance.Value);
		}
		if (text.Contains("surtling"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.SurtlingCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.SurtlingCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.SurtlingCircleDistance.Value);
		}
		if (text.Contains("blob"))
		{
			if (text.Contains("elite"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDistance.Value);
			}
			if (text.Contains("tar"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDistance.Value);
			}
			if (text.Contains("lava"))
			{
				return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.GoblinShamanCircleDistance.Value);
			}
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.BlobCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.BlobCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.BlobCircleDistance.Value);
		}
		if (text.Contains("fenring"))
		{
			if (text.Contains("cultist"))
			{
				return EnemyConfig.NotFound;
			}
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.FenringCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.FenringCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.FenringCircleDistance.Value);
		}
		if (text.Contains("deathsquito"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.DeathsquitoCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.DeathsquitoCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.DeathsquitoCircleDistance.Value);
		}
		if (text.Contains("lox"))
		{
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.LoxCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.LoxCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.LoxCircleDistance.Value);
		}
		if (text.Contains("seeker"))
		{
			if (text.Contains("brute"))
			{
				return EnemyConfig.NotFound;
			}
			return new EnemyConfig(DangerousEnemiesSMALLEditionPlugin.SeekerCircleInterval.Value, DangerousEnemiesSMALLEditionPlugin.SeekerCircleDuration.Value, DangerousEnemiesSMALLEditionPlugin.SeekerCircleDistance.Value);
		}
		return EnemyConfig.NotFound;
	}

	private static void PeriodicCleanup()
	{
		if (Time.time - s_lastCleanupTime > 300f)
		{
			if (s_configCache.Count > 150)
			{
				s_configCache.Clear();
			}
			s_lastCleanupTime = Time.time;
		}
	}

	public static void Cleanup()
	{
		s_configCache.Clear();
		s_customEnemies?.Clear();
		s_customEnemies = null;
		s_lastCustomEnemyConfig = null;
	}
}
[HarmonyPatch(typeof(MonsterAI), "SelectBestAttack")]
public static class EnemyAttackIntervalPatch
{
	private static readonly FieldRef<MonsterAI, Character> m_characterRef = AccessTools.FieldRefAccess<MonsterAI, Character>("m_character");

	private static readonly Dictionary<MonsterAI, string> s_lastAttackByInstance = new Dictionary<MonsterAI, string>();

	private static float s_lastCleanupTime = 0f;

	private const float CLEANUP_INTERVAL = 60f;

	private static void Postfix(MonsterAI __instance, ref ItemData __result)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			((Object)__instance).name.ToLower();
			if (__result == null || (Object)(object)__result.m_dropPrefab == (Object)null)
			{
				return;
			}
			Character val = m_characterRef.Invoke(__instance);
			if ((Object)(object)val == (Object)null || string.IsNullOrWhiteSpace(val.m_name))
			{
				return;
			}
			PeriodicCleanup();
			string name = val.m_name;
			(float, float)? attackConfig = GetAttackConfig(name.ToLowerInvariant());
			if (!attackConfig.HasValue)
			{
				return;
			}
			string name2 = ((Object)__result.m_dropPrefab).name;
			if (!s_lastAttackByInstance.TryGetValue(__instance, out var value) || value != name2)
			{
				s_lastAttackByInstance[__instance] = name2;
				float num = Random.Range(attackConfig.Value.Item1, attackConfig.Value.Item2);
				__result.m_shared.m_aiAttackInterval = num;
				if (DangerousEnemiesSMALLEditionPlugin.EnableDebugLogging.Value)
				{
					Debug.Log((object)$"[EnemyCirclingControl] Set attack interval for {name} ({name2}): {num:F2}s");
				}
			}
		}
		catch (Exception arg)
		{
			Debug.LogError((object)$"[EnemyCirclingControl] Exception in attack interval patch: {arg}");
		}
	}

	private static (float Min, float Max)? GetAttackConfig(string lowerName)
	{
		if (lowerName.Contains("greyling"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.GreylingAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.GreylingAttackIntervalMax.Value);
		}
		if (lowerName.Contains("greydwarf"))
		{
			if (lowerName.Contains("brute"))
			{
				return (DangerousEnemiesSMALLEditionPlugin.GreydwarfBruteAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfBruteAttackIntervalMax.Value);
			}
			if (lowerName.Contains("shaman"))
			{
				return (DangerousEnemiesSMALLEditionPlugin.GreydwarfShamanAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfShamanAttackIntervalMax.Value);
			}
			return (DangerousEnemiesSMALLEditionPlugin.GreydwarfAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.GreydwarfAttackIntervalMax.Value);
		}
		if (lowerName.Contains("boar"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.BoarAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.BoarAttackIntervalMax.Value);
		}
		if (lowerName.Contains("neck"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.NeckAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.NeckAttackIntervalMax.Value);
		}
		if (lowerName.Contains("skeleton"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.SkeletonAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.SkeletonAttackIntervalMax.Value);
		}
		if (lowerName.Contains("draugr"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.DraugrAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.DraugrAttackIntervalMax.Value);
		}
		if (lowerName.Contains("drake"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.HatchlingAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.HatchlingAttackIntervalMax.Value);
		}
		if (lowerName.Contains("goblin"))
		{
			if (lowerName.Contains("brute"))
			{
				return null;
			}
			if (lowerName.Contains("shaman"))
			{
				return null;
			}
			return (DangerousEnemiesSMALLEditionPlugin.GoblinAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.GoblinAttackIntervalMax.Value);
		}
		if (lowerName.Contains("ulv"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.UlvAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.UlvAttackIntervalMax.Value);
		}
		if (lowerName.Contains("wraith"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.WraithAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.WraithAttackIntervalMax.Value);
		}
		if (lowerName.Contains("surtling"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.SurtlingAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.SurtlingAttackIntervalMax.Value);
		}
		if (lowerName.Contains("blob"))
		{
			if (lowerName.Contains("elite"))
			{
				return (DangerousEnemiesSMALLEditionPlugin.BlobEliteAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.BlobEliteAttackIntervalMax.Value);
			}
			if (lowerName.Contains("tar"))
			{
				return (DangerousEnemiesSMALLEditionPlugin.BlobTarAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.BlobTarAttackIntervalMax.Value);
			}
			if (lowerName.Contains("lava"))
			{
				return (DangerousEnemiesSMALLEditionPlugin.BlobLavaAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.BlobLavaAttackIntervalMax.Value);
			}
			return (DangerousEnemiesSMALLEditionPlugin.BlobAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.BlobAttackIntervalMax.Value);
		}
		if (lowerName.Contains("fenring"))
		{
			if (lowerName.Contains("cultist"))
			{
				return null;
			}
			return (DangerousEnemiesSMALLEditionPlugin.FenringAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.FenringAttackIntervalMax.Value);
		}
		if (lowerName.Contains("deathsquito"))
		{
			return (DangerousEnemiesSMALLEditionPlugin.DeathsquitoAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.DeathsquitoAttackIntervalMax.Value);
		}
		if (lowerName.Contains("seeker"))
		{
			if (lowerName.Contains("brute"))
			{
				return null;
			}
			return (DangerousEnemiesSMALLEditionPlugin.SeekerAttackIntervalMin.Value, DangerousEnemiesSMALLEditionPlugin.SeekerAttackIntervalMax.Value);
		}
		return null;
	}

	private static void PeriodicCleanup()
	{
		if (!(Time.time - s_lastCleanupTime > 60f))
		{
			return;
		}
		foreach (MonsterAI item in s_lastAttackByInstance.Keys.Where((MonsterAI key) => (Object)(object)key == (Object)null || (Object)(object)((Component)key).gameObject == (Object)null).ToList())
		{
			s_lastAttackByInstance.Remove(item);
		}
		s_lastCleanupTime = Time.time;
	}

	public static void Cleanup()
	{
		s_lastAttackByInstance.Clear();
	}
}
[HarmonyPatch(typeof(MonsterAI), "Awake")]
public static class MinorEnemyProjectileIntervalPatch
{
	private static readonly Dictionary<MonsterAI, bool> s_configCache = new Dictionary<MonsterAI, bool>();

	private static float s_lastCleanupTime = 0f;

	private const float CLEANUP_INTERVAL = 60f;

	private static void Postfix(MonsterAI __instance)
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Expected O, but got Unknown
		try
		{
			PeriodicCleanup();
			if ((Object)(object)__instance == (Object)null || s_configCache.ContainsKey(__instance))
			{
				return;
			}
			string text = ((Object)__instance).name.ToLower();
			if (!text.Contains("drake"))
			{
				return;
			}
			Humanoid component = ((Component)__instance).GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			ItemData val = (ItemData)AccessTools.Field(typeof(Humanoid), "m_rightItem").GetValue(component);
			if (val?.m_shared != null)
			{
				float num = 0f;
				float num2 = 0f;
				if (text.Contains("drake"))
				{
					num = DangerousEnemiesSMALLEditionPlugin.HatchlingAttackIntervalMin.Value;
					num2 = DangerousEnemiesSMALLEditionPlugin.HatchlingAttackIntervalMax.Value;
				}
				float num3 = Random.Range(num, num2);
				val.m_shared.m_aiAttackInterval = num3;
				if (DangerousEnemiesSMALLEditionPlugin.EnableDebugLogging.Value)
				{
					Debug.Log((object)$"[MinorEnemyProjectileIntervalPatch] Set attack interval for {((Object)__instance).name}: {num3:F2}s");
				}
			}
			s_configCache[__instance] = true;
		}
		catch (Exception arg)
		{
			Debug.LogError((object)$"[MinorEnemyProjectileIntervalPatch] Exception: {arg}");
		}
	}

	private static void PeriodicCleanup()
	{
		if (Time.time - s_lastCleanupTime > 60f)
		{
			if (s_configCache.Count > 150)
			{
				s_configCache.Clear();
			}
			s_lastCleanupTime = Time.time;
		}
	}

	public static void Cleanup()
	{
		s_configCache.Clear();
	}
}