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 System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IssaPlugin.Items;
using IssaPlugin.Network;
using IssaPlugin.Overlays;
using IssaPlugin.Patches;
using Microsoft.CodeAnalysis;
using Mirror;
using Unity.Collections;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Localization;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[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: AssemblyCompany("IssaPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.29.0")]
[assembly: AssemblyInformationalVersion("0.0.29+d56dc40e6b078258fcda7f7ca86ece7679798b8f")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("IssaPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.29.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace IssaPlugin
{
	public class AC130Config
	{
		private const string Section = "AC130";

		private const string MaydaySection = "AC130Mayday";

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> OrbitRadius { get; private set; }

		public ConfigEntry<float> OrbitSpeed { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> CameraPitch { get; private set; }

		public ConfigEntry<float> CameraDistance { get; private set; }

		public ConfigEntry<float> FireCooldown { get; private set; }

		public ConfigEntry<float> RocketAngularJitter { get; private set; }

		public ConfigEntry<float> BoostMultiplier { get; private set; }

		public ConfigEntry<float> AltitudeOffsetMax { get; private set; }

		public ConfigEntry<float> AltitudeAdjustSpeed { get; private set; }

		public ConfigEntry<float> ZoomFov { get; private set; }

		public ConfigEntry<float> ZoomSpeed { get; private set; }

		public ConfigEntry<float> ApproachDistance { get; private set; }

		public ConfigEntry<float> ApproachSpeed { get; private set; }

		public ConfigEntry<float> BaseFov { get; private set; }

		public ConfigEntry<float> YawLimit { get; private set; }

		public ConfigEntry<float> PitchLimit { get; private set; }

		public ConfigEntry<float> MouseSensitivity { get; private set; }

		public ConfigEntry<float> HeavyFireCooldown { get; private set; }

		public ConfigEntry<float> HeavyShotsBeforeReload { get; private set; }

		public ConfigEntry<float> HeavyReloadTime { get; private set; }

		public ConfigEntry<bool> MaydayEnabled { get; private set; }

		public ConfigEntry<Key> MaydayKey { get; private set; }

		public ConfigEntry<float> MaydayDiveSteepRate { get; private set; }

		public ConfigEntry<float> MaydayInitialDiveAngle { get; private set; }

		public ConfigEntry<float> MaydayMaxDiveAngle { get; private set; }

		public ConfigEntry<float> MaydayPullInfluence { get; private set; }

		public ConfigEntry<float> MaydayRollSpeed { get; private set; }

		public ConfigEntry<float> MaydaySpeed { get; private set; }

		public ConfigEntry<float> MaydayDrift { get; private set; }

		public ConfigEntry<float> MaydayCenterBias { get; private set; }

		public ConfigEntry<float> MaydayCamYawLimit { get; private set; }

		public ConfigEntry<float> MaydayCamPitchLimit { get; private set; }

		public ConfigEntry<float> MaydayShakeBase { get; private set; }

		public ConfigEntry<float> MaydayShakeMax { get; private set; }

		public ConfigEntry<float> MaydayExplosionScale { get; private set; }

		public ConfigEntry<float> MaydayExplosionDuration { get; private set; }

		public ConfigEntry<float> MaydayRollTurnRate { get; private set; }

		public ConfigEntry<float> HitsToMayday { get; private set; }

		public ConfigEntry<float> RocketProximityFuse { get; private set; }

		public ConfigEntry<bool> ApplyCoffeeBoostAfterwards { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> HeavyRocketExplosionScale { get; private set; }

		public AC130Config(ConfigFile cfg, GlobalConfig global)
		{
			Uses = cfg.Bind<float>("AC130", "Uses", 1f, "Number of AC130 uses per pickup.");
			GiveKey = cfg.Bind<Key>("AC130", "GiveKey", (Key)104, "Key to press to add the AC130 to your inventory.");
			OrbitRadius = cfg.Bind<float>("AC130", "OrbitRadius", 100f, "Radius in units of the circle the gunship flies around the map centre.");
			OrbitSpeed = cfg.Bind<float>("AC130", "OrbitSpeed", 6f, "Degrees per second at which the gunship orbits the map centre.");
			Altitude = cfg.Bind<float>("AC130", "Altitude", 140f, "Height above the map centre the gunship flies at.");
			Duration = cfg.Bind<float>("AC130", "Duration", 20f, "How many seconds the AC130 remains active before leaving.");
			CameraPitch = cfg.Bind<float>("AC130", "CameraPitch", 80f, "Camera pitch angle in degrees during the AC130 (0 = horizontal, 90 = straight down).");
			CameraDistance = cfg.Bind<float>("AC130", "CameraDistance", 80f, "Camera distance addition from the gunship pivot during the AC130.");
			FireCooldown = cfg.Bind<float>("AC130", "FireCooldown", 0.35f, "Minimum seconds between rocket fires.");
			HeavyFireCooldown = cfg.Bind<float>("AC130", "HeavyFireCooldown", 3f, "Minimum seconds between heavy (big shot) rocket fires.");
			HeavyShotsBeforeReload = cfg.Bind<float>("AC130", "HeavyShotsBeforeReload", 3f, "Number of big shots before the heavy rocket must reload.");
			HeavyReloadTime = cfg.Bind<float>("AC130", "HeavyReloadTime", 8f, "Time in seconds for the heavy rocket to reload after depleting all big shots.");
			RocketAngularJitter = cfg.Bind<float>("AC130", "RocketAngularJitter", 0.5f, "Random angular jitter in degrees applied to each rocket fired from the AC130.");
			BoostMultiplier = cfg.Bind<float>("AC130", "BoostMultiplier", 2.25f, "Multiplier applied to orbit speed when holding Left Shift.");
			AltitudeOffsetMax = cfg.Bind<float>("AC130", "AltitudeOffsetMax", 80f, "Maximum units the player can raise the gunship from its base altitude using Q/E.");
			AltitudeAdjustSpeed = cfg.Bind<float>("AC130", "AltitudeAdjustSpeed", 10f, "Units per second the gunship rises or descends when holding Q or E.");
			ZoomFov = cfg.Bind<float>("AC130", "ZoomFov", 20f, "Field of view when right-click zooming in the AC130. Lower values zoom in more (default camera FOV is typically 60).");
			ZoomSpeed = cfg.Bind<float>("AC130", "ZoomSpeed", 8f, "Speed at which the camera lerps to and from the zoomed FOV when right-clicking.");
			ApproachDistance = cfg.Bind<float>("AC130", "ApproachDistance", 200f, "How far away the AC130 spawns and flies in from before reaching the orbit point.");
			ApproachSpeed = cfg.Bind<float>("AC130", "ApproachSpeed", 60f, "Speed in units per second at which the AC130 flies in and out.");
			BaseFov = cfg.Bind<float>("AC130", "BaseFov", 60f, "Base field of view for the AC130 camera.");
			YawLimit = cfg.Bind<float>("AC130", "YawLimit", 40f, "How many degrees left/right the player can pan from the map centre.");
			PitchLimit = cfg.Bind<float>("AC130", "PitchLimit", 30f, "How many degrees up/down the player can pan from the map centre.");
			MouseSensitivity = cfg.Bind<float>("AC130", "MouseSensitivity", 0.15f, "How sensitive the player's mouse is to panning the camera.");
			ApplyCoffeeBoostAfterwards = cfg.Bind<bool>("AC130", "ApplyCoffeeBoostAfterwards", true, "Give the user of an AC130 a max coffee boost after the AC130 ends to make up for the time they spent sitting in the AC130, not golfing.");
			MaydayEnabled = cfg.Bind<bool>("AC130Mayday", "Enabled", true, "Whether the manual mayday self-destruct hotkey is available.");
			MaydayKey = cfg.Bind<Key>("AC130Mayday", "Key", (Key)27, "Hotkey to manually trigger mayday (self-destruct) while in an AC130 session.");
			MaydayDiveSteepRate = cfg.Bind<float>("AC130Mayday", "DiveSteepRate", 8f, "Degrees per second at which the dive pitch steepens toward vertical.");
			MaydayInitialDiveAngle = cfg.Bind<float>("AC130Mayday", "InitialDiveAngle", 20f, "Starting pitch angle (degrees below horizontal) when mayday begins.");
			MaydayMaxDiveAngle = cfg.Bind<float>("AC130Mayday", "MaxDiveAngle", 85f, "Maximum pitch angle (degrees below horizontal) the dive steepens to.");
			MaydayPullInfluence = cfg.Bind<float>("AC130Mayday", "PullInfluence", 6f, "Degrees per second of pitch influence the player has when holding W/S during mayday.");
			MaydayRollSpeed = cfg.Bind<float>("AC130Mayday", "RollSpeed", 45f, "Degrees per second the player can roll the gunship with A/D during mayday.");
			MaydaySpeed = cfg.Bind<float>("AC130Mayday", "Speed", 80f, "Forward speed of the gunship during the mayday dive in units per second.");
			MaydayDrift = cfg.Bind<float>("AC130Mayday", "Drift", 3f, "Maximum random lateral drift added to the dive direction per second.");
			MaydayCenterBias = cfg.Bind<float>("AC130Mayday", "CenterBias", 0.4f, "Lerp strength per second toward map centre during the dive. Higher = tighter spiral, lower = nearly straight. Default 0.4.");
			MaydayCamYawLimit = cfg.Bind<float>("AC130Mayday", "CamYawLimit", 25f, "How many degrees left/right the player can look during mayday.");
			MaydayCamPitchLimit = cfg.Bind<float>("AC130Mayday", "CamPitchLimit", 15f, "How many degrees up/down the player can look during mayday.");
			MaydayShakeBase = cfg.Bind<float>("AC130Mayday", "ShakeBase", 0.3f, "Camera shake intensity at the start of the mayday dive.");
			MaydayShakeMax = cfg.Bind<float>("AC130Mayday", "ShakeMax", 2.5f, "Maximum camera shake intensity at the end of the dive.");
			MaydayExplosionScale = cfg.Bind<float>("AC130Mayday", "ExplosionScale", 4f, "Explosion scale multiplier for the mayday crash. Affects blast radius, knockback, and VFX size.");
			MaydayExplosionDuration = cfg.Bind<float>("AC130Mayday", "ExplosionDuration", 12f, "How long (seconds) the crash explosion VFX lingers before being destroyed.");
			MaydayRollTurnRate = cfg.Bind<float>("AC130Mayday", "RollTurnRate", 45f, "Degrees per second of yaw the aircraft gains when fully banked (90° roll). Controls how tightly rolling steers the plane left/right.");
			HitsToMayday = cfg.Bind<float>("AC130Mayday", "HitsToMayday", 1f, "Number of rocket hits required to force the gunship into mayday. Only counts hits during an active session. Set to 0 to disable.");
			RocketProximityFuse = cfg.Bind<float>("AC130Mayday", "RocketProximityFuse", 4f, "Distance in metres at which a homing rocket detonates near the gunship. Must be less than 5 m so the explosion's overlap sphere (radius 5 m) still reaches the gunship and registers the hit.");
			ExplosionScale = cfg.Bind<float>("Explosions", "AC130Scale", 2.25f, "Multiplier for AC130 rocket explosions. Affects blast radius, knockback, and VFX size.");
			HeavyRocketExplosionScale = cfg.Bind<float>("Explosions", "AC130HeavyRocketScale", 5f, "Multiplier for AC130 heavy (big shot) rocket explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class AK47Config
	{
		private const string Section = "AK47";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FireRate { get; private set; }

		public ConfigEntry<float> Inaccuracy { get; private set; }

		public ConfigEntry<float> MaxAimingDistance { get; private set; }

		public ConfigEntry<float> MaxShotDistance { get; private set; }

		public ConfigEntry<float> ScreenShakeIntensity { get; private set; }

		public AK47Config(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("AK47", "GiveKey", (Key)80, "Debug key to add the Sub-Machine Gun to your inventory.");
			Uses = cfg.Bind<float>("AK47", "Uses", 10f, "Total bullets per Sub-Machine Gun pickup. Each shot consumes one use.");
			FireRate = cfg.Bind<float>("AK47", "FireRate", 0.04f, "Seconds between each bullet in the burst.");
			Inaccuracy = cfg.Bind<float>("AK47", "Inaccuracy", 5f, "Random spread angle (degrees) applied to each bullet. Higher = less accurate.");
			MaxAimingDistance = cfg.Bind<float>("AK47", "MaxAimingDistance", 500f, "Max distance used when computing the aim point for each bullet.");
			MaxShotDistance = cfg.Bind<float>("AK47", "MaxShotDistance", 500f, "Max raycast distance for each bullet.");
			ScreenShakeIntensity = cfg.Bind<float>("AK47", "ScreenShakeIntensity", 0.25f, "Intensity of the screen shake when firing the AK47. 0 disables it. Higher values shake more.");
		}
	}
	public class BaseballBatConfig
	{
		private const string Section = "BaseballBat";

		public ConfigEntry<float> PowerMultiplier { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public BaseballBatConfig(ConfigFile cfg, GlobalConfig global)
		{
			PowerMultiplier = cfg.Bind<float>("BaseballBat", "PowerMultiplier", 3f, "Multiplier applied to the golf swing power when using the bat.");
			Uses = cfg.Bind<float>("BaseballBat", "Uses", 99f, "Number of swings before the bat is consumed. Set high for near-infinite use.");
			GiveKey = cfg.Bind<Key>("BaseballBat", "GiveKey", (Key)100, "Key to press to add the baseball bat to your inventory.");
		}
	}
	public class BearConfig
	{
		private const string Section = "Bear";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Count { get; private set; }

		public ConfigEntry<float> SpawnRadius { get; private set; }

		public ConfigEntry<float> SessionDuration { get; private set; }

		public ConfigEntry<float> WalkSpeed { get; private set; }

		public ConfigEntry<float> RunSpeed { get; private set; }

		public ConfigEntry<float> ChargeSpeed { get; private set; }

		public ConfigEntry<float> TurnSpeed { get; private set; }

		public ConfigEntry<float> WanderRadius { get; private set; }

		public ConfigEntry<float> ChargeRange { get; private set; }

		public ConfigEntry<float> AttackRange { get; private set; }

		public ConfigEntry<float> AttackCooldown { get; private set; }

		public ConfigEntry<float> AttackAnimationDuration { get; private set; }

		public ConfigEntry<float> SpawnAnimationDuration { get; private set; }

		public ConfigEntry<float> DeathAnimationDuration { get; private set; }

		public ConfigEntry<float> StunDuration { get; private set; }

		public ConfigEntry<float> EnrageDuration { get; private set; }

		public ConfigEntry<float> EnrageSpeedMultiplier { get; private set; }

		public ConfigEntry<float> MaxHP { get; private set; }

		public ConfigEntry<float> DamageDuelingPistol { get; private set; }

		public ConfigEntry<float> DamageElephantGun { get; private set; }

		public ConfigEntry<float> DamageRocketDirect { get; private set; }

		public ConfigEntry<float> DamageRocketExplosion { get; private set; }

		public ConfigEntry<float> DamageGolfClub { get; private set; }

		public ConfigEntry<float> DamageBaseballBat { get; private set; }

		public ConfigEntry<float> DamageOrbitalLaser { get; private set; }

		public ConfigEntry<float> MeleeKnockbackForce { get; private set; }

		public ConfigEntry<float> BatKnockbackForce { get; private set; }

		public ConfigEntry<float> MaxClimbHeight { get; private set; }

		public ConfigEntry<float> TargetLockDuration { get; private set; }

		public ConfigEntry<float> TargetStealThreshold { get; private set; }

		public ConfigEntry<float> TargetAbandonDistance { get; private set; }

		public ConfigEntry<float> AggroStealThreshold { get; private set; }

		public ConfigEntry<float> AggroDuration { get; private set; }

		public ConfigEntry<float> MeleeHitRange { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public BearConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Bear", "GiveKey", (Key)89, "Debug key to add the Bear item to your inventory.");
			Uses = cfg.Bind<float>("Bear", "Uses", 1f, "Number of uses per Bear item pickup.");
			Count = cfg.Bind<float>("Bear", "BearCount", 2f, "Number of bears spawned per item use.");
			SpawnRadius = cfg.Bind<float>("Bear", "SpawnRadius", 15f, "Radius around the player within which bears spawn.");
			SessionDuration = cfg.Bind<float>("Bear", "SessionDuration", 60f, "Seconds before all remaining bears are forcibly despawned.");
			WalkSpeed = cfg.Bind<float>("Bear", "WalkSpeed", 4f, "Bear movement speed while wandering or obstructed (units/sec).");
			RunSpeed = cfg.Bind<float>("Bear", "RunSpeed", 9f, "Bear movement speed while pursuing a target (units/sec).");
			ChargeSpeed = cfg.Bind<float>("Bear", "ChargeSpeed", 14f, "Bear movement speed during the committed charge phase (units/sec).");
			TurnSpeed = cfg.Bind<float>("Bear", "TurnSpeed", 6f, "How quickly the bear rotates to face its movement direction.");
			WanderRadius = cfg.Bind<float>("Bear", "WanderRadius", 12f, "Radius of the area the bear wanders within when idle.");
			ChargeRange = cfg.Bind<float>("Bear", "ChargeRange", 10f, "Distance at which the bear commits to a charge attack (units).");
			AttackRange = cfg.Bind<float>("Bear", "AttackRange", 2.8f, "Distance at which the bear's attack swing connects (units).");
			AttackCooldown = cfg.Bind<float>("Bear", "AttackCooldown", 1.8f, "Seconds between the end of one attack and the start of the next pursuit.");
			AttackAnimationDuration = cfg.Bind<float>("Bear", "AttackAnimationDuration", 1.2f, "Total duration of the attack animation. Hit is applied at 55% of this value.");
			SpawnAnimationDuration = cfg.Bind<float>("Bear", "SpawnAnimationDuration", 2f, "Duration of the Buff/spawn-in animation before the bear begins hunting.");
			DeathAnimationDuration = cfg.Bind<float>("Bear", "DeathAnimationDuration", 2.5f, "How long the death animation plays before the bear is destroyed.");
			StunDuration = cfg.Bind<float>("Bear", "StunDuration", 2f, "Seconds the bear is stunned after being hit by an explosion.");
			EnrageDuration = cfg.Bind<float>("Bear", "EnrageDuration", 5f, "Seconds the bear runs at enrage speed after recovering from a stun.");
			EnrageSpeedMultiplier = cfg.Bind<float>("Bear", "EnrageSpeedMultiplier", 1.5f, "Speed multiplier applied to RunSpeed during enrage.");
			MaxHP = cfg.Bind<float>("Bear", "MaxHP", 100f, "Maximum HP for a bear. Each hit reduces HP by the weapon's damage value; bear dies at 0.");
			DamageDuelingPistol = cfg.Bind<float>("Bear", "DamageDuelingPistol", 25f, "HP damage dealt to a bear by a dueling pistol shot.");
			DamageElephantGun = cfg.Bind<float>("Bear", "DamageElephantGun", 50f, "HP damage dealt to a bear by an elephant gun shot.");
			DamageRocketDirect = cfg.Bind<float>("Bear", "DamageRocketDirect", 100f, "HP damage dealt to a bear by a direct rocket hit (explosion centre within 1.5 units).");
			DamageRocketExplosion = cfg.Bind<float>("Bear", "DamageRocketExplosion", 35f, "HP damage dealt to a bear by rocket splash damage (not a direct hit).");
			DamageGolfClub = cfg.Bind<float>("Bear", "DamageGolfClub", 25f, "HP damage dealt to a bear by a golf club swing.");
			DamageBaseballBat = cfg.Bind<float>("Bear", "DamageBaseballBat", 40f, "HP damage dealt to a bear by a baseball bat swing.");
			DamageOrbitalLaser = cfg.Bind<float>("Bear", "DamageOrbitalLaser", 100f, "HP damage dealt to a bear by the orbital laser.");
			MeleeKnockbackForce = cfg.Bind<float>("Bear", "MeleeKnockbackForce", 12f, "Impulse force applied to a bear's rigidbody when hit by a golf club swing.");
			BatKnockbackForce = cfg.Bind<float>("Bear", "BatKnockbackForce", 22f, "Impulse force applied to a bear's rigidbody when hit by a baseball bat swing.");
			MaxClimbHeight = cfg.Bind<float>("Bear", "MaxClimbHeight", 6f, "Max height difference (units) before a target is considered unreachable.");
			TargetLockDuration = cfg.Bind<float>("Bear", "TargetLockDuration", 8f, "Minimum seconds a bear keeps its target before re-evaluating.");
			TargetStealThreshold = cfg.Bind<float>("Bear", "TargetStealThreshold", 12f, "A new candidate must be this many units closer to steal the lock after the timer expires.");
			TargetAbandonDistance = cfg.Bind<float>("Bear", "TargetAbandonDistance", 65f, "If the locked target moves beyond this distance the lock is dropped immediately.");
			AggroStealThreshold = cfg.Bind<float>("Bear", "AggroStealThreshold", 4f, "A player who hit the bear can steal the lock if at least this many units closer (lower bar than normal steal).");
			AggroDuration = cfg.Bind<float>("Bear", "AggroDuration", 15f, "How long (seconds) aggro on a specific player lasts after they hit the bear.");
			MeleeHitRange = cfg.Bind<float>("Bear", "MeleeHitRange", 2.5f, "Radius (units) around the swing hitbox centre that counts as a golf-club/bat hit on a bear.");
			FriendlyFire = cfg.Bind<bool>("Bear", "FriendlyFire", false, "If false, bears will not target or attack the player who summoned them.");
			AttackFinishedPlayers = cfg.Bind<bool>("Bear", "AttackFinishedPlayers", false, "If true, bears will target players who have already holed out. If false, bears ignore them.");
		}
	}
	public class BlackHoleGrenadeConfig
	{
		private const string Section = "BlackHoleGrenade";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> MaxThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> GraceTime { get; private set; }

		public ConfigEntry<float> SuckDuration { get; private set; }

		public ConfigEntry<float> SuckRadius { get; private set; }

		public ConfigEntry<float> SuckForce { get; private set; }

		public ConfigEntry<float> MaxSuckForce { get; private set; }

		public ConfigEntry<float> SpitForce { get; private set; }

		public ConfigEntry<float> SpitVfxScale { get; private set; }

		public ConfigEntry<float> KnockdownRadius { get; private set; }

		public ConfigEntry<bool> ExcludeThrower { get; private set; }

		public ConfigEntry<float> BonusGolfCartForceMultiplier { get; private set; }

		public ConfigEntry<bool> AffectsGolfBalls { get; private set; }

		public BlackHoleGrenadeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("BlackHoleGrenade", "GiveKey", (Key)91, "Debug key to add the Black Hole Grenade to your inventory.");
			Uses = cfg.Bind<float>("BlackHoleGrenade", "Uses", 1f, "Number of uses per Black Hole Grenade pickup.");
			ThrowSpeed = cfg.Bind<float>("BlackHoleGrenade", "ThrowSpeed", 20f, "Initial throw speed in m/s.");
			MaxThrowSpeed = cfg.Bind<float>("BlackHoleGrenade", "MaxThrowSpeed", 30f, "Server-side clamp on throw speed to prevent exploits.");
			LobAngle = cfg.Bind<float>("BlackHoleGrenade", "LobAngle", 0.4f, "Upward component added to the throw direction to create an arc. 0 = flat, 1 = 45° upward.");
			GraceTime = cfg.Bind<float>("BlackHoleGrenade", "GraceTime", 0.35f, "Seconds after throwing before the grenade can stick to the ground.");
			SuckDuration = cfg.Bind<float>("BlackHoleGrenade", "SuckDuration", 6f, "How many seconds the suction phase lasts before spitting.");
			SuckRadius = cfg.Bind<float>("BlackHoleGrenade", "SuckRadius", 35f, "Radius in units of the suction field.");
			SuckForce = cfg.Bind<float>("BlackHoleGrenade", "SuckForce", 8f, "Suction acceleration (m/s²) applied at the outer edge of the suction field.");
			MaxSuckForce = cfg.Bind<float>("BlackHoleGrenade", "MaxSuckForce", 40f, "Suction acceleration (m/s²) applied right at the center of the black hole.");
			SpitForce = cfg.Bind<float>("BlackHoleGrenade", "SpitForce", 35f, "Speed (m/s) at which objects and players are ejected during the spit phase.");
			SpitVfxScale = cfg.Bind<float>("BlackHoleGrenade", "SpitVfxScale", 3f, "Scale of the explosion VFX played on all clients when the black hole collapses.");
			KnockdownRadius = cfg.Bind<float>("BlackHoleGrenade", "KnockdownRadius", 15f, "Distance from the black hole at which a player gets knocked down. Must be less than SuckRadius. Set to 0 to disable.");
			ExcludeThrower = cfg.Bind<bool>("BlackHoleGrenade", "ExcludeThrower", true, "If true, the player who threw the grenade is not affected by suction or spit.");
			BonusGolfCartForceMultiplier = cfg.Bind<float>("BlackHoleGrenade", "BonusGolfCartForceMultiplier", 2f, "Additional force multiplier applied to golf carts.");
			AffectsGolfBalls = cfg.Bind<bool>("BlackHoleGrenade", "AffectsGolfBalls", true, "If true, the black hole grenade sucks in and spits out golf balls. Set to false to leave golf balls unaffected.");
		}
	}
	public class DonutConfig
	{
		private const string Section = "Donut";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Speed { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> TerrainFollowSpeed { get; private set; }

		public ConfigEntry<float> TurnSpeed { get; private set; }

		public ConfigEntry<float> CameraPitch { get; private set; }

		public ConfigEntry<float> CameraDistance { get; private set; }

		public ConfigEntry<float> MouseSensitivity { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> LaserUses { get; private set; }

		public ConfigEntry<float> LaserAnticipationDuration { get; private set; }

		public ConfigEntry<float> LaserCooldown { get; private set; }

		public ConfigEntry<float> HitsToDestroy { get; private set; }

		public ConfigEntry<float> CrashImpactForce { get; private set; }

		public ConfigEntry<float> CrashDownwardForce { get; private set; }

		public ConfigEntry<float> CrashTorque { get; private set; }

		public ConfigEntry<float> CrashExplosionScale { get; private set; }

		public DonutConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Donut", "GiveKey", (Key)86, "Debug key to add the Donut to your inventory.");
			Uses = cfg.Bind<float>("Donut", "Uses", 1f, "Number of Donut uses per pickup.");
			Speed = cfg.Bind<float>("Donut", "Speed", 30f, "Horizontal movement speed of the Donut in units per second.");
			Altitude = cfg.Bind<float>("Donut", "Altitude", 20f, "Height above terrain the Donut hovers at.");
			TerrainFollowSpeed = cfg.Bind<float>("Donut", "TerrainFollowSpeed", 5f, "How quickly the Donut adjusts its altitude to match terrain changes (lerp speed).");
			TurnSpeed = cfg.Bind<float>("Donut", "TurnSpeed", 8f, "How quickly the Donut rotates to face the movement direction (Slerp speed).");
			CameraPitch = cfg.Bind<float>("Donut", "CameraPitch", 60f, "Camera pitch angle in degrees during the Donut session (0 = horizontal, 90 = straight down).");
			CameraDistance = cfg.Bind<float>("Donut", "CameraDistance", 40f, "Camera distance addition from the Donut during the session.");
			MouseSensitivity = cfg.Bind<float>("Donut", "MouseSensitivity", 0.2f, "Mouse X sensitivity for rotating the Donut orbit camera.");
			Duration = cfg.Bind<float>("Donut", "Duration", 30f, "How many seconds the Donut session lasts before automatically ending.");
			LaserUses = cfg.Bind<float>("Donut", "LaserUses", 3f, "How many orbital laser strikes the player can fire during a Donut session.");
			LaserAnticipationDuration = cfg.Bind<float>("Donut", "LaserAnticipationDuration", 1.5f, "Seconds of anticipation before the orbital laser fires. The laser tracks the Donut during this window.");
			LaserCooldown = cfg.Bind<float>("Donut", "LaserCooldown", 3f, "Minimum seconds between orbital laser fires.");
			HitsToDestroy = cfg.Bind<float>("Donut", "HitsToDestroy", 1f, "Rocket hits required to shoot down the Donut. Set to 0 to make it invincible.");
			CrashImpactForce = cfg.Bind<float>("Donut", "CrashImpactForce", 500f, "Impulse force applied to the Donut in the direction of the rocket hit when shot down.");
			CrashDownwardForce = cfg.Bind<float>("Donut", "CrashDownwardForce", 15f, "Impulse force applied to the Donut in the downward direction.");
			CrashTorque = cfg.Bind<float>("Donut", "CrashTorque", 1.2f, "Magnitude of the random tumble torque applied to the Donut when shot down.");
			CrashExplosionScale = cfg.Bind<float>("Donut", "CrashExplosionScale", 4f, "Explosion scale multiplier for when a Donut crashes. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class DroneSwarmConfig
	{
		private const string Section = "DroneSwarm";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> BaseDroneCount { get; private set; }

		public ConfigEntry<float> PerPlayerScalingFactor { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> WanderRadius { get; private set; }

		public ConfigEntry<float> WanderSpeed { get; private set; }

		public ConfigEntry<float> WanderTurnRate { get; private set; }

		public ConfigEntry<float> AltitudeVariance { get; private set; }

		public ConfigEntry<float> CircleTimeMin { get; private set; }

		public ConfigEntry<float> CircleTimeMax { get; private set; }

		public ConfigEntry<float> DiveSpeed { get; private set; }

		public ConfigEntry<float> DiveAcceleration { get; private set; }

		public ConfigEntry<float> HomingStopDistance { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public ConfigEntry<float> MaxSessionDuration { get; private set; }

		public DroneSwarmConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			GiveKey = cfg.Bind<Key>("DroneSwarm", "GiveKey", (Key)77, "Debug key to add the Drone Swarm item to your inventory.");
			Uses = cfg.Bind<float>("DroneSwarm", "Uses", 1f, "Number of uses per Drone Swarm pickup.");
			BaseDroneCount = cfg.Bind<float>("DroneSwarm", "BaseDroneCount", 15f, "Number of drones spawned per use. Keep at or below 12 to avoid network overhead.");
			PerPlayerScalingFactor = cfg.Bind<float>("DroneSwarm", "PerPlayerScalingFactor", 0.1f, new ConfigDescription("Increase the DroneCount as: DroneCount = BaseDroneCount * (1 + [NumPlayers * PerPlayerScalingFactor]). Set to 0 to disable.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			Altitude = cfg.Bind<float>("DroneSwarm", "Altitude", 300f, "Height (metres) at which drones circle above the player centroid.");
			WanderRadius = cfg.Bind<float>("DroneSwarm", "WanderRadius", 150f, "Maximum distance (metres) from the wander centre a drone waypoint may be placed.");
			WanderSpeed = cfg.Bind<float>("DroneSwarm", "WanderSpeed", 125f, "Cruise speed (metres/second) while drones are wandering before they dive.");
			WanderTurnRate = cfg.Bind<float>("DroneSwarm", "WanderTurnRate", 45f, "Maximum steering rate (degrees/second) while wandering. Lower = lazier, wider arcs. Higher = tighter turns.");
			AltitudeVariance = cfg.Bind<float>("DroneSwarm", "AltitudeVariance", 25f, "Half-range (metres) of random altitude variation added to each waypoint. Drones pick altitudes between Altitude ± AltitudeVariance.");
			CircleTimeMin = cfg.Bind<float>("DroneSwarm", "CircleTimeMin", 3f, "Minimum seconds a drone circles before diving (randomised per drone).");
			CircleTimeMax = cfg.Bind<float>("DroneSwarm", "CircleTimeMax", 30f, "Maximum seconds a drone circles before diving (randomised per drone).");
			DiveSpeed = cfg.Bind<float>("DroneSwarm", "DiveSpeed", 20f, "Initial dive speed in metres per second.");
			DiveAcceleration = cfg.Bind<float>("DroneSwarm", "DiveAcceleration", 40f, "How many metres per second the dive speed increases each second.");
			HomingStopDistance = cfg.Bind<float>("DroneSwarm", "HomingStopDistance", 75f, "Distance from the target (metres) at which the drone stops tracking and flies straight, giving the target a chance to dodge. Set to 0 to always home.");
			ArrivalRadius = cfg.Bind<float>("DroneSwarm", "ArrivalRadius", 3f, "Distance from the aim point (metres) at which the drone detonates.");
			ExplosionScale = cfg.Bind<float>("DroneSwarm", "ExplosionScale", 1.05f, "Scale multiplier for the drone impact explosion radius and force.");
			FriendlyFire = cfg.Bind<bool>("DroneSwarm", "FriendlyFire", false, "If true, drones may target the player who summoned them.");
			AttackFinishedPlayers = cfg.Bind<bool>("DroneSwarm", "AttackFinishedPlayers", false, "If true, drones may target players who have already holed out.");
			MaxSessionDuration = cfg.Bind<float>("DroneSwarm", "MaxSessionDuration", 60f, "Safety cap (seconds) after which any remaining drones are force-destroyed.");
		}
	}
	public class FlamethrowerConfig
	{
		private const string Section = "Flamethrower";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FuelPerUse { get; private set; }

		public ConfigEntry<float> BurnDuration { get; private set; }

		public ConfigEntry<float> BurnRequestInterval { get; private set; }

		public FlamethrowerConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Flamethrower", "GiveKey", (Key)98, "Hotkey to give yourself a Flamethrower (debug/testing).");
			Uses = cfg.Bind<float>("Flamethrower", "Uses", 1f, "Number of fuel canisters per Flamethrower pickup. Each canister provides FuelPerUse seconds of fire.");
			FuelPerUse = cfg.Bind<float>("Flamethrower", "FuelPerUse", 3f, "Seconds of continuous fire provided by each fuel canister.");
			BurnDuration = cfg.Bind<float>("Flamethrower", "BurnDuration", 4f, "Seconds a hit player stays on fire after the last flamethrower contact. Resets on each new hit.");
			BurnRequestInterval = cfg.Bind<float>("Flamethrower", "BurnRequestInterval", 0.5f, "Minimum seconds between burn-request messages sent per victim while the flame collider overlaps them.");
		}
	}
	public class FreezeConfig
	{
		private const string Section = "FreezeWorld";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> Friction { get; private set; }

		public ConfigEntry<float> Bounciness { get; private set; }

		public ConfigEntry<float> CartSidewaysStiffness { get; private set; }

		public ConfigEntry<float> GripRadius { get; private set; }

		public FreezeConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			GiveKey = cfg.Bind<Key>("FreezeWorld", "GiveKey", (Key)105, "Debug key to add the Freeze World item to your inventory.");
			Uses = cfg.Bind<float>("FreezeWorld", "Uses", 1f, "Number of uses per Freeze World pickup.");
			Duration = cfg.Bind<float>("FreezeWorld", "Duration", 15f, "Seconds the world stays frozen before physics and visuals are restored.");
			Friction = cfg.Bind<float>("FreezeWorld", "Friction", 0.05f, "Surface friction applied to all physics contacts during a freeze (0 = frictionless).");
			Bounciness = cfg.Bind<float>("FreezeWorld", "Bounciness", 0.2f, new ConfigDescription("Surface bounciness applied to all physics contacts during a freeze.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			CartSidewaysStiffness = cfg.Bind<float>("FreezeWorld", "CartSidewaysStiffness", 0.15f, "Sideways friction stiffness for golf cart wheel colliders while frozen (0 = no grip, 1 = normal). Lower values cause more drift.");
			GripRadius = cfg.Bind<float>("FreezeWorld", "GripRadius", 1.5f, "Distance (metres) from the local player's own ball within which normal traction is restored, allowing them to stop and take a shot.");
		}
	}
	public class GlobalConfig
	{
		private readonly Dictionary<int, ConfigEntry<bool>> _itemEnabledEntries = new Dictionary<int, ConfigEntry<bool>>();

		private readonly Dictionary<int, ConfigEntry<bool>> _itemWarningEnabledEntries = new Dictionary<int, ConfigEntry<bool>>();

		public const int PoolAhead = 0;

		public const int PoolLead = 1;

		public const int PoolBehind50 = 2;

		public const int PoolBehind125 = 3;

		public const int PoolBehind200 = 4;

		public const int PoolMobility = 5;

		private static readonly (int pool, string suffix)[] PoolSuffixes = new(int, string)[6]
		{
			(1, "Lead"),
			(2, "Behind50"),
			(3, "Behind125"),
			(4, "Behind200"),
			(0, "Ahead"),
			(5, "Mobility")
		};

		private readonly Dictionary<(int itemType, int pool), ConfigEntry<float>> _poolWeightEntries = new Dictionary<(int, int), ConfigEntry<float>>();

		public ConfigEntry<bool> CustomItemSpawnsEnabled { get; private set; }

		public ConfigEntry<float> CustomItemSpawnRate { get; private set; }

		public ConfigEntry<bool> AllowHotkeyItemGiving { get; private set; }

		public ConfigEntry<bool> BloodEffectsEnabled { get; private set; }

		public ConfigEntry<float> NumInventorySlots { get; private set; }

		public ConfigEntry<bool> FirstPlaceStarEnabled { get; private set; }

		public ConfigEntry<float> FirstPlaceStarHeight { get; private set; }

		public ConfigEntry<Key> SpawnConfigUIKey { get; private set; }

		public ConfigEntry<bool> WarningsEnabled { get; private set; }

		public ConfigEntry<float> WarningDuration { get; private set; }

		public ConfigEntry<bool> WarningShowForSelf { get; private set; }

		public ConfigEntry<bool> WarningSymbolEnabled { get; private set; }

		public ConfigEntry<float> WarningPrefabScale { get; private set; }

		public ConfigEntry<float> WarningSymbolAlpha { get; private set; }

		public ConfigEntry<float> WarningPiPScale { get; private set; }

		public bool GetItemEnabled(ItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			ConfigEntry<bool> value;
			return !_itemEnabledEntries.TryGetValue((int)itemType, out value) || value.Value;
		}

		public void SetItemEnabled(ItemType itemType, bool enabled)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected I4, but got Unknown
			if (_itemEnabledEntries.TryGetValue((int)itemType, out var value))
			{
				value.Value = enabled;
			}
		}

		public bool GetItemWarningEnabled(ItemType itemType)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			ConfigEntry<bool> value;
			return WarningsEnabled.Value && _itemWarningEnabledEntries.TryGetValue((int)itemType, out value) && value.Value;
		}

		public float GetItemPoolWeight(ItemType itemType, int poolIndex)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected I4, but got Unknown
			ConfigEntry<float> value;
			return _poolWeightEntries.TryGetValue(((int)itemType, poolIndex), out value) ? value.Value : 0f;
		}

		public void SetItemPoolWeight(ItemType itemType, int poolIndex, float value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			if (_poolWeightEntries.TryGetValue(((int)itemType, poolIndex), out var value2))
			{
				value2.Value = value;
			}
		}

		public GlobalConfig(ConfigFile cfg)
		{
			CustomItemSpawnsEnabled = cfg.Bind<bool>("IssaPlugin", "Enabled", true, "Master kill-switch for allowing custom items to be spawned without having to set all spawn weights to 0.");
			CustomItemSpawnRate = cfg.Bind<float>("IssaPlugin", "CustomItemSpawnRate", 0.5f, "Global multiplier applied to every custom item's spawn weight. 1.0 = default, 0.5 = half as frequent, 0.0 = never spawn.");
			AllowHotkeyItemGiving = cfg.Bind<bool>("IssaPlugin", "AllowHotkeyItemGiving", false, "Whether non-host clients can use item hotkeys to give themselves items. The host is always exempt.");
			BloodEffectsEnabled = cfg.Bind<bool>("IssaPlugin", "BloodEffectsEnabled", true, "Whether blood splatter effects are shown when players are hit by guns. Each client sets this independently.");
			NumInventorySlots = cfg.Bind<float>("IssaPlugin", "NumInventorySlots", 6f, "Change the number of inventory slots available.");
			FirstPlaceStarEnabled = cfg.Bind<bool>("IssaPlugin", "FirstPlaceStarEnabled", false, "Show a gold star above the first-place player so they are easy to spot.");
			FirstPlaceStarHeight = cfg.Bind<float>("IssaPlugin", "FirstPlaceStarHeight", 1.5f, "Height in Unity units above the player's origin at which the gold star appears.");
			SpawnConfigUIKey = cfg.Bind<Key>("UI", "SpawnConfigUIKey", (Key)27, "Hotkey that opens/closes the Spawn Config GUI panel. The panel lets the host adjust per-pool spawn weights at runtime.");
			Reg(cfg, _itemEnabledEntries, 100, "BaseballBatEnabled", "Baseball Bat");
			Reg(cfg, _itemEnabledEntries, 101, "StealthBomberEnabled", "Stealth Bomber");
			Reg(cfg, _itemEnabledEntries, 102, "PredatorMissileEnabled", "Predator Missile");
			Reg(cfg, _itemEnabledEntries, 103, "AC130Enabled", "AC-130 Gunship");
			Reg(cfg, _itemEnabledEntries, 104, "FreezeEnabled", "Freeze World");
			Reg(cfg, _itemEnabledEntries, 105, "LowGravityEnabled", "Low Gravity");
			Reg(cfg, _itemEnabledEntries, 106, "SniperRifleEnabled", "Sniper Rifle");
			Reg(cfg, _itemEnabledEntries, 107, "DonutEnabled", "Donut");
			Reg(cfg, _itemEnabledEntries, 108, "JavelinEnabled", "Javelin");
			Reg(cfg, _itemEnabledEntries, 109, "StickyGrenadeEnabled", "Sticky Grenade");
			Reg(cfg, _itemEnabledEntries, 110, "BearEnabled", "Bear");
			Reg(cfg, _itemEnabledEntries, 111, "NukeEnabled", "Nuke");
			Reg(cfg, _itemEnabledEntries, 112, "BlackHoleGrenadeEnabled", "Black Hole Grenade");
			Reg(cfg, _itemEnabledEntries, 113, "PlaceableWallEnabled", "Placeable Wall");
			Reg(cfg, _itemEnabledEntries, 114, "AK47Enabled", "AK-47");
			Reg(cfg, _itemEnabledEntries, 115, "HarrierEnabled", "Harrier Jet");
			Reg(cfg, _itemEnabledEntries, 116, "PositionSwapEnabled", "Position Swap");
			Reg(cfg, _itemEnabledEntries, 117, "PoisonJarEnabled", "Poison Jar");
			Reg(cfg, _itemEnabledEntries, 118, "DroneSwarmEnabled", "Drone Swarm");
			Reg(cfg, _itemEnabledEntries, 119, "RedBullEnabled", "Red Bull");
			Reg(cfg, _itemEnabledEntries, 120, "SuperDonutEnabled", "Super Donut");
			Reg(cfg, _itemEnabledEntries, 121, "GravityGunEnabled", "Gravity Gun");
			Reg(cfg, _itemEnabledEntries, 122, "RocketTetherEnabled", "Rocket Tether");
			Reg(cfg, _itemEnabledEntries, 123, "JetpackEnabled", "Jetpack");
			Reg(cfg, _itemEnabledEntries, 124, "TeleporterEnabled", "Teleporter");
			Reg(cfg, _itemEnabledEntries, 125, "SpinachEnabled", "Spinach");
			Reg(cfg, _itemEnabledEntries, 126, "FlamethrowerEnabled", "Flamethrower");
			Reg(cfg, _itemEnabledEntries, 127, "RocketTetherGrenadeEnabled", "Rocket Tether Grenade");
			WarningsEnabled = cfg.Bind<bool>("Warnings", "Enabled", true, "Master toggle for all item-use warning banners and PiP cameras.");
			WarningDuration = cfg.Bind<float>("Warnings", "Duration", 5f, "How long (seconds) each warning banner and PiP camera is displayed.");
			WarningShowForSelf = cfg.Bind<bool>("Warnings", "ShowForSelf", false, "If true, the warning banner and PiP also appear for the player who used the item. Useful for testing.");
			WarningSymbolEnabled = cfg.Bind<bool>("Warnings", "WarningSymbolEnabled", true, "If true, the warning particle effect is shown. Each client can disable it locally.");
			WarningPrefabScale = cfg.Bind<float>("Warnings", "WarningSymbolScale", 0.75f, "Controls the size of the warning prefab.");
			WarningSymbolAlpha = cfg.Bind<float>("Warnings", "WarningSymbolAlpha", 0.5f, "Controls the alpha channel of the start color of the warning prefab.");
			WarningPiPScale = cfg.Bind<float>("Warnings", "PiPScale", 1f, "Scale multiplier for the PiP camera box (base size 320x180). Valid range: 0.5 (160x90) to 2.0 (640x360).");
			RegWarn(cfg, _itemWarningEnabledEntries, 100, "BaseballBatWarning", "Baseball Bat", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 101, "BomberWarning", "Stealth Bomber", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 102, "MissileWarning", "Predator Missile", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 103, "AC130Warning", "AC-130 Gunship", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 104, "FreezeWarning", "Freeze World", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 105, "LowGravityWarning", "Low Gravity", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 106, "SniperRifleWarning", "Sniper Rifle", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 107, "DonutWarning", "Donut", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 108, "JavelinWarning", "Javelin", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 109, "StickyGrenadeWarning", "Sticky Grenade", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 110, "BearWarning", "Bear", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 111, "NukeWarning", "Nuke", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 112, "BlackHoleGrenadeWarning", "Black Hole Grenade", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 113, "PlaceableWallWarning", "Placeable Wall", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 114, "AK47Warning", "AK-47", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 115, "HarrierWarning", "Harrier Jet", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 116, "PositionSwapWarning", "Position Swap", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 117, "PoisonJarWarning", "Poison Jar", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 118, "DroneSwarmWarning", "Drone Swarm", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 119, "RedBullWarning", "Red Bull", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 120, "SuperDonutWarning", "Super Donut", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 121, "GravityGunWarning", "Gravity Gun", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 122, "RocketTetherWarning", "Rocket Tether", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 123, "JetpackWarning", "Jetpack", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 124, "TeleporterWarning", "Teleporter", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 125, "SpinachWarning", "Spinach", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 126, "FlamethrowerWarning", "Flamethrower", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 127, "RocketTetherGrenadeWarning", "Rocket Tether Grenade", defaultOn: false);
			BindAllItemPoolWeights(cfg);
			static void Reg(ConfigFile c, Dictionary<int, ConfigEntry<bool>> map, int id, string key, string label)
			{
				map[id] = c.Bind<bool>("ItemEnabled", key, true, "Whether the " + label + " is enabled and can spawn.");
			}
			static void RegWarn(ConfigFile c, Dictionary<int, ConfigEntry<bool>> map, int id, string key, string label, bool defaultOn)
			{
				map[id] = c.Bind<bool>("ItemWarnings", key, defaultOn, "Show a warning to all other players when " + label + " is used.");
			}
		}

		private void BindAllItemPoolWeights(ConfigFile cfg)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			foreach (CustomItemDefinition allItem in ItemRegistry.AllItems)
			{
				(int, string)[] poolSuffixes = PoolSuffixes;
				for (int i = 0; i < poolSuffixes.Length; i++)
				{
					var (num, text) = poolSuffixes[i];
					_poolWeightEntries[((int)allItem.ItemType, num)] = cfg.Bind<float>("ItemBoxSpawns", allItem.ConfigKeyPrefix + "Weight" + text, allItem.GetDefaultPoolWeight(num), "Spawn weight for " + allItem.DisplayName + " in the '" + text + "' pool. 0 = never spawns in this pool.");
				}
			}
		}
	}
	public class GravityGunConfig
	{
		private const string Section = "GravityGun";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> LockOnRange { get; private set; }

		public ConfigEntry<float> LockOnConeAngleDeg { get; private set; }

		public ConfigEntry<float> TetherRadius { get; private set; }

		public ConfigEntry<float> TetherDuration { get; private set; }

		public ConfigEntry<float> SpringForce { get; private set; }

		public ConfigEntry<float> MaxPullSpeed { get; private set; }

		public ConfigEntry<float> InputSendInterval { get; private set; }

		public GravityGunConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("GravityGun", "GiveKey", (Key)78, "Hotkey to give yourself a Gravity Gun (debug/testing).");
			Uses = cfg.Bind<float>("GravityGun", "Uses", 1f, "Number of uses per Gravity Gun pickup.");
			LockOnRange = cfg.Bind<float>("GravityGun", "LockOnRange", 45f, "Maximum distance (units) at which the Gravity Gun can lock onto a target.");
			LockOnConeAngleDeg = cfg.Bind<float>("GravityGun", "LockOnConeAngleDeg", 40f, "Half-angle (degrees) of the aim cone used to filter lock-on candidates.");
			TetherRadius = cfg.Bind<float>("GravityGun", "TetherRadius", 20f, "Distance (units) at which the target orbits the wielder while tethered.");
			TetherDuration = cfg.Bind<float>("GravityGun", "TetherDuration", 5f, "Maximum tether duration in seconds before automatic release.");
			SpringForce = cfg.Bind<float>("GravityGun", "SpringForce", 12f, "Spring stiffness coefficient; higher values pull the target faster.");
			MaxPullSpeed = cfg.Bind<float>("GravityGun", "MaxPullSpeed", 18f, "Maximum velocity change (m/s) applied to the target per physics tick.");
			InputSendInterval = cfg.Bind<float>("GravityGun", "InputSendInterval", 0.05f, "Interval (seconds) between aim-tick messages sent to the server (~20 Hz).");
		}
	}
	public class HarrierConfig
	{
		private const string Section = "HarrierJet";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> FireInterval { get; private set; }

		public ConfigEntry<float> ApproachDistance { get; private set; }

		public ConfigEntry<float> ApproachSpeed { get; private set; }

		public ConfigEntry<float> DriftSpeed { get; private set; }

		public ConfigEntry<float> HoverRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> RocketJitter { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<float> HitsToDestroy { get; private set; }

		public ConfigEntry<float> CrashExplosionScale { get; private set; }

		public HarrierConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("HarrierJet", "GiveKey", (Key)93, "Debug key to add the Harrier Jet to your inventory.");
			Uses = cfg.Bind<float>("HarrierJet", "Uses", 1f, "Number of Harrier Jet uses per pickup.");
			Altitude = cfg.Bind<float>("HarrierJet", "Altitude", 175f, "Height above the map centre the Harrier hovers at while attacking.");
			Duration = cfg.Bind<float>("HarrierJet", "Duration", 30f, "How many seconds the Harrier remains on-station before flying out.");
			FireInterval = cfg.Bind<float>("HarrierJet", "FireInterval", 2.5f, "Seconds between each autonomous rocket fired by the Harrier.");
			ApproachDistance = cfg.Bind<float>("HarrierJet", "ApproachDistance", 600f, "How far away the Harrier spawns before flying in to its hover point.");
			ApproachSpeed = cfg.Bind<float>("HarrierJet", "ApproachSpeed", 100f, "Speed in units per second during fly-in and fly-out.");
			DriftSpeed = cfg.Bind<float>("HarrierJet", "DriftSpeed", 8f, "Units per second the Harrier drifts toward the player concentration centroid.");
			HoverRadius = cfg.Bind<float>("HarrierJet", "HoverRadius", 30f, "Maximum distance the Harrier can drift from its initial hover centre.");
			ExplosionScale = cfg.Bind<float>("HarrierJet", "ExplosionScale", 1.5f, "Scale multiplier applied to each rocket explosion from the Harrier.");
			RocketJitter = cfg.Bind<float>("HarrierJet", "RocketJitter", 4f, "Angular spread in degrees applied to each rocket. Higher = less accurate.");
			FriendlyFire = cfg.Bind<bool>("HarrierJet", "FriendlyFire", false, "If false, the Harrier will not target the player who summoned it.");
			HitsToDestroy = cfg.Bind<float>("HarrierJet", "HitsToDestroy", 3f, "Number of direct rocket hits required to shoot down the Harrier. Set to 0 to make it invincible.");
			CrashExplosionScale = cfg.Bind<float>("HarrierJet", "CrashExplosionScale", 3f, "Scale multiplier for the explosion spawned when the Harrier crashes into the ground.");
		}
	}
	public class HunterDroneConfig
	{
		private const string Section = "HunterDrone";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> LaunchSpeed { get; private set; }

		public ConfigEntry<float> Acceleration { get; private set; }

		public ConfigEntry<float> HomingStopDistance { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> ArmDelay { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public HunterDroneConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("HunterDrone", "GiveKey", (Key)80, "Debug key to add the Hunter Drone item to your inventory.");
			Uses = cfg.Bind<float>("HunterDrone", "Uses", 1f, "Number of uses per Hunter Drone pickup.");
			LaunchSpeed = cfg.Bind<float>("HunterDrone", "LaunchSpeed", 90f, "Initial flight speed of the drone in metres per second.");
			Acceleration = cfg.Bind<float>("HunterDrone", "Acceleration", 25f, "How many metres per second the drone's speed increases each second.");
			HomingStopDistance = cfg.Bind<float>("HunterDrone", "HomingStopDistance", 10f, "Distance from the target (metres) at which the drone locks its aim point and flies straight, giving the target a brief chance to dodge. Set to 0 to always track the target.");
			ArrivalRadius = cfg.Bind<float>("HunterDrone", "ArrivalRadius", 2.5f, "Distance from the aim point (metres) at which the drone detonates.");
			ExplosionScale = cfg.Bind<float>("HunterDrone", "ExplosionScale", 1.2f, "Scale multiplier for the drone impact explosion radius and force.");
			ArmDelay = cfg.Bind<float>("HunterDrone", "ArmDelay", 0.2f, "Seconds after launch before the drone starts checking for collision. Prevents the drone from detonating on the thrower immediately after being thrown.");
			FriendlyFire = cfg.Bind<bool>("HunterDrone", "FriendlyFire", false, "If true, the drone may target the player who threw it.");
			AttackFinishedPlayers = cfg.Bind<bool>("HunterDrone", "AttackFinishedPlayers", false, "If true, the drone may target players who have already holed out.");
		}
	}
	public class JavelinConfig
	{
		private const string Section = "Javelin";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ApexHeight { get; private set; }

		public ConfigEntry<float> AscentSpeed { get; private set; }

		public ConfigEntry<float> DiveSpeed { get; private set; }

		public ConfigEntry<float> DiveAcceleration { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> Timeout { get; private set; }

		public ConfigEntry<float> ExplosionVfxDuration { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public JavelinConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Javelin", "GiveKey", (Key)87, "Debug key to add the Javelin to your inventory.");
			Uses = cfg.Bind<float>("Javelin", "Uses", 1f, "Number of Javelin uses per pickup.");
			ApexHeight = cfg.Bind<float>("Javelin", "ApexHeight", 80f, "How many units above the launch point the rocket climbs before turning.");
			AscentSpeed = cfg.Bind<float>("Javelin", "AscentSpeed", 35f, "Speed in units per second during the upward climb phase.");
			DiveSpeed = cfg.Bind<float>("Javelin", "DiveSpeed", 55f, "Initial speed in units per second when the rocket begins its dive.");
			DiveAcceleration = cfg.Bind<float>("Javelin", "DiveAcceleration", 25f, "Additional speed gained per second during the dive phase.");
			ArrivalRadius = cfg.Bind<float>("Javelin", "ArrivalRadius", 3f, "Distance from the target position at which the rocket detonates.");
			Timeout = cfg.Bind<float>("Javelin", "Timeout", 20f, "Maximum seconds before the rocket force-detonates if it hasn't hit yet.");
			ExplosionVfxDuration = cfg.Bind<float>("Javelin", "ExplosionVfxDuration", 5f, "Seconds before the Javelin explosion VFX prefab is destroyed on each client.");
			ExplosionScale = cfg.Bind<float>("Explosions", "JavelinScale", 3.5f, "Multiplier for Javelin explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class JetpackConfig
	{
		private const string Section = "Jetpack";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FuelPerUse { get; private set; }

		public ConfigEntry<float> ThrustForce { get; private set; }

		public ConfigEntry<bool> UseJumpToActivate { get; private set; }

		public JetpackConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Jetpack", "GiveKey", (Key)69, "Hotkey to give yourself a Jetpack (debug/testing).");
			Uses = cfg.Bind<float>("Jetpack", "Uses", 1f, "Number of fuel canisters per Jetpack pickup. Each canister provides JetpackFuelPerUse seconds of thrust.");
			FuelPerUse = cfg.Bind<float>("Jetpack", "FuelPerUse", 1f, "Seconds of thrust provided by each fuel canister. When exhausted, one use is consumed.");
			ThrustForce = cfg.Bind<float>("Jetpack", "ThrustForce", 35f, "Upward acceleration (m/s²) applied each physics step while thrusting. Uses ForceMode.Acceleration.");
			UseJumpToActivate = cfg.Bind<bool>("Jetpack", "UseJumpToActivate", true, "When enabled, pressing Space (Jump) activates the jetpack even if it is not the active item. The fuel gauge is visible whenever the jetpack is in inventory.");
		}
	}
	public class LowGravityConfig
	{
		private const string Section = "LowGravity";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> Scale { get; private set; }

		public LowGravityConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("LowGravity", "GiveKey", (Key)84, "Debug key to add the Low Gravity item to your inventory.");
			Uses = cfg.Bind<float>("LowGravity", "Uses", 1f, "Number of uses per Low Gravity pickup.");
			Duration = cfg.Bind<float>("LowGravity", "Duration", 20f, "Seconds the reduced gravity lasts before physics is restored.");
			Scale = cfg.Bind<float>("LowGravity", "GravityScale", 0.25f, "Fraction of normal gravity applied during the effect (e.g. 0.25 = 25%). Affects golf balls (Rigidbody) and player fall/jump height equally, since PlayerMovement reads Physics.gravity directly.");
		}
	}
	public static class ModConfig
	{
		public static GlobalConfig Global { get; private set; }

		public static BaseballBatConfig BaseballBat { get; private set; }

		public static StealthBomberConfig StealthBomber { get; private set; }

		public static PredatorMissileConfig PredatorMissile { get; private set; }

		public static AC130Config AC130 { get; private set; }

		public static FreezeConfig Freeze { get; private set; }

		public static LowGravityConfig LowGravity { get; private set; }

		public static SniperRifleConfig SniperRifle { get; private set; }

		public static DonutConfig Donut { get; private set; }

		public static JavelinConfig Javelin { get; private set; }

		public static StickyGrenadeConfig StickyGrenade { get; private set; }

		public static BearConfig Bear { get; private set; }

		public static NukeConfig Nuke { get; private set; }

		public static BlackHoleGrenadeConfig BlackHoleGrenade { get; private set; }

		public static PlaceableWallConfig PlaceableWall { get; private set; }

		public static AK47Config AK47 { get; private set; }

		public static HarrierConfig Harrier { get; private set; }

		public static PositionSwapConfig PositionSwap { get; private set; }

		public static PoisonJarConfig PoisonJar { get; private set; }

		public static DroneSwarmConfig DroneSwarm { get; private set; }

		public static RedBullConfig RedBull { get; private set; }

		public static SuperDonutConfig SuperDonut { get; private set; }

		public static GravityGunConfig GravityGun { get; private set; }

		public static RocketTetherConfig RocketTether { get; private set; }

		public static JetpackConfig Jetpack { get; private set; }

		public static TeleporterConfig Teleporter { get; private set; }

		public static SpinachConfig Spinach { get; private set; }

		public static FlamethrowerConfig Flamethrower { get; private set; }

		public static RocketTetherGrenadeConfig RocketTetherGrenade { get; private set; }

		public static WindStormConfig WindStorm { get; private set; }

		public static HunterDroneConfig HunterDrone { get; private set; }

		public static void Initialize(ConfigFile cfg)
		{
			Global = new GlobalConfig(cfg);
			BaseballBat = new BaseballBatConfig(cfg, Global);
			StealthBomber = new StealthBomberConfig(cfg, Global);
			PredatorMissile = new PredatorMissileConfig(cfg, Global);
			AC130 = new AC130Config(cfg, Global);
			Freeze = new FreezeConfig(cfg, Global);
			LowGravity = new LowGravityConfig(cfg, Global);
			SniperRifle = new SniperRifleConfig(cfg, Global);
			Donut = new DonutConfig(cfg, Global);
			Javelin = new JavelinConfig(cfg, Global);
			StickyGrenade = new StickyGrenadeConfig(cfg, Global);
			Bear = new BearConfig(cfg, Global);
			Nuke = new NukeConfig(cfg, Global);
			BlackHoleGrenade = new BlackHoleGrenadeConfig(cfg, Global);
			PlaceableWall = new PlaceableWallConfig(cfg, Global);
			AK47 = new AK47Config(cfg, Global);
			Harrier = new HarrierConfig(cfg, Global);
			PositionSwap = new PositionSwapConfig(cfg, Global);
			PoisonJar = new PoisonJarConfig(cfg, Global);
			DroneSwarm = new DroneSwarmConfig(cfg, Global);
			RedBull = new RedBullConfig(cfg, Global);
			SuperDonut = new SuperDonutConfig(cfg, Global);
			GravityGun = new GravityGunConfig(cfg, Global);
			RocketTether = new RocketTetherConfig(cfg, Global);
			Jetpack = new JetpackConfig(cfg, Global);
			Teleporter = new TeleporterConfig(cfg, Global);
			Spinach = new SpinachConfig(cfg, Global);
			Flamethrower = new FlamethrowerConfig(cfg, Global);
			RocketTetherGrenade = new RocketTetherGrenadeConfig(cfg, Global);
			WindStorm = new WindStormConfig(cfg, Global);
			HunterDrone = new HunterDroneConfig(cfg, Global);
		}

		public static bool GetItemEnabled(ItemType itemType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemEnabled(itemType);
		}

		public static void SetItemEnabled(ItemType itemType, bool enabled)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Global.SetItemEnabled(itemType, enabled);
		}

		public static float GetItemPoolWeight(ItemType t, int pool)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemPoolWeight(t, pool);
		}

		public static void SetItemPoolWeight(ItemType t, int pool, float v)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Global.SetItemPoolWeight(t, pool, v);
		}

		public static bool GetItemWarningEnabled(ItemType itemType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemWarningEnabled(itemType);
		}
	}
	public class NukeConfig
	{
		private const string Section = "Nuke";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> DropHeight { get; private set; }

		public ConfigEntry<float> DropSpeed { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> SkyBlastForce { get; private set; }

		public ConfigEntry<float> SkyBlastRadius { get; private set; }

		public ConfigEntry<float> SkyBlastVerticalBias { get; private set; }

		public ConfigEntry<float> ExplosionVfxDuration { get; private set; }

		public ConfigEntry<float> ExplosionVfxScale { get; private set; }

		public ConfigEntry<bool> ExcludeThrower { get; private set; }

		public NukeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Nuke", "GiveKey", (Key)90, "Debug key to add the Nuke to your inventory.");
			Uses = cfg.Bind<float>("Nuke", "Uses", 1f, "Number of uses per Nuke pickup.");
			DropHeight = cfg.Bind<float>("Nuke", "DropHeight", 300f, "Units above the map centre at which the nuke bomb spawns.");
			DropSpeed = cfg.Bind<float>("Nuke", "DropSpeed", 80f, "Downward speed of the falling nuke bomb in units per second.");
			SkyBlastForce = cfg.Bind<float>("Nuke", "SkyBlastForce", 350f, "Extra upward impulse force applied to all rigidbodies within SkyBlastRadius after detonation. Stacks on top of the standard explosion knockback.");
			SkyBlastRadius = cfg.Bind<float>("Nuke", "SkyBlastRadius", 350f, "Radius (units) of the secondary sky blast. Should be large enough to cover the whole map so no one escapes.");
			SkyBlastVerticalBias = cfg.Bind<float>("Nuke", "SkyBlastVerticalBias", 0.7f, "Controls how much of the sky blast force goes upward versus outward (0 = all outward, 1 = all straight up). The horizontal direction is still relative to the explosion point, so players are pushed away from the blast site.");
			ExplosionVfxDuration = cfg.Bind<float>("Nuke", "ExplosionVfxDuration", 8f, "Seconds before the nuke explosion VFX prefab is destroyed on each client.");
			ExplosionVfxScale = cfg.Bind<float>("Nuke", "ExplosionVfxScale", 5f, "Uniform scale applied to the nuke explosion VFX transform on each client. Increase this to make the particle systems appear larger.");
			ExcludeThrower = cfg.Bind<bool>("Nuke", "ExcludeThrower", true, "If true, the sky blast does not apply force to the player who activated the nuke.");
			ExplosionScale = cfg.Bind<float>("Explosions", "NukeScale", 6f, "Explosion scale multiplier for the Nuke's detonation rocket. Affects blast radius, knockback force, and VFX size.");
		}
	}
	public class PlaceableWallConfig
	{
		private const string Section = "PlaceableWall";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> MaxPlacementDistance { get; private set; }

		public ConfigEntry<float> MinHoleDistance { get; private set; }

		public ConfigEntry<float> HealthPoints { get; private set; }

		public ConfigEntry<float> VelocityImpactFactor { get; private set; }

		public ConfigEntry<float> TorsionMultiplier { get; private set; }

		public ConfigEntry<float> RotationStep { get; private set; }

		public ConfigEntry<float> DebrisLifetime { get; private set; }

		public ConfigEntry<float> RocketExplosionForce { get; private set; }

		public ConfigEntry<float> DamageGolfClub { get; private set; }

		public ConfigEntry<float> DamageBaseballBat { get; private set; }

		public PlaceableWallConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("PlaceableWall", "GiveKey", (Key)92, "Debug key to add the Placeable Wall to your inventory.");
			Uses = cfg.Bind<float>("PlaceableWall", "Uses", 1f, "Number of wall placements per pickup.");
			MaxPlacementDistance = cfg.Bind<float>("PlaceableWall", "MaxPlacementDistance", 20f, "Maximum distance (units) from the player's camera at which a wall can be placed.");
			MinHoleDistance = cfg.Bind<float>("PlaceableWall", "MinHoleDistance", 3f, "Minimum XZ distance (units) from the hole centre that a wall may be placed. Prevents blocking the hole entirely. Set to 0 to disable the check.");
			HealthPoints = cfg.Bind<float>("PlaceableWall", "HealthPoints", 3f, "Number of golf club or baseball bat hits required to destroy the wall. Rocket hits always destroy in one shot.");
			VelocityImpactFactor = cfg.Bind<float>("PlaceableWall", "VelocityImpactFactor", 2.5f, "Degree to which the velocity of an object colliding with the placeable wall will damage it. Default: 2.5.");
			TorsionMultiplier = cfg.Bind<float>("PlaceableWall", "TorsionMultiplier", 0.002f, "Degree to which torque (spin) damages the bricks of the placeable wall. Default: 0.002.");
			RotationStep = cfg.Bind<float>("PlaceableWall", "RotationStep", 45f, "Degrees the wall rotates per scroll-wheel tick during the placement preview. Scroll up rotates clockwise, scroll down rotates counter-clockwise.");
			DebrisLifetime = cfg.Bind<float>("PlaceableWall", "DebrisLifetime", 30f, "Seconds before detached wall debris (bricks/pillars) are automatically destroyed.");
			RocketExplosionForce = cfg.Bind<float>("PlaceableWall", "RocketExplosionForce", 600f, "Impulse force (per brick) applied by a rocket explosion to detached wall debris.");
			DamageGolfClub = cfg.Bind<float>("PlaceableWall", "DamageGolfClub", 1f, "Damage dealt to a wall chunk per golf club swing.");
			DamageBaseballBat = cfg.Bind<float>("PlaceableWall", "DamageBaseballBat", 2f, "Damage dealt to a wall chunk per baseball bat swing.");
		}
	}
	public class PoisonJarConfig
	{
		private const string JarSection = "PoisonJar";

		private const string OverlaySection = "PoisonOverlay";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> Radius { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<bool> GhostEnabled { get; private set; }

		public ConfigEntry<float> GhostOffsetX { get; private set; }

		public ConfigEntry<float> GhostOffsetY { get; private set; }

		public ConfigEntry<float> GhostAlpha { get; private set; }

		public ConfigEntry<float> RollFreq1 { get; private set; }

		public ConfigEntry<float> RollAmp1 { get; private set; }

		public ConfigEntry<float> RollFreq2 { get; private set; }

		public ConfigEntry<float> RollAmp2 { get; private set; }

		public ConfigEntry<float> RollFreq3 { get; private set; }

		public ConfigEntry<float> RollAmp3 { get; private set; }

		public ConfigEntry<float> FovFreq1 { get; private set; }

		public ConfigEntry<float> FovAmp1 { get; private set; }

		public ConfigEntry<float> FovFreq2 { get; private set; }

		public ConfigEntry<float> FovAmp2 { get; private set; }

		public ConfigEntry<float> VigPulseFreq1 { get; private set; }

		public ConfigEntry<float> VigPulseFreq2 { get; private set; }

		public ConfigEntry<float> VigBaseAlpha { get; private set; }

		public ConfigEntry<float> VigPulseAmp1 { get; private set; }

		public ConfigEntry<float> VigPulseAmp2 { get; private set; }

		public ConfigEntry<float> TintBaseAlpha { get; private set; }

		public ConfigEntry<float> TintPulseAmp { get; private set; }

		public ConfigEntry<float> TintPulseFreq { get; private set; }

		public ConfigEntry<bool> AimNoiseEnabled { get; private set; }

		public ConfigEntry<float> AimNoiseYawAmp { get; private set; }

		public ConfigEntry<float> AimNoiseYawFreq { get; private set; }

		public ConfigEntry<float> AimNoisePitchAmp { get; private set; }

		public ConfigEntry<float> AimNoisePitchFreq { get; private set; }

		public PoisonJarConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("PoisonJar", "GiveKey", (Key)82, "Debug key to add the Poison Jar to your inventory.");
			Uses = cfg.Bind<float>("PoisonJar", "Uses", 1f, "Number of uses per Poison Jar pickup.");
			ThrowSpeed = cfg.Bind<float>("PoisonJar", "ThrowSpeed", 18f, "Initial throw speed in metres per second.");
			LobAngle = cfg.Bind<float>("PoisonJar", "LobAngle", 0.35f, "Upward component added to the throw direction (0 = flat, 1 = 45° up).");
			Radius = cfg.Bind<float>("PoisonJar", "Radius", 2f, "Radius in metres of the poison AoE. Also scales the splash VFX.");
			Duration = cfg.Bind<float>("PoisonJar", "Duration", 10f, "How long (seconds) the poison visual lasts on affected players.");
			GhostEnabled = cfg.Bind<bool>("PoisonOverlay", "GhostEnabled", true, "Enable the double-vision ghost image.");
			GhostOffsetX = cfg.Bind<float>("PoisonOverlay", "GhostOffsetX", 0.04f, "Horizontal ghost offset as a fraction of screen width (e.g. 0.04 = 4%).");
			GhostOffsetY = cfg.Bind<float>("PoisonOverlay", "GhostOffsetY", 0.01f, "Vertical ghost offset as a fraction of screen height.");
			GhostAlpha = cfg.Bind<float>("PoisonOverlay", "GhostAlpha", 0.35f, "Opacity of the ghost image (0–1).");
			RollFreq1 = cfg.Bind<float>("PoisonOverlay", "RollFreq1", 1f, "Primary lean frequency (Hz).");
			RollAmp1 = cfg.Bind<float>("PoisonOverlay", "RollAmp1", 4.5f, "Primary lean amplitude (degrees).");
			RollFreq2 = cfg.Bind<float>("PoisonOverlay", "RollFreq2", 0.28f, "Slow drift frequency (Hz).");
			RollAmp2 = cfg.Bind<float>("PoisonOverlay", "RollAmp2", 12f, "Slow drift amplitude (degrees).");
			RollFreq3 = cfg.Bind<float>("PoisonOverlay", "RollFreq3", 1.35f, "Subtle tremor frequency (Hz).");
			RollAmp3 = cfg.Bind<float>("PoisonOverlay", "RollAmp3", 5f, "Subtle tremor amplitude (degrees).");
			FovFreq1 = cfg.Bind<float>("PoisonOverlay", "FovFreq1", 0.5f, "Primary FOV breathing frequency (Hz).");
			FovAmp1 = cfg.Bind<float>("PoisonOverlay", "FovAmp1", 5f, "Primary FOV breathing amplitude (degrees).");
			FovFreq2 = cfg.Bind<float>("PoisonOverlay", "FovFreq2", 1.2f, "Secondary FOV breathing frequency (Hz).");
			FovAmp2 = cfg.Bind<float>("PoisonOverlay", "FovAmp2", 8f, "Secondary FOV breathing amplitude (degrees).");
			VigPulseFreq1 = cfg.Bind<float>("PoisonOverlay", "VigPulseFreq1", 1.2f, "Vignette primary pulse frequency (Hz).");
			VigPulseFreq2 = cfg.Bind<float>("PoisonOverlay", "VigPulseFreq2", 6f, "Vignette secondary pulse frequency (Hz).");
			VigBaseAlpha = cfg.Bind<float>("PoisonOverlay", "VigBaseAlpha", 0.5f, "Vignette base opacity (0–1).");
			VigPulseAmp1 = cfg.Bind<float>("PoisonOverlay", "VigPulseAmp1", 0.15f, "Vignette primary pulse amplitude.");
			VigPulseAmp2 = cfg.Bind<float>("PoisonOverlay", "VigPulseAmp2", 0.08f, "Vignette secondary pulse amplitude.");
			TintBaseAlpha = cfg.Bind<float>("PoisonOverlay", "TintBaseAlpha", 0.1f, "Full-screen tint base opacity (0–1).");
			TintPulseAmp = cfg.Bind<float>("PoisonOverlay", "TintPulseAmp", 0.05f, "Full-screen tint pulse amplitude.");
			TintPulseFreq = cfg.Bind<float>("PoisonOverlay", "TintPulseFreq", 3f, "Full-screen tint pulse frequency (Hz).");
			AimNoiseEnabled = cfg.Bind<bool>("PoisonOverlay", "AimNoiseEnabled", true, "If true, adds sinusoidal yaw and pitch drift to make aiming harder while poisoned.");
			AimNoiseYawAmp = cfg.Bind<float>("PoisonOverlay", "AimNoiseYawAmp", 2.5f, "Yaw (horizontal) aim drift amplitude in degrees.");
			AimNoiseYawFreq = cfg.Bind<float>("PoisonOverlay", "AimNoiseYawFreq", 0.8f, "Yaw aim drift frequency in Hz.");
			AimNoisePitchAmp = cfg.Bind<float>("PoisonOverlay", "AimNoisePitchAmp", 1.5f, "Pitch (vertical) aim drift amplitude in degrees.");
			AimNoisePitchFreq = cfg.Bind<float>("PoisonOverlay", "AimNoisePitchFreq", 1.1f, "Pitch aim drift frequency in Hz.");
		}
	}
	public class PositionSwapConfig
	{
		private const string Section = "PositionSwap";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Delay { get; private set; }

		public PositionSwapConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("PositionSwap", "GiveKey", (Key)81, "Debug key to add the Position Swap item to your inventory.");
			Uses = cfg.Bind<float>("PositionSwap", "Uses", 1f, "Number of uses per Position Swap pickup.");
			Delay = cfg.Bind<float>("PositionSwap", "Delay", 3f, "Seconds between selecting a swap target and the swap executing. During this time a warning orb appears under both players.");
		}
	}
	public class PredatorMissileConfig
	{
		private const string Section = "PredatorMissile";

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> FallSpeed { get; private set; }

		public ConfigEntry<float> SteerSpeed { get; private set; }

		public ConfigEntry<float> Timeout { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public PredatorMissileConfig(ConfigFile cfg, GlobalConfig global)
		{
			Altitude = cfg.Bind<float>("PredatorMissile", "Altitude", 175f, "Height above the player where the missile spawns.");
			FallSpeed = cfg.Bind<float>("PredatorMissile", "FallSpeed", 50f, "Downward speed of the missile in units per second.");
			SteerSpeed = cfg.Bind<float>("PredatorMissile", "SteerSpeed", 35f, "Horizontal steering speed when directing the missile.");
			Timeout = cfg.Bind<float>("PredatorMissile", "Timeout", 15f, "Maximum seconds before the missile auto-detonates.");
			Uses = cfg.Bind<float>("PredatorMissile", "Uses", 1f, "Number of missile uses per pickup.");
			GiveKey = cfg.Bind<Key>("PredatorMissile", "GiveKey", (Key)102, "Key to press to add the predator missile to your inventory.");
			ExplosionScale = cfg.Bind<float>("Explosions", "PredatorMissileScale", 3f, "Multiplier for Predator Missile explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class RedBullConfig
	{
		private const string Section = "RedBull";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> ExtraSpeedMultiplier { get; private set; }

		public ConfigEntry<float> JumpBonus { get; private set; }

		public ConfigEntry<float> DispenserChance { get; private set; }

		public RedBullConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("RedBull", "GiveKey", (Key)79, "Hotkey to give yourself a Red Bull (debug/testing).");
			Uses = cfg.Bind<float>("RedBull", "Uses", 1f, "Number of uses per Red Bull item.");
			Duration = cfg.Bind<float>("RedBull", "Duration", 10f, "How long the Red Bull speed and jump boost lasts (seconds).");
			ExtraSpeedMultiplier = cfg.Bind<float>("RedBull", "ExtraSpeedMultiplier", 1.625f, "Additional speed multiplier applied on top of the coffee speed-boost factor while Red Bull is active.");
			JumpBonus = cfg.Bind<float>("RedBull", "JumpBonus", 10f, "Extra upward velocity (m/s) added to each jump while Red Bull is active.");
			DispenserChance = cfg.Bind<float>("RedBull", "DispenserChance", 0.25f, "Probability (0–1) that the coffee dispenser gives a Red Bull instead of a coffee. 0 = never, 1 = always.");
		}
	}
	public class RocketTetherConfig
	{
		private const string Section = "RocketTether";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> LockOnRange { get; private set; }

		public ConfigEntry<float> LockOnConeAngleDeg { get; private set; }

		public ConfigEntry<float> TetherDuration { get; private set; }

		public ConfigEntry<float> SpringForce { get; private set; }

		public ConfigEntry<float> MaxPullSpeed { get; private set; }

		public ConfigEntry<float> NaturalLength { get; private set; }

		public ConfigEntry<float> RocketSpeed { get; private set; }

		public ConfigEntry<float> ExplosionForce { get; private set; }

		public ConfigEntry<float> ExplosionRadius { get; private set; }

		public RocketTetherConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("RocketTether", "GiveKey", (Key)79, "Hotkey to give yourself a Rocket Tether (debug/testing).");
			Uses = cfg.Bind<float>("RocketTether", "Uses", 1f, "Number of uses per Rocket Tether pickup.");
			LockOnRange = cfg.Bind<float>("RocketTether", "LockOnRange", 40f, "Maximum distance (units) at which the Rocket Tether can lock onto a target.");
			LockOnConeAngleDeg = cfg.Bind<float>("RocketTether", "LockOnConeAngleDeg", 60f, "Full angle (degrees) of the aim cone used to filter lock-on candidates.");
			TetherDuration = cfg.Bind<float>("RocketTether", "TetherDuration", 8f, "Duration in seconds before the tether automatically disconnects.");
			SpringForce = cfg.Bind<float>("RocketTether", "SpringForce", 5f, "Spring stiffness coefficient; multiplied by stretch distance to compute pull speed.");
			MaxPullSpeed = cfg.Bind<float>("RocketTether", "MaxPullSpeed", 20f, "Maximum velocity change (m/s) applied to each player per physics tick.");
			NaturalLength = cfg.Bind<float>("RocketTether", "NaturalLength", 5f, "Distance (units) below which no force is applied. Set >0 for a rope with slack.");
			RocketSpeed = cfg.Bind<float>("RocketTether", "RocketSpeed", 35f, "Upward speed (m/s) of the rocket during its flight.");
			ExplosionForce = cfg.Bind<float>("RocketTether", "ExplosionForce", 100f, "Peak velocity change (m/s, VelocityChange) applied at the explosion centre.");
			ExplosionRadius = cfg.Bind<float>("RocketTether", "ExplosionRadius", 50f, "Radius (units) within which the explosion affects nearby players.");
		}
	}
	public class RocketTetherGrenadeConfig
	{
		private const string Section = "RocketTetherGrenade";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<bool> ExcludeThrower { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> BlastRadius { get; private set; }

		public ConfigEntry<int> MaxVictims { get; private set; }

		public ConfigEntry<float> TetherDuration { get; private set; }

		public ConfigEntry<float> RocketSpeed { get; private set; }

		public ConfigEntry<float> SpringForce { get; private set; }

		public ConfigEntry<float> MaxPullSpeed { get; private set; }

		public ConfigEntry<float> NaturalLength { get; private set; }

		public ConfigEntry<float> ExplosionForce { get; private set; }

		public ConfigEntry<float> ExplosionRadius { get; private set; }

		public RocketTetherGrenadeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("RocketTetherGrenade", "GiveKey", (Key)0, "Hotkey to give yourself a Rocket Tether Grenade (debug/testing).");
			Uses = cfg.Bind<float>("RocketTetherGrenade", "Uses", 1f, "Number of uses per Rocket Tether Grenade pickup.");
			ThrowSpeed = cfg.Bind<float>("RocketTetherGrenade", "ThrowSpeed", 18f, "Initial speed (m/s) of the thrown grenade.");
			LobAngle = cfg.Bind<float>("RocketTetherGrenade", "LobAngle", 0.4f, "Upward angle added to the camera forward direction when throwing (0 = flat, 1 = straight up).");
			BlastRadius = cfg.Bind<float>("RocketTetherGrenade", "BlastRadius", 12f, "Radius (units) within which players are tethered on landing.");
			MaxVictims = cfg.Bind<int>("RocketTetherGrenade", "MaxVictims", 4, "Maximum number of players that can be simultaneously tethered by one grenade.");
			ExcludeThrower = cfg.Bind<bool>("RocketTetherGrenade", "ExcludeThrower", true, "If true, the thrower cannot tether themselves with a grenade.");
			TetherDuration = cfg.Bind<float>("RocketTetherGrenade", "TetherDuration", 6f, "Duration (seconds) before each victim's rocket explodes.");
			RocketSpeed = cfg.Bind<float>("RocketTetherGrenade", "RocketSpeed", 35f, "Upward speed (m/s) of each victim's rocket during its flight.");
			SpringForce = cfg.Bind<float>("RocketTetherGrenade", "SpringForce", 5f, "Spring stiffness coefficient; multiplied by stretch distance to compute pull speed.");
			MaxPullSpeed = cfg.Bind<float>("RocketTetherGrenade", "MaxPullSpeed", 20f, "Maximum velocity change (m/s) applied to each victim per physics tick.");
			NaturalLength = cfg.Bind<float>("RocketTetherGrenade", "NaturalLength", 5f, "Distance (units) below which no pull force is applied (rope slack).");
			ExplosionForce = cfg.Bind<float>("RocketTetherGrenade", "ExplosionForce", 80f, "Peak velocity change (m/s, VelocityChange) at each victim's explosion centre.");
			ExplosionRadius = cfg.Bind<float>("RocketTetherGrenade", "ExplosionRadius", 50f, "Radius (units) within which each victim's explosion affects nearby players.");
		}
	}
	public class SniperRifleConfig
	{
		private const string Section = "SniperRifle";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> MaxAimingDistance { get; private set; }

		public ConfigEntry<float> MaxShotDistance { get; private set; }

		public ConfigEntry<float> ScopedInaccuracy { get; private set; }

		public ConfigEntry<float> HipFireInaccuracy { get; private set; }

		public ConfigEntry<float> ZoomFov { get; private set; }

		public ConfigEntry<float> ZoomSpeed { get; private set; }

		public ConfigEntry<float> ShotDuration { get; private set; }

		public ConfigEntry<float> MinZoomFov { get; private set; }

		public ConfigEntry<float> MaxZoomFov { get; private set; }

		public ConfigEntry<float> ScrollSensitivity { get; private set; }

		public ConfigEntry<float> ScreenShakeIntensity { get; private set; }

		public SniperRifleConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("SniperRifle", "GiveKey", (Key)85, "Debug key to add the Sniper Rifle to your inventory.");
			Uses = cfg.Bind<float>("SniperRifle", "Uses", 5f, "Number of shots per Sniper Rifle pickup.");
			MaxAimingDistance = cfg.Bind<float>("SniperRifle", "MaxAimingDistance", 1000f, "Maximum distance (units) the aim-point raycast travels when computing where the barrel points.");
			MaxShotDistance = cfg.Bind<float>("SniperRifle", "MaxShotDistance", 1000f, "Maximum distance (units) the bullet raycast travels before missing.");
			ScopedInaccuracy = cfg.Bind<float>("SniperRifle", "ScopedInaccuracy", 0.05f, "Maximum random angular deviation (degrees) when firing while scoped. Lower = more precise.");
			HipFireInaccuracy = cfg.Bind<float>("SniperRifle", "HipFireInaccuracy", 3f, "Maximum random angular deviation (degrees) when firing from the hip (not scoped).");
			ZoomFov = cfg.Bind<float>("SniperRifle", "ZoomFov", 15f, "Camera field of view while the scope is active. Lower values zoom in more.");
			ZoomSpeed = cfg.Bind<float>("SniperRifle", "ZoomSpeed", 10f, "Speed at which the camera lerps to and from the scoped FOV.");
			ShotDuration = cfg.Bind<float>("SniperRifle", "ShotDuration", 0.6f, "Seconds the shot animation plays before the item use state resets.");
			MinZoomFov = cfg.Bind<float>("SniperRifle", "MinZoomFov", 5f, "Minimum FOV reachable by scrolling in (maximum zoom). Lower = more zoomed.");
			MaxZoomFov = cfg.Bind<float>("SniperRifle", "MaxZoomFov", 40f, "Maximum FOV reachable by scrolling out (minimum zoom). Must be above MinZoomFov.");
			ScrollSensitivity = cfg.Bind<float>("SniperRifle", "ScrollSensitivity", 5f, "FOV units changed per scroll notch. Higher values zoom faster.");
			ScreenShakeIntensity = cfg.Bind<float>("SniperRifle", "ScreenShakeIntensity", 0.65f, "Intensity of the screen shake when firing the Sniper Rifle. 0 disables it. Higher values shake more.");
		}
	}
	public class SpinachConfig
	{
		private const string Section = "Spinach";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> PowerMultiplier { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public SpinachConfig(ConfigFile cfg, GlobalConfig global)
		{
			Duration = cfg.Bind<float>("Spinach", "Duration", 30f, "Duration in seconds of the spinach.");
			PowerMultiplier = cfg.Bind<float>("Spinach", "PowerMultiplier", 2.5f, "Swing power multiplier.");
			Uses = cfg.Bind<float>("Spinach", "Uses", 1f, "Number of uses");
			GiveKey = cfg.Bind<Key>("Spinach", "GiveKey", (Key)99, "Key to press to get the spinach item.");
		}
	}
	public class StealthBomberConfig
	{
		private const string Section = "StealthBomber";

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> Speed { get; private set; }

		public ConfigEntry<float> RocketInterval { get; private set; }

		public ConfigEntry<float> Spread { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> WaitTime { get; private set; }

		public ConfigEntry<float> StripLength { get; private set; }

		public ConfigEntry<float> RocketAngularJitter { get; private set; }

		public ConfigEntry<float> RocketSpawnDepth { get; private set; }

		public ConfigEntry<float> TargetingZoomSpeed { get; private set; }

		public ConfigEntry<float> TargetMoveSpeed { get; private set; }

		public ConfigEntry<float> TargetRotateSpeed { get; private set; }

		public ConfigEntry<float> ApproachDistance { get; private set; }

		public ConfigEntry<float> HitsToDestroy { get; private set; }

		public ConfigEntry<float> CrashImpactForce { get; private set; }

		public ConfigEntry<float> CrashDownwardForce { get; private set; }

		public ConfigEntry<float> CrashTorque { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public StealthBomberConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			Altitude = cfg.Bind<float>("StealthBomber", "Altitude", 60f, "Height above the map the bombing run flies at.");
			Speed = cfg.Bind<float>("StealthBomber", "Speed", 35f, "Speed of the bombing run in units per second.");
			ApproachDistance = cfg.Bind<float>("StealthBomber", "ApproachDistance", 300f, "How far away the bomber visual spawns from the targeting strip in units.");
			RocketInterval = cfg.Bind<float>("StealthBomber", "RocketInterval", 0.75f, "Seconds between each rocket drop during a bombing run.");
			Spread = cfg.Bind<float>("StealthBomber", "Spread", 25f, new ConfigDescription("Random lateral spread in units for each rocket's drop position.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(25f, 100f), Array.Empty<object>()));
			Uses = cfg.Bind<float>("StealthBomber", "Uses", 1f, "Number of bombing runs per pickup.");
			GiveKey = cfg.Bind<Key>("StealthBomber", "GiveKey", (Key)101, "Key to press to add the stealth bomber to your inventory.");
			WaitTime = cfg.Bind<float>("StealthBomber", "WaitTime", 1.5f, "Seconds to wait before starting the bombing run.");
			StripLength = cfg.Bind<float>("StealthBomber", "StripLength", 300f, "Length of the targeting strip in units.");
			TargetingZoomSpeed = cfg.Bind<float>("StealthBomber", "TargetingZoomSpeed", 5f, "Speed at which the camera zooms in/out during bomber targeting.");
			RocketAngularJitter = cfg.Bind<float>("StealthBomber", "RocketAngularJitter", 0.8f, "Random angular jitter in degrees for each rocket's rotation.");
			RocketSpawnDepth = cfg.Bind<float>("StealthBomber", "RocketSpawnDepth", 5f, "How far below the bomber (in units) rockets spawn, to avoid colliding with the bomber on creation.");
			TargetMoveSpeed = cfg.Bind<float>("StealthBomber", "TargetMoveSpeed", 50f, "How fast the targeting strip moves with WASD.");
			TargetRotateSpeed = cfg.Bind<float>("StealthBomber", "TargetRotateSpeed", 90f, "Rotation speed of the targeting strip in degrees per second (Q/E).");
			HitsToDestroy = cfg.Bind<float>("StealthBomber", "HitsToDestroy", 1f, "Rocket hits required to shoot down the bomber and cancel its run. Set to 0 to make it invincible.");
			CrashImpactForce = cfg.Bind<float>("StealthBomber", "CrashImpactForce", 500f, "Impulse force applied to the stealth bomber in the direction of the rocket hit when shot down.");
			CrashDownwardForce = cfg.Bind<float>("StealthBomber", "CrashDownwardForce", 15f, "Impulse force applied to the stealth bomber in the downward direction.");
			CrashTorque = cfg.Bind<float>("StealthBomber", "CrashTorque", 1.2f, "Magnitude of the random tumble torque applied to the stealth bomber when shot down.");
			ExplosionScale = cfg.Bind<float>("Explosions", "StealthBomberScale", 1.5f, "Multiplier for Stealth Bomber rocket explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class StickyGrenadeConfig
	{
		private const string Section = "StickyGrenade";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> MaxThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> FuseTime { get; private set; }

		public ConfigEntry<float> GraceTime { get; private set; }

		public ConfigEntry<float> StickRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public StickyGrenadeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("StickyGrenade", "GiveKey", (Key)88, "Debug key to add the StickyGrenade grenade to your inventory.");
			Uses = cfg.Bind<float>("StickyGrenade", "Uses", 2f, "Number of StickyGrenade grenades per pickup.");
			ThrowSpeed = cfg.Bind<float>("StickyGrenade", "ThrowSpeed", 22f, "Initial speed in units per second when the grenade is thrown.");
			MaxThrowSpeed = cfg.Bind<float>("StickyGrenade", "MaxThrowSpeed", 35f, "Server-side cap on throw speed to prevent exploits.");
			LobAngle = cfg.Bind<float>("StickyGrenade", "LobAngle", 0.25f, "Upward component added to the throw direction for a natural lob arc. 0 = perfectly flat, 1 = 45 degrees upward.");
			FuseTime = cfg.Bind<float>("StickyGrenade", "FuseTime", 3.5f, "Seconds from when the grenade sticks until it detonates.");
			GraceTime = cfg.Bind<float>("StickyGrenade", "GraceTime", 0.35f, "Seconds after throwing before the grenade can stick to anything. Prevents the grenade from immediately sticking to the thrower.");
			StickRadius = cfg.Bind<float>("StickyGrenade", "StickRadius", 0.55f, "Radius of the overlap sphere used to detect stick targets each FixedUpdate.");
			ExplosionScale = cfg.Bind<float>("Explosions", "StickyGrenadeScale", 4f, "Multiplier for StickyGrenade explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class SuperDonutConfig
	{
		private const string Section = "SuperDonut";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public SuperDonutConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("SuperDonut", "GiveKey", (Key)78, "Hotkey to give yourself a Super Donut (debug/testing).");
			Uses = cfg.Bind<float>("SuperDonut", "Uses", 1f, "Number of Super Donut uses per pickup.");
		}
	}
	public class TeleporterConfig
	{
		private const string Section = "Teleporter";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> TargetMoveSpeed { get; private set; }

		public ConfigEntry<float> MarkerRadius { get; private set; }

		public TeleporterConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Teleporter", "GiveKey", (Key)68, "Hotkey to give yourself a Teleporter (debug/testing). Key.None = disabled.");
			Uses = cfg.Bind<float>("Teleporter", "Uses", 1f, "Number of uses per Teleporter pickup.");
			TargetMoveSpeed = cfg.Bind<float>("Teleporter", "TargetMoveSpeed", 60f, "Speed (units/second) at which the target marker moves during the targeting phase.");
			MarkerRadius = cfg.Bind<float>("Teleporter", "MarkerRadius", 1f, "Radius (units) of the circular target marker disc shown in the targeting UI.");
		}
	}
	public class WindStormConfig
	{
		private const string Section = "WindStorm";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> StormSpeed { get; private set; }

		public ConfigEntry<bool> ExcludeActivator { get; private set; }

		public ConfigEntry<float> DirectionChangeInterval { get; private set; }

		public ConfigEntry<float> DirectionChangeRange { get; private set; }

		public ConfigEntry<bool> AffectPlayers { get; private set; }

		public ConfigEntry<float> PlayerWindFactor { get; private set; }

		public WindStormConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("WindStorm", "GiveKey", (Key)0, "Debug key to add the Wind Storm item to your inventory.");
			Uses = cfg.Bind<float>("WindStorm", "Uses", 1f, "Number of uses per Wind Storm pickup.");
			Duration = cfg.Bind<float>("WindStorm", "Duration", 15f, "Seconds the wind storm lasts before wind returns to normal.");
			StormSpeed = cfg.Bind<float>("WindStorm", "StormSpeed", 150f, "Wind speed (km/h) applied during the storm. The base game High preset maxes out at 99 km/h.");
			ExcludeActivator = cfg.Bind<bool>("WindStorm", "ExcludeActivator", true, "When true, the player who activates the storm is immune — their ball is unaffected by the storm wind. When false, everyone including the activator is hit by the storm.");
			DirectionChangeInterval = cfg.Bind<float>("WindStorm", "DirectionChangeInterval", 2f, "Seconds between each wind direction shift during the storm. Smaller values produce more turbulent, rapidly-changing gusts.");
			DirectionChangeRange = cfg.Bind<float>("WindStorm", "DirectionChangeRange", 45f, "Maximum degrees the wind direction can shift each interval (random walk). E.g. 45 means the angle changes by a random amount in [-45, +45] per tick.");
			AffectPlayers = cfg.Bind<bool>("WindStorm", "AffectPlayers", true, "When true, storm wind is applied as a force to knocked-out player bodies. Set false to limit the effect to golf balls only.");
			PlayerWindFactor = cfg.Bind<float>("WindStorm", "PlayerWindFactor", 0.15f, "Strength of wind applied to players as a fraction of the storm wind vector. 0.1 is a noticeable nudge; 0.5 noticeably impedes movement.");
		}
	}
	public class ItemConfigSyncer : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ItemConfigSyncer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					if (NetworkServer.active)
					{
						Broadcast();
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedEx