using Oxide.Core.Plugins;
using Oxide.Game.Rust.Cui;
using System.Collections.Generic;
using UnityEngine;
using Oxide.Core;
using System;
using System.Linq;
using System.Text;
using Newtonsoft.Json;
using JSON;
using System.IO;
using Rust;

namespace Oxide.Plugins
{
    [Info("TotalControl", "Mat993hew", "1.3.5")]
    class TotalControl : RustPlugin
    {
        #region Plugin References
        [PluginReference]
        Plugin Economics, ServerRewards, ImageLibrary;

        #endregion
        #region Dictionary
        #region General variables
        private const string openGui = "totalcontrol.OpenGUI";
        private GatherData gatherData = new GatherData();
        private StackSizeData stackSizeData = new StackSizeData();
        private SmeltingData smeltingData = new SmeltingData();
        private RewardsData rewardsData = new RewardsData();
        private SettingsData settingsData = new SettingsData();

        private int currentPage = 0;
        private int gatherRatesPage = 0;
        private int stackSizePage = 0;
        private int rewardsPage = 0;
        private bool resetCooldown = false;
        bool freezeTimeOn = false;
        private string voteDayValue;
        string tempValue = "";

        #endregion
        #region Position lists
        private List<float> settingsPositions = new List<float> { 0.37f, 0.29f, 0.21f, 0.13f, 0.05f };
        private List<float> ModifierPositions = new List<float> { 0.53f, 0.45f };
        private List<float> columnPositions = new List<float> { 0.85f, 0.77f, 0.69f, 0.61f, 0.53f, 0.45f, 0.37f, 0.29f, 0.21f, 0.13f, 0.05f };
        private List<float> columnXPositions = new List<float> { 0.03f, 0.265f, 0.5f, 0.735f };
        private float settingsXPos = 0.735f;
        string raidOffsetMin = "-272 49";
        string raidOffsetMax = "-212 78";
        private List<float> ButtonscolumnPositions = new List<float> { 0.85f, 0.77f, 0.69f };
        private List<float> SettingscolumnPositions = new List<float> { 0.61f, 0.53f, 0.45f, 0.37f, 0.29f, 0.21f };
        private List<float> SettingscolumnXPositions = new List<float> { 0.03f, 0.295f, 0.56f, 0.825f };

        #endregion
        #region Health and damage tracking
        private float totalHealthBradley;
        private float totalHealthHeli;
        private BasePlayer lastPlayer = null;
        private Dictionary<ulong, float> playerDamageBradley = new Dictionary<ulong, float>();
        private Dictionary<ulong, float> playerDamageHeli = new Dictionary<ulong, float>();
        #endregion
        #region Lists of settings and categories
        private List<string> settings = new List<string> {
    "Divided_Loot", "Award_Only_On_Full_Harvest", "Show_Messages_On_Award", "Use_Economics", "Use_Scrap", "Use_ServerRewards" };
        private List<string> Meats { get; set; } = new List<string> {
    "meat.boar", "horsemeat.raw", "wolfmeat.raw", "bearmeat", "chicken.raw", "fish.raw", "deermeat.raw", "humanmeat.raw" };
        private List<string> OtherScientist { get; set; } = new List<string> {
    "scientistnpc_bradleyapc_road", "scientistnpc_bradleyapc_monument", "scientistnpc_arena", "scientistnpc_roam", "scientistnpc_broamtethered" };
        private List<string> ExcludedCategory = new List<string> {
    "Weapon", "Construction", "Items", "Resources", "Attire", "Tool", "Medical", "Food", "Ammunition", "Traps", "Misc", "Component", "Electrical", "Fun" };
        private List<string> StackNames = new List<string> {
    "wood", "stones", "metal.ore", "sulfur.ore", "hq.metal.ore", "metal.fragments", "sulfur", "metal.refined", "cloth", "leather",
    "gunpowder", "charcoal", "fat.animal", "bone.fragments", "crude.oil", "lowgradefuel", "diesel_barrel", "explosives", "scrap", "horsedung", "fertilizer", "cctv.camera",
    "targeting.computer", "explosive.timed", "explosive.satchel", "grenade.smoke", "supply.signal", "antiradpills", "bandage", "largemedkit", "syringe.medical", "blood",
    "fuse", "metalpipe", "techparts", "gears", "metalblade", "metalspring", "propanetank", "rope", "sewingkit", "tarp", "roadsigns", "sheetmetal" };
        private List<string> StackNames2 = new List<string> {
    "smgbody", "semibody", "riflebody", "grenade.beancan", "grenade.f1",
    "grenade.flashbang", "grenade.molotov", "ladder.wooden.wall", "cactusflesh",
    "sleepingbag", "wall.frame.netting", "Weapon", "Construction", "Items",
    "Resources", "Attire", "Tool", "Medical", "Food", "Ammunition", "Traps",
    "Misc", "Component", "Electrical", "Fun" };
        private List<string> Category = new List<string> {
    "Weapon", "Construction", "Items", "Resources", "Attire", "Tool", "Medical",
    "Food", "Ammunition", "Traps", "Misc", "Component", "Electrical", "Fun" };
        private List<string> StackDisplayNames = new List<string> {
    "Wood", "Stone", "Metal Ore", "Sulfur Ore", "HQ Metal Ore", "Metal Frags",
    "Cooked Sulfur", "Cooked HQ Metal", "Cloth", "Leather", "Gun Poweder",
    "Charcoal", "Animal Fat", "Bone Fragments", "Crude Oil", "Low Grade Fuel",
    "Diesel Fuel", "Explosives", "Scrap", "Horse Dung", "Fertilizer",
    "CCTV Camera", "Targeting Computer", "Timed Explosive", "Stachel Charge",
    "Smoke Grenade", "Suply Signal", "Anti Rad Pills", "Bandage", "Large MedKit",
    "Medical Syringe", "Blood", "Fuse", "Pipes", "Tech Trash", "Gears", "Metal Blade",
    "Metal Spring", "Propane Tank", "Rope", "Sewing Kit", "Tarp", "Road Signs", "Sheet Metal" };
        private List<string> StackDisplayNames2 = new List<string> {
    "SMG Body", "Semi Automatic Body", "Rifle Body",
    "Beancan Grenade", "F1 Grenade", "Flashbang", "Molotov Cocktail",
    "Wooden Ladder", "Cactus Flesh", "Sleeping Bag", "Netting", "<i><b>Weapon Category</b></i>",
    "<i><b>Construction Category</b></i>", "<i><b>Items Category</b></i>",
    "<i><b>Resources Category</b></i>", "<i><b>Attire Category</b></i>",
    "<i><b>Tool Category</b></i>", "<i><b>Medical Category</b></i>",
    "<i><b>Food Category</b></i>", "<i><b>Ammunition Category</b></i>",
    "<i><b>Traps Category</b></i>", "<i><b>Misc Category</b></i>",
    "<i><b>Component Category</b></i>", "<i><b>Electrical Category</b></i>",
    "<i><b>Fun Category</b></i>" };
        private List<string> gatherNames = new List<string> {
    "stone-collectable", "metal-collectable", "sulfur-collectable", "wood-collectable", "stones",
    "metal.ore", "hq.metal.ore", "metal.refined", "sulfur.ore", "wood", "hemp-collectable",
    "seed.hemp", "corn-collectable", "seed.corn", "pumpkin-collectable", "seed.pumpkin", "Mushroom", "potato-collectable",
    "seed.potato", "berry-red-collectable", "seed.red.berry", "berry-blue-collectable", "seed.blue.berry", "berry-green-collectable",
    "seed.green.berry","berry-yellow-collectable", "seed.yellow.berry", "berry-white-collectable", "seed.white.berry",
    "cactusflesh", "diesel_collectable", "crude.oil", "lowgradefuel", "scrap", "Meat", "cloth", "leather", "bone.fragments", "fat.animal", "riflebody", "semibody", "smgbody", "gears", "metalspring"};
        private List<string> GatherDisplayNames = new List<string> {
    "Stone Pickup", "Metal Pickup", "Sulfur Pickup", "Wood Pickup", "Stone Ore", "Metal Ore",
    "HQ Metal Ore", "HQ Metal In Crates", "Sulfur Ore", "Wood from Trees", "Hemp", "Hemp Seed", "Corn", "Corn Seed",
    "Pumpkin", "Pumpkin Seed", "Mushroom", "Potato", "Potato Seed", "Red Berry", "Red Berry Seed", "Blue Berry", "Blue Berry Seed",
    "Green Berry", "Green Berry Seed", "Yellow Berry", "Yellow Berry Seed", "White Berry", "White Berry Seed", "Cactus",
    "Diesel Barrel", "Crude Oil", "Low Grade", "Scrap", "Meat", "Cloth", "Leather", "Bone Fragments", "Animal Fat", "Rifle Body",
    "Semi Body", "Smg Body", "Gears", "Springs"};
        private List<string> gatherNames2 = new List<string> {
    "metalpipe", "techparts","cctv.camera", "targeting.computer", "rope", "sewingkit",
    "tarp", "roadsigns", "sheetmetal","metalblade", "propanetank", "grenade.beancan",
    "grenade.f1", "grenade.flashbang","grenade.molotov", "ladder.wooden.wall", "explosives",
    "gunpowder", "charcoal","explosive.timed", "supply.signal", "grenade.smoke",
    "explosive.satchel", "bandage", "largemedkit", "syringe.medical", "fish", "Food",
    "Ammunition", "fuse", "Electrical", "largeWaterCatcher", "smallWaterCatcher",
    "quarryStones", "quarryMetal", "quarrySulfur","quarryHQM", "excavMetal", "excavSulfur",
    "excavHQM", "excavStones"};
        private List<string> GatherDisplayNames2 = new List<string> {
    "Pipes", "Tech Trash", "CCTV Camera", "Targeting Computer", "Rope", "Sewing Kit", "Tarp",
    "Road Signs", "Sheet Metal", "Metal Blade", "Propane Tank", "Beancan Grenade", "F1 Grenade",
    "Flashbang", "Molotov", "Ladders", "Explosives", "Gun Powder", "Charcoal", "Timed Explosive",
    "Supply Signal","Smoke Grenade", "Satchel Charge", "Bandage", "Large Med Kit", "Medical Syringe",
    "Fish","Food In Containers", "Ammo", "Electrical Fuse", "Electrical Items", "Large Water Cather",
    "Small Water Catcher", "Quarry Stones", "Quarry Metal Ore", "Quarry Sulfur Ore", "Quarry HQM",
    "Excavator Metal Frags", "Excavator Sulfur Ore", "Excavator HQM Ore", "Excavator Stones"};
        private List<string> smeltingNames = new List<string> {
    "furnace", "furnace.large", "refinery_small_deployed", "bbq.deployed", "campfire", "electricfurnace.deployed", "mixingtable" };
        private List<string> charcoalNames = new List<string> {
    "furnace", "furnace.large", "refinery_small_deployed", "bbq.deployed", "campfire" };
        private List<string> fuelUsageNames = new List<string> {
    "furnace", "furnace.large", "refinery_small_deployed", "bbq.deployed", "campfire" };
        private List<string> outputMultiplierNames = new List<string> {
    "furnace", "furnace.large", "refinery_small_deployed", "bbq.deployed", "campfire", "electricfurnace.deployed" };
        private List<string> DisplayNames = new List<string> {
    "Small Furnace", "Large Furnace", "Oil Refinery", "BBQ", "Campfire", "Electric Furnace", "Mixing Table" };
        private List<string> rDisplayNames = new List<string> {
    "Bear", "Polarbear", "Chicken", "Horse", "Stag", "Wolf", "Boar", "Shark", "Corn", "Mushroom", "Pumpkin", "Hemp", "Berries",
    "Player", "Team Member", "Scarecrow", "Suicide", "Death",
    "Stone Pickup", "Metal Pickup", "Sulfur Pickup", "Wood Pickup", "Stone Ore", "Metal Ore", "Sulfur Ore", "Tree",
    "Junkpile Scientist", "Excavator Scientist", "Cargoship Scientist", "Patrol Scientist", "Oilrig Scientist",
    "Heavy Scientist", "Underwater Scientist", "Tunnel Scientist", "Other Scientist", "Bradley", "Patrol Heli" };
        private List<string> sDisplayNames = new List<string> {
    "<b>Divide Bradley & Heli Loot</b>", "<b>Award After Full Harvest</b>", "<b>Show Message On Award</b>",
    "<b><color=#1f83abff>Use Economics</color></b>", "<b><color=#c36e32ff>Use Scrap</color></b>" };
        private List<string> mDisplayNames = new List<string> {
    "<b>Chainsaw Modifier</b>", "<b>JackHammer Modifier</b>" };
        private List<string> rNames = new List<string> {
    "bear", "polarbear", "chicken", "testridablehorse", "stag", "wolf", "boar", "simpleshark", "corn-collectable", "Mushroom",
    "pumpkin-collectable", "hemp-collectable", "Berries", "Player", "Team_Member", "scarecrow", "Suicide", "Death",
    "stone-collectable", "metal-collectable", "sulfur-collectable", "wood-collectable", "stones", "metal.ore", "sulfur.ore", "wood",
    "scientistnpc_junkpile_pistol", "scientistnpc_excavator", "CargoScientist", "scientistnpc_patrol", "scientistnpc_oilrig",
    "scientistnpc_heavy", "npc_underwaterdweller", "npc_tunneldweller", "otherScientist", "bradleyapc", "patrolhelicopter" };
        private List<string> mNames = new List<string> {
    "Chainsaw_Modifier", "JackHammer_Modifier" };
        private List<string> sSrDisplayNames = new List<string> {
    "<b>Use ServerRewards</b>" };
        private List<string> buttons = new List<string> {
            "skip", "vote", "freeze", "PvEMode", "autoPvEMode", "ModeIcon", "raidProt", "autoRaidProt", "RaidIcon" };
        private List<string> settingsNames = new List<string> {
            "SOD", "EOD", "VotePass", "MessageDelay", "MaxSkipDays", "VoteDayCmd", "PvEOn", "PvEOff", "", "", "", "", "ProtOn", "ProtOff" };
        private List<string> settingsDisplayNames = new List<string> {
            "Start Of Day", "End Of Day", "Vote Pass Rate (%)", "Vote Message Delay <size=14>(in seconds)</size>", "Max Skip Nights <size=14>(-1 to disable)</size>","Vote Day Command", "Turn On PvE Mode", "Turn Off PvE Mode", "", "", "","", "Turn On Raid Protection", "Turn Off Raid Protection" };
        private List<string> buttonsDisplayNames = new List<string> {
            "Use Auto Skip Night", "Use Voting /day", "Freeze Time To Start Of Day", "PvE Mode", "Timed PvE Mode", "Show PvP/PvE Icon", "Raid Protection", "Timed Raid Protection", "Show Raid Protection Icon" };


        #endregion
        #region Modifiers and dictionaries
        private Dictionary<string, int> OrginalCreateAmount = new Dictionary<string, int>();
        private Dictionary<string, int> OrginalBarrelAmount = new Dictionary<string, int>();
        private Dictionary<string, float> CurrentMultiplier = new Dictionary<string, float>();
        private static Dictionary<float, HashSet<ItemDefinition>> _materialOutputCache;
        private Dictionary<string, bool> updatedOvens = new Dictionary<string, bool>();
        private List<BaseOven> ovens = new List<BaseOven>();
        private HashSet<ulong> deadPlayerSteamIds = new HashSet<ulong>();
        private HashSet<ulong> suicidePlayerSteamIds = new HashSet<ulong>();
        private HashSet<string> singleStackItems = new HashSet<string>();
        private Dictionary<string, int> stackSizeCache = new Dictionary<string, int>();
        private static Dictionary<NetworkableId, Dictionary<int, Dictionary<int, int>>> _previousAmounts = new Dictionary<NetworkableId, Dictionary<int, Dictionary<int, int>>>();
        private List<float> smeltingColumnPositions = new List<float> { 0.805f, 0.701f, 0.596f, 0.492f, 0.386f, 0.282f, 0.178f };
        private Dictionary<string, int> originalSmeltSpeed = new Dictionary<string, int>();
        private Dictionary<string, int> originalByproductAmounts = new Dictionary<string, int>();
        private Dictionary<string, bool> updatedSmeltSpeed = new Dictionary<string, bool>();
        private Timer _timer;
        private Timer _timerVote;
        private int printCount = 0;
        private bool votingInProgress = false;
        private int skippedDays = 0;
        private bool skipDayCooldown = false;
        private Dictionary<string, bool> votes = new Dictionary<string, bool>();
        private Dictionary<string, string> tempSettings = new Dictionary<string, string>();
        private Dictionary<int, int> originalStackSizes = new Dictionary<int, int>();

        #endregion
        #region Default rates
        private float defaultBaseRate = 0.25f;
        private float defaultRainRate = 1.0f;
        private float defaultSnowRate = 0.5f;
        private float defaultFogRate = 2f;
        private bool catcherUnloaded = true;
        private bool isServerInitialized = false;
        #endregion
        #endregion
        #region Data
        public class GatherData
        {
            public bool DisableBtn { get; set; } = true;
            public Dictionary<string, float> GatherRates { get; set; } = new Dictionary<string, float>
            {
                {"stone-collectable", 1.0f},
                {"metal-collectable", 1.0f},
                {"sulfur-collectable", 1.0f},
                {"wood-collectable", 1.0f},
                {"stones", 1.0f},
                {"metal.ore", 1.0f},
                {"hq.metal.ore", 1.0f},
                {"sulfur.ore", 1.0f},
                {"wood", 1.0f},
                {"hemp-collectable", 1.0f},
                {"corn-collectable", 1.0f},
                {"pumpkin-collectable", 1.0f},
                {"Mushroom", 1.0f},
                {"berry-red-collectable", 1.0f},
                {"berry-blue-collectable", 1.0f},
                {"berry-green-collectable", 1.0f},
                {"berry-yellow-collectable", 1.0f},
                {"berry-white-collectable", 1.0f},
                {"diesel_collectable", 1.0f},
                {"crude.oil", 1.0f},
                {"lowgradefuel", 1.0f},
                {"scrap", 1.0f},
                {"Meat", 1.0f},
                {"cloth", 1.0f},
                {"leather", 1.0f},
                {"bone.fragments", 1.0f},
                {"fat.animal", 1.0f},
                {"gears", 1.0f},
                {"metalspring", 1.0f},
                {"metalpipe", 1.0f},
                {"techparts", 1.0f},
                {"cctv.camera", 1.0f},
                {"targeting.computer", 1.0f},
                {"rope", 1.0f},
                {"sewingkit", 1.0f},
                {"tarp", 1.0f},
                {"roadsigns", 1.0f},
                {"sheetmetal", 1.0f},
                {"metalblade", 1.0f},
                {"propanetank", 1.0f},
                {"smgbody", 1.0f},
                {"semibody", 1.0f},
                {"riflebody", 1.0f},
                {"metal.refined", 1.0f},
                {"grenade.beancan",1.0f},
                {"grenade.f1", 1.0f},
                {"potato-collectable", 1.0f},
                {"grenade.flashbang", 1.0f},
                {"grenade.molotov", 1.0f},
                {"ladder.wooden.wall", 1.0f},
                {"explosives", 1.0f},
                {"gunpowder", 1.0f},
                {"charcoal", 1.0f},
                {"explosive.timed", 1.0f},
                {"supply.signal", 1.0f},
                {"grenade.smoke", 1.0f},
                {"explosive.satchel", 1.0f},
                {"bandage", 1.0f},
                {"largemedkit", 1.0f},
                {"syringe.medical", 1.0f},
                {"fish", 1.0f},
                {"cactusflesh", 1.0f},
                {"Food", 1.0f},
                {"Ammunition", 1.0f},
                {"fuse", 1.0f},
                {"Electrical", 1.0f},
                {"largeWaterCatcher", 1.0f},
                {"smallWaterCatcher", 1.0f},
                {"quarryStones", 1.0f},
                {"quarryMetal", 1.0f},
                {"quarrySulfur", 1.0f},
                {"quarryHQM", 1.0f},
                {"excavStones", 1.0f},
                {"excavMetal", 1.0f},
                {"excavSulfur", 1.0f},
                {"excavHQM", 1.0f},
                {"seed.red.berry", 1.0f},
                {"seed.blue.berry", 1.0f},
                {"seed.green.berry", 1.0f},
                {"seed.yellow.berry", 1.0f},
                {"seed.white.berry", 1.0f},
                {"seed.corn", 1.0f},
                {"seed.hemp", 1.0f},
                {"seed.potato", 1.0f},
                {"seed.pumpkin", 1.0f}
            };
        }
        public class ItemData
        {
            public float StackSize { get; set; }
            public string Mode { get; set; }
        }
        public class StackSizeData
        {
            public bool DisableBtn { get; set; } = true;
            public Dictionary<string, ItemData> StackSize { get; set; } = new Dictionary<string, ItemData>
            {
                {"wood", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"stones", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metal.ore", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"sulfur.ore", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"hq.metal.ore", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metal.fragments", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"sulfur", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metal.refined", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"cloth", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"leather", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"gunpowder", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"charcoal", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"fat.animal", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"bone.fragments", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"crude.oil", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"lowgradefuel", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"diesel_barrel", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"explosives", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"scrap", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"horsedung", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"fertilizer", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"cctv.camera", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"targeting.computer", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"explosive.timed", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"explosive.satchel", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"grenade.smoke", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"supply.signal", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"antiradpills", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"bandage", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"largemedkit", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"syringe.medical", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"blood", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"fuse", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metalpipe", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"techparts", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"gears", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metalblade", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"metalspring", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"propanetank", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"rope", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"sewingkit", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"tarp", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"roadsigns", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"sheetmetal", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"smgbody", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"semibody", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"riflebody", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"grenade.beancan", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"grenade.f1", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"grenade.flashbang", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"grenade.molotov", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"ladder.wooden.wall", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"cactusflesh", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"sleepingbag", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"wall.frame.netting", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Weapon", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Construction", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Items", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Resources", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Attire", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Tool", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Medical", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Food", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Ammunition", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Traps", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Misc", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Component", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Electrical", new ItemData { StackSize = 1.0f, Mode = "x" }},
                {"Fun", new ItemData { StackSize = 1.0f, Mode = "x" }}
            };
        }
        public class SmeltingData
        {
            public bool DisableBtn { get; set; } = true;
            public Dictionary<string, float> Smelting { get; set; } = new Dictionary<string, float>
            {
                {"furnace", 1.0f},
                {"furnace.large", 1.0f},
                {"electricfurnace.deployed", 1.0f},
                {"refinery_small_deployed", 1.0f},
                {"bbq.deployed", 1.0f},
                {"campfire", 1.0f},
                {"mixingtable", 1.0f},
            };
            public Dictionary<string, float> CharcoalMultiplier { get; set; } = new Dictionary<string, float>
            {
                {"furnace", 1.0f},
                {"furnace.large", 1.0f},
                {"refinery_small_deployed", 1.0f},
                {"bbq.deployed", 1.0f},
                {"campfire", 1.0f},
            };
            public Dictionary<string, float> FuelUsageNames { get; set; } = new Dictionary<string, float>
            {
                {"furnace", 1.0f},
                {"furnace.large", 1.0f},
                {"refinery_small_deployed", 1.0f},
                {"bbq.deployed", 1.0f},
                {"campfire", 1.0f},
            };
            public Dictionary<string, float> OutputMultiplier { get; set; } = new Dictionary<string, float>
            {
                {"furnace", 1.0f},
                {"furnace.large", 1.0f},
                {"electricfurnace.deployed", 1.0f},
                {"refinery_small_deployed", 1.0f},
                {"bbq.deployed", 1.0f},
                {"campfire", 1.0f},
            };
        }
        public class RewardsData
        {
            public bool DisableBtn { get; set; } = true;
            public struct RewardValues
            {
                public float Economics { get; set; }
                public int Scrap { get; set; }
                public float ServerRewards { get; set; }
            };
            public Dictionary<string, string> Settings { get; set; } = new Dictionary<string, string>
                {
                { "Divided_Loot", "True" },
                { "Award_Only_On_Full_Harvest", "True" },
                { "Show_Messages_On_Award", "True" },
                { "Use_Economics", "True" },
                { "Use_Scrap", "False" },
                {"Use_ServerRewards", "False"}
                };
            public Dictionary<string, float> Modifiersettings { get; set; } = new Dictionary<string, float>
                {
                {"Chainsaw_Modifier", 0.8f},
                {"JackHammer_Modifier", 0.8f}
                };
            public Dictionary<string, RewardValues> Rewards { get; set; } = new Dictionary<string, RewardValues>
                {
                { "bear", new RewardValues { Economics = 15f, Scrap = 0, ServerRewards = 0f} },
                { "polarbear", new RewardValues { Economics = 15f, Scrap = 0, ServerRewards = 0f} },
                { "chicken", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "testridablehorse", new RewardValues { Economics = -15f, Scrap = 0, ServerRewards = 0f} },
                { "stag", new RewardValues { Economics = 5f, Scrap = 0, ServerRewards = 0f} },
                { "wolf", new RewardValues { Economics = 10f, Scrap = 0, ServerRewards = 0f} },
                { "boar", new RewardValues { Economics = 10f, Scrap = 0, ServerRewards = 0f} },
                { "simpleshark", new RewardValues { Economics = 15f, Scrap = 0, ServerRewards = 0f} },
                { "corn-collectable", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "Mushroom", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "pumpkin-collectable", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "hemp-collectable", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "Berries", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "Player", new RewardValues { Economics = 150f, Scrap = 0, ServerRewards = 0f} },
                { "Team_Member", new RewardValues { Economics = -20f, Scrap = 0, ServerRewards = 0f} },
                { "scarecrow", new RewardValues { Economics = 75f, Scrap = 0, ServerRewards = 0f} },
                { "Suicide", new RewardValues { Economics = -20f, Scrap = 0, ServerRewards = 0f} },
                { "Death", new RewardValues { Economics = 0f, Scrap = 0, ServerRewards = 0f} },
                { "stone-collectable", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "metal-collectable", new RewardValues { Economics = 5f, Scrap = 0, ServerRewards = 0f} },
                { "sulfur-collectable", new RewardValues { Economics = 8f, Scrap = 0, ServerRewards = 0f} },
                { "wood-collectable", new RewardValues { Economics = 2f, Scrap = 0, ServerRewards = 0f} },
                { "stones", new RewardValues { Economics = 10f, Scrap = 0, ServerRewards = 0f} },
                { "metal.ore", new RewardValues { Economics = 12f, Scrap = 0, ServerRewards = 0f} },
                { "sulfur.ore", new RewardValues { Economics = 15f, Scrap = 0, ServerRewards = 0f} },
                { "wood", new RewardValues { Economics = 8f, Scrap = 0, ServerRewards = 0f} },
                { "scientistnpc_junkpile_pistol", new RewardValues { Economics = 75f, Scrap = 0, ServerRewards = 0f} },
                { "scientistnpc_excavator", new RewardValues { Economics = 100f, Scrap = 0, ServerRewards = 0f} },
                { "CargoScientist", new RewardValues { Economics = 110f, Scrap = 0, ServerRewards = 0f} },
                { "scientistnpc_patrol", new RewardValues { Economics = 75f, Scrap = 0, ServerRewards = 0f} },
                { "scientistnpc_oilrig", new RewardValues { Economics = 120f, Scrap = 0, ServerRewards = 0f} },
                { "scientistnpc_heavy", new RewardValues { Economics = 150f, Scrap = 0, ServerRewards = 0f} },
                { "npc_underwaterdweller", new RewardValues { Economics = 110f, Scrap = 0, ServerRewards = 0f} },
                { "npc_tunneldweller", new RewardValues { Economics = 100f, Scrap = 0, ServerRewards = 0f} },
                { "otherScientist", new RewardValues { Economics = 75f, Scrap = 0, ServerRewards = 0f} },
                { "bradleyapc", new RewardValues { Economics = 1200f, Scrap = 800, ServerRewards = 0f} },
                { "patrolhelicopter", new RewardValues { Economics = 1000f, Scrap = 600, ServerRewards = 0f} }
                };
        }
        public class SettingsData
        {
            public bool DisableBtn { get; set; } = true;

            public Dictionary<string, string> Settings { get; set; } = new Dictionary<string, string>
                {
                    {"SOD", "8"},
                    {"EOD", "22"},
                    {"VotePass", "40"},
                    {"MessageDelay", "30"},
                    {"MaxSkipDays", "-1"},
                    {"PvEOn","10"},
                    {"PvEOff","15"},
                    {"ProtOn", "22"},
                    {"ProtOff", "8"},
                    {"skip", "False"},
                    {"vote", "False"},
                    {"freeze", "False"},
                    {"PvEMode", "False"},
                    {"autoPvEMode", "False"},
                    {"ModeIcon", "False"},
                    {"raidProt", "False"},
                    {"autoRaidProt", "False"},
                    {"RaidIcon", "False"},
                    {"VoteDayCmd", "day"}

                };
        }
        #endregion
        #region Plugin Load & Unload
        void Init()
        {
            SendMessageToAdmins("Total Control has been loaded");
            CreateLanguageFiles();
            permission.RegisterPermission(openGui, this);
            OrginalCreateAmount.Clear();
            OrginalBarrelAmount.Clear();
            CurrentMultiplier.Clear();
            originalSmeltSpeed.Clear();

            if (!Interface.Oxide.DataFileSystem.ExistsDatafile("TotalControl/Gather"))
            {
                gatherData = new GatherData();
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Gather", gatherData);
            }
            else
            {
                gatherData = Interface.Oxide.DataFileSystem.ReadObject<GatherData>("TotalControl/Gather");
            }

            if (!Interface.Oxide.DataFileSystem.ExistsDatafile("TotalControl/StackSize"))
            {
                stackSizeData = new StackSizeData();
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/StackSize", stackSizeData);
            }
            else
            {
                stackSizeData = Interface.Oxide.DataFileSystem.ReadObject<StackSizeData>("TotalControl/StackSize");
            }

            if (!Interface.Oxide.DataFileSystem.ExistsDatafile("TotalControl/Smelting"))
            {
                smeltingData = new SmeltingData();
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Smelting", smeltingData);
            }
            else
            {
                smeltingData = Interface.Oxide.DataFileSystem.ReadObject<SmeltingData>("TotalControl/Smelting");
            }

            if (!Interface.Oxide.DataFileSystem.ExistsDatafile("TotalControl/Rewards"))
            {
                rewardsData = new RewardsData();
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Rewards", rewardsData);
            }
            else
            {
                rewardsData = Interface.Oxide.DataFileSystem.ReadObject<RewardsData>("TotalControl/Rewards");
            }

            if (!Interface.Oxide.DataFileSystem.ExistsDatafile("TotalControl/Settings"))
            {
                settingsData = new SettingsData();
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Settings", settingsData);
            }
            else
            {
                settingsData = Interface.Oxide.DataFileSystem.ReadObject<SettingsData>("TotalControl/Settings");
            }

            tempValue = voteDayValue;
            SetVoteCommand();
            voteDayValue = settingsData.Settings["VoteDayCmd"];
            cmd.AddChatCommand(voteDayValue, this, nameof(VoteDayCommand));
        }
        void Loaded()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                UpdateUI(player);
            }
            StartTimer();
        }
        private void StartTimer()
        {
            if (settingsData.DisableBtn)
            {
                _timer?.Destroy();
                _timer = timer.Every(1f, CheckTime);
            }
        }
        void UpdateUI(BasePlayer player)
        {
            if (settingsData.DisableBtn)
            {
                if (settingsData.Settings["ModeIcon"] == "True")
                {
                    if (settingsData.Settings["PvEMode"] == "True")
                    {
                        OnIcon(player, "Mode");
                    }
                    else
                    {
                        OffIcon(player, "Mode");
                    }
                }
                if (settingsData.Settings["RaidIcon"] == "True")
                {
                    if (settingsData.Settings["raidProt"] == "True")
                    {
                        OnIcon(player, "Raid");
                    }
                    else
                    {
                        OffIcon(player, "Raid");
                    }
                }
            }
            else
            {
                foreach (var activePlayer in BasePlayer.activePlayerList)
                {
                    CuiHelper.DestroyUi(activePlayer, "IconMode");
                    CuiHelper.DestroyUi(activePlayer, "IconRaid");
                }
            }
        }
        void OnPlayerConnected(BasePlayer player)
        {
            UpdateUI(player);
        }
        void OnServerInitialized()
        {
            if (plugins.Exists("ImageLibrary"))
            {
                DownloadImages();
            }
            if (!plugins.Exists("Economics"))
            {
                SendMessageToAdmins("Economics plugin is not loaded. Download it from the uMod website to use Economics options.");
                rewardsData.Settings["Use_Economics"] = "False";
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Rewards", rewardsData);
            }
            if (!plugins.Exists("ServerRewards"))
            {
                SendMessageToAdmins("ServerRewards plugin is not loaded. Download it from the uMod website to use ServerRewards options.");
                rewardsData.Settings["Use_ServerRewards"] = "False";
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Rewards", rewardsData);
            }
            if (settingsData.Settings["freeze"] == "True")
            {
                FreezeTime();
            }
            isServerInitialized = true;

            var dataList = new List<(bool Enable, string Page)>
{
    (gatherData.DisableBtn, "GatherRate"),
    (stackSizeData.DisableBtn, "StackSize"),
    (smeltingData.DisableBtn, "Smelting"),
    (rewardsData.DisableBtn, "Rewards"),
    (settingsData.DisableBtn, "Settings")
};

            foreach (var (enable, page) in dataList)
            {
                SubscribeUnsubscribe(enable, page);
            }


        }
        void SendMessageToAdmins(string message)
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (permission.UserHasGroup(player.userID.ToString(), "admin"))
                {
                    PrintToChat(player, message);
                }
            }
        }
        void OnEntityKill(BaseNetworkable entity)
        {
            var oven = entity as BaseOven;
            if (oven != null)
            {
                ovens.Remove(oven);
            }
        }
        void PopulateOvensList()
        {
            ovens = BaseNetworkable.serverEntities
                    .OfType<BaseOven>()
                    .ToList();

        }
        void UpdatePreviousAmounts()
        {
            foreach (var oven in ovens)
            {
                if (!_previousAmounts.TryGetValue(oven.net.ID, out var previousAmounts))
                {
                    previousAmounts = new Dictionary<int, Dictionary<int, int>>();
                    _previousAmounts[oven.net.ID] = previousAmounts;
                }

                foreach (var slotItem in oven.inventory.itemList)
                {
                    if (!previousAmounts.TryGetValue(slotItem.info.itemid, out var previousAmountDict))
                    {
                        previousAmountDict = new Dictionary<int, int>();
                        previousAmounts[slotItem.info.itemid] = previousAmountDict;
                    }
                    previousAmountDict[slotItem.position] = slotItem.amount;
                }
            }
        }
        void OnServerShutdown()
        {
            isServerInitialized = false;
        }
        void OnPluginUnloaded(Plugin plugin)
        {
            if (!isServerInitialized)
            {
                return;
            }
            if (plugin.Name == "Economics" || plugin.Name == "ServerRewards")
            {
                SendMessageToAdmins($"{plugin.Name} plugin has been unloaded. Reinstall it to use {plugin.Name} options.");
                if (plugin.Name == "Economics")
                    rewardsData.Settings["Use_Economics"] = "False";
                else if (plugin.Name == "ServerRewards")
                    rewardsData.Settings["Use_ServerRewards"] = "False";
                Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Rewards", rewardsData);
            }
        }
        private void Unload()
        {
            UnloadSmelting();
            foreach (var player in BasePlayer.activePlayerList)
            {
                CuiHelper.DestroyUi(player, "TotalControlGUI");
            }
            foreach (var waterCatcher in BaseNetworkable.serverEntities.OfType<WaterCatcher>())
            {
                waterCatcher.collectionRates.baseRate = defaultBaseRate;
                waterCatcher.collectionRates.rainRate = defaultRainRate;
                waterCatcher.collectionRates.snowRate = defaultSnowRate;
                waterCatcher.collectionRates.fogRate = defaultFogRate;
            }
            foreach (var itemId in singleStackItems)
            {
                var item = ItemManager.FindItemDefinition(Convert.ToInt32(itemId));
                if (item != null)
                {
                    item.stackable = 1;
                }
            }
            if (settingsData.Settings["freeze"] == "True")
            {
                UnfreezeTime();
            }
            foreach (var itemId in originalStackSizes.Keys)
            {
                ItemDefinition itemDef = ItemManager.FindItemDefinition(itemId);
                if (itemDef != null)
                {
                    itemDef.stackable = originalStackSizes[itemId];
                }
            }
            originalStackSizes.Clear();
        }
        private void DownloadImages()
        {
            var images = new Dictionary<string, string>
    {
        {"https://i.ibb.co/KxzS2S1/Total-Control.png", "TotalControl"},
        {"https://i.ibb.co/zsvPFRX/Red-Button.png", "RedButton"},
        {"https://i.ibb.co/kG01rJm/Green-Button.png", "GreenButton"},
        {"https://i.ibb.co/5nM2rwV/X2Button.png", "X2Button"},
        {"https://i.ibb.co/BjTWv6S/X3Button.png", "X3Button"},
        {"https://i.ibb.co/CscC0sd/X5Button.png", "X5Button"},
        {"https://i.ibb.co/3MTYX38/X10-Button.png", "X10Button"},
        {"https://i.ibb.co/qCbNbWw/Reset-Button.png", "ResetButton"},
        {"https://i.ibb.co/SNFyPDm/Background.png", "BackGround"},
        {"https://i.ibb.co/zrdHHth/Gather-Rates.png", "GatherRateName"},
        {"https://i.ibb.co/dGtCj78/Stack-Sizes.png", "StackSizesName"},
        {"https://i.ibb.co/wJdYBsF/Smelting.png", "SmeltingName"},
        {"https://i.ibb.co/RyRCyfQ/Rewards.png", "RewardsName"},
        {"https://i.ibb.co/Vv88sqJ/Server-Rewards.png", "ServerRewardsName"},
        {"https://i.ibb.co/jZS81cn/Settings.png", "SettingsName"},
    };
            if (ImageLibrary == null) return;

            foreach (var image in images)
            {
                if (ImageLibrary.Call<bool>("HasImage", image.Value)) continue;

                try
                {
                    if (!ImageLibrary.Call<bool>("AddImage", image.Key, image.Value))
                    {
                        PrintWarning($"Failed to download and add image '{image.Value}' to ImageLibrary.");
                    }
                }
                catch (Exception ex)
                {
                    PrintWarning($"Error adding image '{image.Value}' to ImageLibrary: {ex.Message}");
                }
            }
        }

        #endregion
        #region GUIConstruction
        public class CUIClass
        {
            public static void CreateRectangle(ref CuiElementContainer _container, string _parent, string _name, string _color, string _anchorMin, string _anchorMax)
            {
                _container.Add(new CuiElement
                {
                    Parent = _parent,
                    Name = _name,
                    Components =
        {
            new CuiImageComponent
            {
                Color = _color
            },
            new CuiRectTransformComponent
            {
                AnchorMin = _anchorMin,
                AnchorMax = _anchorMax
            }
        }
                });
            }
            public static void CreatePanel(ref CuiElementContainer _container, string _parent, string _name, string _color, string _anchorMin, string _anchorMax, string _OffsetMin = "0 0", string _OffsetMax = "0 0", bool _cursorOn = false, float _fadeIn = 0f, float _fadeOut = 0f, string _mat2 = "assets/content/ui/uibackgroundblur.mat", bool keyboard = false)
            {
                _container.Add(new CuiPanel
                {
                    Image = { Color = _color, Material = _mat2, FadeIn = _fadeIn },
                    RectTransform = { AnchorMin = _anchorMin, AnchorMax = _anchorMax, OffsetMin = _OffsetMin, OffsetMax = _OffsetMax },
                    FadeOut = _fadeOut,
                    CursorEnabled = _cursorOn,
                    KeyboardEnabled = keyboard
                },
                _parent,
                _name);
            }
            public static void CreateText(ref CuiElementContainer _container, string _parent, string _name, string _color, string _localizationKey, int _size, string _anchorMin, string _anchorMax, TextAnchor _align = TextAnchor.MiddleCenter, string _font = "robotocondensed-bold.ttf", float _fadeIn = 0f, float _fadeOut = 0f, string _outlineColor = "0 0 0 0", string _outlineScale = "0 0", TotalControl plugin = null, BasePlayer player = null)
            {
                var localizedText = plugin != null && player != null ? plugin.GetMessage(_localizationKey, player.UserIDString) : _localizationKey;

                _container.Add(new CuiElement
                {
                    Parent = _parent,
                    Name = _name,
                    Components =
                    {
                        new CuiTextComponent
                        {
                            Text = localizedText,
                            FontSize = _size,
                            Font = _font,
                            Align = _align,
                            Color = _color,
                            FadeIn = _fadeIn,
                        },
                        new CuiOutlineComponent
                        {
                            Color = _outlineColor,
                            Distance = _outlineScale
                        },
                        new CuiRectTransformComponent
                        {
                            AnchorMin = _anchorMin,
                            AnchorMax = _anchorMax
                        }
                    },
                    FadeOut = _fadeOut
                });
            }
            public static void CreateButton(ref CuiElementContainer _container, string _parent, string _name, string _color, string _text, int _size, string _anchorMin, string _anchorMax, string _command = "", string _close = "", string _textColor = "0.843 0.816 0.78 1", float _fade = 1.0f, TextAnchor _align = TextAnchor.MiddleCenter, string _font = "robotocondensed-bold.ttf", string _material = "assets/content/ui/uibackgroundblur-ingamemenu.mat")
            {
                _container.Add(new CuiButton
                {
                    Button = { Close = _close, Command = _command, Color = _color, Material = _material, FadeIn = _fade },
                    RectTransform = { AnchorMin = _anchorMin, AnchorMax = _anchorMax },
                    Text = { Text = _text, FontSize = _size, Align = _align, Color = _textColor, Font = _font, FadeIn = _fade },
                },
                _parent,
                _name);
            }
            public static void CreateImage(ref CuiElementContainer _container, string _parent, string _name, string _url, string _anchorMin = "0 0", string _anchorMax = "1 1", string _sprite = "assets/content/textures/generic/fulltransparent.tga")
            {
                _container.Add(new CuiElement
                {
                    Name = _name,
                    Parent = _parent,
                    Components =
            {
                new CuiRawImageComponent { Url = _url, Sprite = _sprite },
                new CuiRectTransformComponent { AnchorMin = _anchorMin, AnchorMax = _anchorMax }
            }
                });
            }
            public static void CreateInputField(ref CuiElementContainer _container, string _parent, string _name, string _color, string _anchorMin, string _anchorMax, string _command, string _text = "", int _characterLimit = 4, float _fadeOut = 0f, TextAnchor _align = TextAnchor.MiddleCenter)
            {
                int fontSize;

                switch (_characterLimit)
                {
                    case 4:
                        fontSize = 20;
                        break;
                    case 5:
                        fontSize = 18;
                        break;
                    case 6:
                        fontSize = 15;
                        break;
                    default:
                        fontSize = 20;
                        break;
                }

                _container.Add(new CuiElement
                {
                    Parent = _parent,
                    Name = _name,
                    Components =
        {
            new CuiInputFieldComponent
            {
                Text = _text,
                FontSize = fontSize,
                Align = _align,
                Color = _color,
                Command = _command,
                CharsLimit = _characterLimit
            },
            new CuiRectTransformComponent
            {
                AnchorMin = _anchorMin,
                AnchorMax = _anchorMax
            }
        },
                    FadeOut = _fadeOut
                });
            }
        }
        private void CreateImageFromLibrary(ref CuiElementContainer container, string parent, string name, string imageKey, string anchorMin, string anchorMax)
        {
            if (plugins.Exists("ImageLibrary"))
            {
                string imageData = ImageLibrary.Call<string>("GetImage", imageKey);
                if (!string.IsNullOrEmpty(imageData))
                {
                    container.Add(new CuiElement
                    {
                        Parent = parent,
                        Name = name,
                        Components =
                {
                    new CuiRawImageComponent
                    {
                        Png = imageData,
                    },
                    new CuiRectTransformComponent
                    {
                        AnchorMin = anchorMin,
                        AnchorMax = anchorMax,
                    }
                }
                    });
                }
                else
                {
                    PrintWarning($"Image with key '{imageKey}' not found in ImageLibrary.");
                }
            }
            else
            {
                PrintWarning("ImageLibrary plugin not found.");
            }
        }
        public static float Clamp(float value, float min, float max)
        {
            return Math.Max(min, Math.Min(max, value));
        }
        public double ClampDouble(double value, double min, double max)
        {
            return (value < min) ? min : (value > max) ? max : value;
        }
        void OnPlayerInput(BasePlayer player, string input)
        {
            if (input.StartsWith("Rewards"))
            {
                var splitInput = input.Split(' ');
                var name = splitInput[1];
                var value1 = float.Parse(splitInput[2]);
                var value2 = int.Parse(splitInput[3]);
                rewardsData.Rewards[name] = new RewardsData.RewardValues { Economics = value1, Scrap = value2 };
            }
        }
        public string GetMessage(string key, string userId)
        {
            return lang.GetMessage(key, this, userId);
        }
        #endregion
        #region Subscribe/Unsubscribe
        void SubscribeUnsubscribe(bool enable, string page)
        {
            var pageHooks = new Dictionary<string, List<string>>
    {
        { "StackSize", new List<string> { nameof(OnMaxStackable), nameof(GetStackSize), nameof(CanStackItem), nameof(OnItemSplit), nameof(CalculateStackSize) } },
        { "Smelting", new List<string> { nameof(CanMoveItem), nameof(OnOvenCooked), nameof(OnOvenCook), nameof(OnFuelConsume), nameof(OnMixingTableToggle), nameof(IsMaterialOutput), nameof(BuildMaterialOutputCache) } },
        { "Rewards", new List<string> { nameof(CanAcceptItem), nameof(OnPlayerRespawned), nameof(OnEntityTakeDamage), nameof(OnEntityDestroy) } },
        { "Settings", new List<string> { nameof(UpdateButton), nameof(OnIcon), nameof(OffIcon), nameof(CheckTime), nameof(FreezeTime), nameof(UnfreezeTime), nameof(SetTimeToDawn), nameof(CancelDamage), nameof(HandleDamageProtection), nameof(SetVoteCommand) } }
    };

            switch (page)
            {
                case "GatherRate":
                    Puts($"Gather Rate system {(enable ? "enabled" : "disabled")}.");
                    break;

                case "StackSize":
                    Puts($"Stack Size system {(enable ? "enabled" : "disabled")}.");
                    break;

                case "Smelting":
                    if (enable)
                    {
                        PopulateOvensList();
                        UpdatePreviousAmounts();
                        ApplyOvenChanges();
                    }
                    else
                    {
                        UnloadSmelting();
                    }
                    Puts($"Smelting system {(enable ? "enabled" : "disabled")}.");
                    break;

                case "Rewards":
                    Puts($"Reward system {(enable ? "enabled" : "disabled")}.");
                    break;

                case "Settings":
                    if (enable)
                    {
                        StartTimer();
                        if (settingsData.Settings["freeze"] == "True")
                        {
                            FreezeTime();
                        }
                    }
                    else
                    {
                        _timer?.Destroy();
                        if (settingsData.Settings["freeze"] == "True")
                        {
                            UnfreezeTime();
                        }
                    }
                    Puts($"Settings system {(enable ? "enabled" : "disabled")}.");
                    break;

                default:
                    Puts($"Unknown page: {page}");
                    return;
            }

            if (pageHooks.ContainsKey(page))
            {
                foreach (var hook in pageHooks[page])
                {
                    if (enable)
                    {
                        Subscribe(hook);
                    }
                    else
                    {
                        Unsubscribe(hook);
                    }
                }
            }
        }


        #endregion
        #region Main GUI
        private void MainGui(BasePlayer player)
        {
            var container = new CuiElementContainer();


            if (plugins.Exists("ImageLibrary"))
            {
                CUIClass.CreatePanel(ref container, "Overlay", "TotalControlGUI", "0 0 0 0", "0.5 0", "0.5 0", "-625 50", $"625 650", true, 0, 0, "assets/content/ui/uibackgroundblur.mat", true);
                CreateImageFromLibrary(ref container, "TotalControlGUI", "BackgroundImage", "BackGround", "0 0", "1 1");
                CreateImageFromLibrary(ref container, "TotalControlGUI", "Title", "TotalControl", "0.32 0.875", "0.68 0.97");
                CreateImageFromLibrary(ref container, "TotalControlGUI", "CloseBtn", "RedButton", "0.51 0.02", "0.61 0.073");
                CreateImageFromLibrary(ref container, "TotalControlGUI", "ApplyBtn", "GreenButton", "0.39 0.02", "0.49 0.073");
                CUIClass.CreateButton(ref container, "TotalControlGUI", "CloseBtn", "0.8 0.25 0.17 0", "Close", 22, "0.51 0.02", "0.61 0.073", "set.close", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                CUIClass.CreateButton(ref container, "TotalControlGUI", "ApplyBtn", "0.48 0.67 0.12 0", "Apply", 22, "0.39 0.02", "0.49 0.073", "set.apply", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
            }
            else
            {
                CUIClass.CreatePanel(ref container, "Overlay", "TotalControlGUI", "0 0 0 0.7", "0.5 0", "0.5 0", "-625 50", $"625 650", true, 0, 0, "assets/content/ui/uibackgroundblur.mat", true);
                CUIClass.CreateText(ref container, "TotalControlGUI", "Title", "0.76 0.43 0.2 1", "<i><b>TOTAL CONTROL</b></i>", 50, "0.36 0.855", "0.64 0.995", TextAnchor.MiddleCenter, "RobotoCondensed-Bold.ttf", 0f, 0f, "0 0 0 1", "1 1");
                CUIClass.CreateButton(ref container, "TotalControlGUI", "CloseBtn", "0.8 0.25 0.17 1", "Close", 22, "0.51 0.02", "0.61 0.073", "set.close", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                CUIClass.CreateButton(ref container, "TotalControlGUI", "ApplyBtn", "0.48 0.67 0.12 1", "Apply", 22, "0.39 0.02", "0.49 0.073", "set.apply", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
            }
            CUIClass.CreateText(ref container, "TotalControlGUI", "Note", "1 1 1 1", "Press Apply to save and activate changes.", 16, "0.15 0.02", "0.38 0.073", TextAnchor.MiddleLeft);
            CUIClass.CreatePanel(ref container, "TotalControlGUI", "RightTopPanel", "0 0 0 0", "0.66 0.875", "1 0.975");
            switch (currentPage)
            {
                case 0:
                    CreateGatherRatesPage(ref container, player);
                    break;
                case 1:
                    CreateStackSizePage(ref container, player);
                    break;
                case 2:
                    CreateSmeltingSpeedsPage(ref container, player);
                    break;
                case 3:
                    CreateRewardsPage(ref container, player);
                    break;
                case 4:
                    CreateSettingsPage(ref container, player);
                    break;
            }
            CuiHelper.AddUi(player, container);
            if (!plugins.Exists("Economics"))
            {
                UpdateButton(player, 3, "False");
            }
            if (!plugins.Exists("ServerRewards"))
            {
                UpdateButton(player, 3, "False");
            }
        }
        void UpdateDisableButton(BasePlayer player)
        {
            var container = new CuiElementContainer();
            string newValue = "";
            string buttonColor = "";
            string set1, set2;

            if (plugins.Exists("ImageLibrary"))
            {
                set1 = "GreenButton";
                set2 = "RedButton";
            }
            else
            {
                set1 = "0.48 0.67 0.12 1";
                set2 = "0.8 0.25 0.17 1";
            }
            switch (currentPage)
            {
                case 0:
                    newValue = gatherData.DisableBtn ? "Enabled" : "Disabled";
                    buttonColor = gatherData.DisableBtn ? set1 : set2;
                    break;
                case 1:
                    newValue = stackSizeData.DisableBtn ? "Enabled" : "Disabled";
                    buttonColor = stackSizeData.DisableBtn ? set1 : set2;
                    break;
                case 2:
                    newValue = smeltingData.DisableBtn ? "Enabled" : "Disabled";
                    buttonColor = smeltingData.DisableBtn ? set1 : set2;
                    break;
                case 3:
                    newValue = rewardsData.DisableBtn ? "Enabled" : "Disabled";
                    buttonColor = rewardsData.DisableBtn ? set1 : set2;
                    break;
                case 4:
                    newValue = settingsData.DisableBtn ? "Enabled" : "Disabled";
                    buttonColor = settingsData.DisableBtn ? set1 : set2;
                    break;
            }
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "Title", buttonColor, "0.935 0.03", "0.985 0.063");
                CUIClass.CreateButton(ref container, "TotalControlGUI", "DisableBtn", "0 0 0 0", newValue, 16, "0.935 0.03", "0.985 0.063", $"set.disable {currentPage}", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
            }
            else
            {
                CUIClass.CreateButton(ref container, "TotalControlGUI", "DisableBtn", buttonColor, newValue, 16, "0.935 0.03", "0.985 0.063", $"set.disable {currentPage}", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
            }
            CuiHelper.AddUi(player, container);
        }
        void RefreshUI(BasePlayer player)
        {
            CuiHelper.DestroyUi(player, "DisableBtn");
            UpdateDisableButton(player);
            DestroyCurrentPage(player);
            CreateCurrentPage(player);
        }
        #endregion
        #region Create Pages
        private void CreatePage(ref CuiElementContainer container, string pageName, string color, bool isVisible, BasePlayer player)
        {
            CUIClass.CreatePanel(ref container, "TotalControlGUI", pageName, color, "0.015 0.105", "0.985 0.86", "0 0", "0 0");
            if (currentPage > 0)
            {
                if (plugins.Exists("ImageLibrary"))
                {
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "LeftArrowBtn", "GreenButton", "0.015 0.02", "0.055 0.073");
                    CUIClass.CreateButton(ref container, "LeftArrowBtn", "LeftArrow", "0 0 0 0", "◄", 26, "0 0", "1 1", "set.page.left", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                }
                else
                {
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "LeftArrowBtn", "0.48 0.67 0.12 1", "◄", 26, "0.015 0.02", "0.055 0.073", "set.page.left", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                }
            }
            if (currentPage < 4)
            {
                if (plugins.Exists("ImageLibrary"))
                {
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "RightArrowBtn", "GreenButton", "0.065 0.02", "0.105 0.073");
                    CUIClass.CreateButton(ref container, "RightArrowBtn", "RightArrow", "0 0 0 0", "►", 26, "0 0", "1 1", "set.page.right", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                }
                else
                {
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "RightArrowBtn", "0.48 0.67 0.12 1", "►", 26, "0.065 0.02", "0.105 0.073", "set.page.right", "", "1 1 1 1", 0f, TextAnchor.MiddleCenter, "robotocondensed-bold.ttf");
                }
            }
        }
        void DestroyCurrentPage(BasePlayer player)
        {
            List<string> uiElements = new List<string> { "RightArrowBtn", "LeftArrowBtn" };
            switch (currentPage)
            {
                case 0:
                    if (gatherRatesPage == 0)
                        uiElements.AddRange(new List<string> { "GatherRatesPage", "GatherRatesTitle", "Button2", "Button3", "Button5", "Button10", "ButtonReset" });
                    else
                        uiElements.AddRange(new List<string> { "GatherRatesPage2", "GatherRatesTitle2", "Button2", "Button3", "Button5", "Button10", "ButtonReset" });
                    break;
                case 1:
                    if (stackSizePage == 0)
                        uiElements.AddRange(new List<string> { "StackSizePage", "StackSizeTitle", "Button2", "Button3", "Button5", "Button10", "ButtonReset" });
                    else
                        uiElements.AddRange(new List<string> { "StackSizePage2", "StackSizeTitle2", "Button2", "Button3", "Button5", "Button10", "ButtonReset" });
                    break;
                case 2:
                    uiElements.AddRange(new List<string> { "SmeltingSpeedsPage", "SmeltingSpeedsTitle" });
                    break;
                case 3:
                    if (rewardsPage == 0)
                        uiElements.AddRange(new List<string> { "RewardsPage", "RewardsTitle" });
                    else
                        uiElements.AddRange(new List<string> { "ServerRewardsPage", "ServerRewardsTitle" });

                    break;
                case 4:
                    uiElements.AddRange(new List<string> { "SettingsPage", "SettingsTitle", "SettingsUnderline" });
                    break;
            }
            foreach (string element in uiElements)
            {
                CuiHelper.DestroyUi(player, element);
            }
        }
        void CreateCurrentPage(BasePlayer player)
        {
            var container = new CuiElementContainer();
            switch (currentPage)
            {
                case 0:
                    if (gatherRatesPage == 0)
                    {
                        CreateGatherRatesPage(ref container, player);
                        stackSizePage = 0;
                    }
                    else
                        CreateGatherRatesPage2(ref container, player);
                    break;
                case 1:
                    if (stackSizePage == 0)
                    {
                        CreateStackSizePage(ref container, player);
                        gatherRatesPage = 0;
                    }
                    else
                        CreateStackSizePage2(ref container, player);
                    break;
                case 2:

                    CreateSmeltingSpeedsPage(ref container, player);
                    stackSizePage = 0;
                    rewardsPage = 0;
                    break;
                case 3:
                    if (rewardsPage == 0)
                        CreateRewardsPage(ref container, player);
                    else
                        CreateServerRewardsPage(ref container, player);
                    break;
                case 4:
                    CreateSettingsPage(ref container, player);
                    rewardsPage = 0;
                    break;
            }
            CuiHelper.AddUi(player, container);
        }
        private void CreateMultiplierButtons(ref CuiElementContainer container)
        {
            if (gatherData.DisableBtn || stackSizeData.DisableBtn)
            {
                if (plugins.Exists("ImageLibrary"))
                {
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "Button2", "X2Button", "0.725 0.84", "0.763 0.915");
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "Button3", "X3Button", "0.765 0.84", "0.803 0.915");
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "Button5", "X5Button", "0.805 0.84", "0.843 0.915");
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "Button10", "X10Button", "0.845 0.84", "0.883 0.915");
                    CreateImageFromLibrary(ref container, "TotalControlGUI", "ButtonReset", "ResetButton", "0.887 0.84", "0.925 0.915");
                    CUIClass.CreateButton(ref container, "Button2", "x2", "0 0 0 0", "", 24, "0.1 0.1", "0.9 0.9", $"set.applyx2", "", "1 1 1 0", 1);
                    CUIClass.CreateButton(ref container, "Button3", "x3", "0 0 0 0", "", 24, "0.1 0.1", "0.9 0.9", "set.applyx3", "", "0.48 0.67 0.12 0", 0);
                    CUIClass.CreateButton(ref container, "Button5", "x5", "0 0 0 0", "", 24, "0.1 0.1", "0.9 0.9", "set.applyx5", "", "0.48 0.67 0.12 0", 0);
                    CUIClass.CreateButton(ref container, "Button10", "x10", "0 0 0 0", "", 24, "0.1 0.1", "0.9 0.9", "set.applyx10", "", "0.48 0.67 0.12 0", 0);
                    CUIClass.CreateButton(ref container, "ButtonReset", "reset", "0 0 0 0", "", 24, "0.1 0.1", "0.9 0.9", "set.applyreset", "", "0.48 0.67 0.12 0", 0);
                }
                else
                {
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "Button2", "0 0 0 0", "", 24, "0.725 0.84", "0.75 0.92", $"set.applyx2", "", "0.48 0.67 0.12 1", 0);
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "Button3", "0 0 0 0", "", 24, "0.76 0.84", "0.785 0.92", "set.applyx3", "", "0.48 0.67 0.12 1", 0);
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "Button5", "0 0 0 0", "", 24, "0.795 0.84", "0.82 0.92", "set.applyx5", "", "0.48 0.67 0.12 1", 0);
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "Button10", "0 0 0 0", "", 24, "0.83 0.84", "0.865 0.92", "set.applyx10", "", "0.48 0.67 0.12 1", 0);
                    CUIClass.CreateButton(ref container, "TotalControlGUI", "ButtonReset", "0 0 0 0", "", 24, "0.875 0.84", "0.925 0.92", "set.applyreset", "", "0.48 0.67 0.12 1", 0);

                    CUIClass.CreateText(ref container, "Button2", "x2", "0.48 0.67 0.12 1", "X2", 26, "0 0", "1 1", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreateText(ref container, "Button3", "x3", "0.48 0.67 0.12 1", "X3", 26, "0 0", "1 1", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreateText(ref container, "Button5", "x5", "0.48 0.67 0.12 1", "X5", 26, "0 0", "1 1", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreateText(ref container, "Button10", "x10", "0.48 0.67 0.12 1", "X10", 26, "0 0", "1 1", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreateText(ref container, "ButtonReset", "reset", "0.48 0.67 0.12 1", "Reset", 24, "0 0", "1 1", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
                }
            }
        }
        #endregion
        #region Gather Rates
        private void CreateGatherRatesPage(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "GatherRatesPage", "0 0 0 0", currentPage == 0, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "GatherRatesTitle", "GatherRateName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "GatherRatesTitle", "0.8 0.25 0.17 1", "GATHER RATES", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (gatherData.DisableBtn)
            {
                CreateMultiplierButtons(ref container);
                CUIClass.CreateText(ref container, "GatherRatesPage", "HelpInfo", "0.8 0.25 0.17 1", "IF VALUE IS 1 THEN GATHER RATE IS ORIGINAL AMOUNT", 16, "0.05 0.93", "0.95 0.99", TextAnchor.MiddleCenter, "RobotoCondensed-Bold.ttf", 0f, 0f, "0 0 0 1", "1 1");
                CUIClass.CreateButton(ref container, "GatherRatesPage", "NextButton", "0.8 0.25 0.17 0", "►", 30, "0.96 0.03", "0.99 0.12", "set.pagetwo", "", "0.12 0.51 0.67 1", 0);

                for (int i = 0; i < gatherNames.Count; i++)
                {
                    float defaultValue = gatherData.GatherRates.ContainsKey(gatherNames[i]) ? gatherData.GatherRates[gatherNames[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 0.1f, 999999f);

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];
                    CUIClass.CreatePanel(ref container, "GatherRatesPage", $"GNamePanel_{i}", "0 0 0 1", $"{xPos} {yPos}", $"{xPos + 0.16} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"GNamePanel_{i}", "GatherRates", "1 1 1 1", GatherDisplayNames[i], 20, "0.1 0.1", "0.9 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreatePanel(ref container, "GatherRatesPage", $"GPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.165} {yPos}", $"{xPos + 0.2} {yPos + 0.07}");
                    CUIClass.CreateInputField(ref container, $"GPanel_{i}", "GatherRates", "1 1 1 1", "0 0.1", "1 0.9", $"set.gather {gatherNames[i]}", defaultValue.ToString(), 6);
                }
            }
        }
        private void CreateGatherRatesPage2(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "GatherRatesPage2", "0 0 0 0", currentPage == 0, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "GatherRatesTitle2", "GatherRateName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "GatherRatesTitle2", "0.8 0.25 0.17 1", "GATHER RATES", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (gatherData.DisableBtn)
            {
                CreateMultiplierButtons(ref container);

                CUIClass.CreateButton(ref container, "GatherRatesPage2", "BackButton", "0.8 0.25 0.17 0", "◄", 30, "0.96 0.03", "0.99 0.12", "set.pageone", "", "0.12 0.51 0.67 1", 0);
                CUIClass.CreateText(ref container, "GatherRatesPage2", "HelpInfo", "0.8 0.25 0.17 1", "IF VALUE IS 1 THEN GATHER RATE IS ORIGINAL AMOUNT", 16, "0.05 0.93", "0.95 0.99", TextAnchor.MiddleCenter, "RobotoCondensed-Bold.ttf", 0f, 0f, "0 0 0 1", "1 1");
                for (int i = 0; i < gatherNames2.Count; i++)
                {
                    float defaultValue = gatherData.GatherRates.ContainsKey(gatherNames2[i]) ? gatherData.GatherRates[gatherNames2[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 0.1f, 999999f);

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];

                    CUIClass.CreatePanel(ref container, "GatherRatesPage2", $"GNamePanel_{i}", "0 0 0 1", $"{xPos} {yPos}", $"{xPos + 0.16} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"GNamePanel_{i}", "GatherRates", "1 1 1 1", GatherDisplayNames2[i], 20, "0.1 0.1", "0.9 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreatePanel(ref container, "GatherRatesPage2", $"GPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.165} {yPos}", $"{xPos + 0.2} {yPos + 0.07}");
                    CUIClass.CreateInputField(ref container, $"GPanel_{i}", "GatherRates", "1 1 1 1", "0 0.1", "1 0.9", $"set.gather {gatherNames2[i]}", defaultValue.ToString(), 6);
                }
            }
        }
        private void OnCollectiblePickup(CollectibleEntity collectible, BasePlayer player)
        {
            #region Gather Rate
            if (gatherData.DisableBtn)
            {
                foreach (ItemAmount item in collectible.itemList)
                {
                    var itemShortname = item.itemDef.shortname;
                    float modifier;
                    bool hasModifier = gatherData.GatherRates.TryGetValue(itemShortname, out modifier) ||
                                       gatherData.GatherRates.TryGetValue(collectible.ShortPrefabName, out modifier);

                    if (!hasModifier && itemShortname.Contains("mushroom"))
                    {
                        hasModifier = gatherData.GatherRates.TryGetValue("Mushroom", out modifier);
                    }

                    if (hasModifier)
                    {
                        item.amount = Math.Max(1, (int)(item.amount * modifier));
                    }
                }
            }
            #endregion
            #region Rewards
            if (rewardsData.DisableBtn)
            {
                if (player == null || collectible == null) return;
                string resource = null;
                float amount = 0f;
                if (collectible.ShortPrefabName.Contains("berry"))
                {
                    if (rewardsData.Rewards.TryGetValue("Berries", out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        resource = "Berries";
                    }
                    else
                    {
                        Console.WriteLine("Berries not found in rewards data.");
                    }
                }
                else if (collectible.ShortPrefabName.Contains("mushroom"))
                {
                    if (rewardsData.Rewards.TryGetValue("Mushroom", out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        resource = "Mushroom";
                    }
                    else
                    {
                        Console.WriteLine("Mushroom not found in rewards data.");
                    }
                }
                else
                {
                    foreach (var configValue in rewardsData.Rewards)
                    {
                        if (!collectible.ToString().ToLower().Contains(configValue.Key.ToLower()))
                            continue;
                        amount = configValue.Value.Economics;
                        resource = configValue.Key;
                        break;
                    }
                }
                if (Interface.CallHook("OnGatherRewardsGiveCredit", player, collectible, amount) != null) return;
                if (resource != null)
                {
                    RewardPlayer(player, "gather", resource);
                }
            }
            #endregion
        }
        private void OnDispenserGather(ResourceDispenser dispenser, BasePlayer player, Item item)
        {
            #region Gather Rate
            if (gatherData.DisableBtn)
            {
                float modifier;
                if (gatherData.GatherRates.TryGetValue(item.info.shortname, out modifier))
                {
                    item.amount = Math.Max(1, (int)(item.amount * modifier));
                }
                else
                {
                    if (gatherData.GatherRates.TryGetValue(item.info.shortname, out float defaultModifier))
                    {
                        item.amount = Math.Max(1, (int)(item.amount * defaultModifier));
                    }
                    else if (Meats.Contains(item.info.shortname))
                    {
                        if (gatherData.GatherRates.TryGetValue("Meat", out defaultModifier))
                        {
                            item.amount = Math.Max(1, (int)(item.amount * defaultModifier));
                        }
                    }
                }
            }
            #endregion
            #region Rewards
            if (rewardsData.DisableBtn)
            {
                if (player == null)
                {
                    return;
                }
                var shortName = item.info.shortname;
                float rewardThreshold = 0f;

                if (!rewardsData.Rewards.TryGetValue(shortName, out RewardsData.RewardValues rewardValues))
                {
                    return;
                }
                if (rewardsData.Settings.TryGetValue("Award_Only_On_Full_Harvest", out var awardOnlyOnFullHarvestString) && bool.TryParse(awardOnlyOnFullHarvestString, out var awardOnlyOnFullHarvest) && awardOnlyOnFullHarvest)
                {
                    if (player.GetHeldEntity() is Chainsaw)
                    {
                        if (rewardsData.Modifiersettings.TryGetValue("Chainsaw_Modifier", out var Rmodifier) && dispenser.fractionRemaining <= rewardThreshold)
                        {
                            float ecoReward = rewardValues.Economics * Rmodifier;
                            int scrapReward = (int)Math.Round(rewardValues.Scrap * Rmodifier);
                            float serverReward = rewardValues.ServerRewards * Rmodifier;

                            RewardAmount(player, "gather", (int)Math.Round(ecoReward), scrapReward, (int)Math.Round(serverReward), shortName);
                        }
                    }
                    else if (player.GetHeldEntity() is Jackhammer)
                    {
                        if (rewardsData.Modifiersettings.TryGetValue("JackHammer_Modifier", out var Rmodifier) && dispenser.fractionRemaining <= rewardThreshold)
                        {
                            float ecoReward = rewardValues.Economics * Rmodifier;
                            int scrapReward = (int)Math.Round(rewardValues.Scrap * Rmodifier);
                            float serverReward = rewardValues.ServerRewards * Rmodifier;

                            RewardAmount(player, "gather", (int)Math.Round(ecoReward), scrapReward, (int)Math.Round(serverReward), shortName);
                        }
                    }
                    else if ((dispenser.gatherType == ResourceDispenser.GatherType.Tree || dispenser.gatherType == ResourceDispenser.GatherType.Ore) && dispenser.fractionRemaining <= rewardThreshold)
                    {
                        RewardPlayer(player, "gather", shortName);
                    }

                    else if (dispenser.GetComponent<BaseEntity>() == null)
                    {
                        RewardPlayer(player, "gather", shortName);
                    }
                }
                else
                {
                    if (player.GetHeldEntity() is Chainsaw)
                    {
                        if (rewardsData.Modifiersettings.TryGetValue("Chainsaw_Modifier", out var Rmodifier))
                        {
                            float ecoReward = rewardValues.Economics * Rmodifier;
                            int scrapReward = (int)Math.Round(rewardValues.Scrap * Rmodifier);
                            float serverReward = rewardValues.ServerRewards * Rmodifier;

                            RewardAmount(player, "gather", (int)Math.Round(ecoReward), scrapReward, (int)Math.Round(serverReward), shortName);
                        }
                    }
                    else if (player.GetHeldEntity() is Jackhammer)
                    {
                        if (rewardsData.Modifiersettings.TryGetValue("JackHammer_Modifier", out var Rmodifier))
                        {
                            float ecoReward = rewardValues.Economics * Rmodifier;
                            int scrapReward = (int)Math.Round(rewardValues.Scrap * Rmodifier);
                            float serverReward = rewardValues.ServerRewards * Rmodifier;

                            RewardAmount(player, "gather", (int)Math.Round(ecoReward), scrapReward, (int)Math.Round(serverReward), shortName);
                        }
                    }
                    else if ((dispenser.gatherType == ResourceDispenser.GatherType.Tree || dispenser.gatherType == ResourceDispenser.GatherType.Ore))
                    {
                        RewardPlayer(player, "gather", shortName);
                    }
                    else if (dispenser.GetComponent<BaseEntity>() == null)
                    {
                        RewardPlayer(player, "gather", shortName);
                    }
                }
            }
            #endregion
        }
        private void OnDispenserBonus(ResourceDispenser dispenser, BasePlayer player, Item item)
        {
            if (gatherData.DisableBtn)
            {
                OnDispenserGather(dispenser, player, item);
            }
        }
        private void OnGrowableGathered(GrowableEntity growable, Item item, BasePlayer player)
        {
            if (gatherData.DisableBtn)
            {
                float modifier;
                if (item.info.shortname != "cloth" && gatherData.GatherRates.TryGetValue(item.info.shortname, out modifier))
                {
                    item.amount = Math.Max(1, (int)(item.amount * modifier));
                }
                else
                {
                    if (item.info.shortname != "cloth" && gatherData.GatherRates.TryGetValue(item.info.shortname, out float defaultModifier))
                    {
                        item.amount = Math.Max(1, (int)(item.amount * defaultModifier));
                    }
                    else
                    {
                        Dictionary<string, string> colorToKeyMap = new Dictionary<string, string>
            {
                {"red", "berry-red-collectable"},
                {"blue", "berry-blue-collectable"},
                {"green", "berry-green-collectable"},
                {"yellow", "berry-yellow-collectable"},
                {"white", "berry-white-collectable"},
                {"pumpkin", "pumpkin-collectable"},
                {"corn", "corn-collectable"},
                {"cloth", "hemp-collectable"},
                {"potato", "potato-collectable"}
            };
                        foreach (var color in colorToKeyMap.Keys)
                        {
                            if (item.info.shortname.Contains(color))
                            {
                                if (gatherData.GatherRates.TryGetValue(colorToKeyMap[color], out defaultModifier))
                                {
                                    item.amount = Math.Max(1, (int)(item.amount * defaultModifier));
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        void OnLootEntity(BasePlayer player, BaseEntity entity)
        {
            #region Gather Rates
            if (gatherData.DisableBtn)
            {
                if (entity is StorageContainer crate)
                {
                    if (crate.ShortPrefabName.Contains("crate") || crate.ShortPrefabName.Contains("trash") || crate.ShortPrefabName.Contains("vehicle_parts"))
                    {
                        var items = crate.inventory.itemList;
                        foreach (var item in items)
                        {
                            var originalItem = crate.ToString() + item.info.shortname;
                            var itemShortName = item.info.shortname;
                            var itemCategory = item.info.category.ToString();
                            var stackSize = item.info.stackable;
                            if (!OrginalCreateAmount.ContainsKey(originalItem))
                            {
                                OrginalCreateAmount[originalItem] = item.amount;
                                CurrentMultiplier[originalItem] = 1;
                            }
                            float defaultModifier;
                            if (itemCategory == "Ammunition" && stackSize > 1 && gatherData.GatherRates.TryGetValue(itemCategory, out defaultModifier) || itemCategory == "Electrical" && stackSize > 1 && gatherData.GatherRates.TryGetValue(itemCategory, out defaultModifier) || itemCategory == "Food" && stackSize > 1 && gatherData.GatherRates.TryGetValue(itemCategory, out defaultModifier))
                            {
                                if (CurrentMultiplier[originalItem] != defaultModifier)
                                {
                                    item.amount = Math.Max(1, (int)(OrginalCreateAmount[originalItem] * defaultModifier / CurrentMultiplier[originalItem]));
                                    OrginalCreateAmount[originalItem] = item.amount;
                                    CurrentMultiplier[originalItem] = defaultModifier;
                                }
                            }
                            if (gatherData.GatherRates.TryGetValue(itemShortName, out defaultModifier))
                            {
                                if (CurrentMultiplier[originalItem] != defaultModifier)
                                {
                                    item.amount = Math.Max(1, (int)(OrginalCreateAmount[originalItem] * defaultModifier / CurrentMultiplier[originalItem]));
                                    OrginalCreateAmount[originalItem] = item.amount;
                                    CurrentMultiplier[originalItem] = defaultModifier;
                                }
                            }
                        }
                    }
                }
            }
            #endregion
            #region Smelting
            if (smeltingData.DisableBtn)
            {
                BaseOven oven = entity as BaseOven;
                if (oven != null)
                {
                    string ovenKey = GetOvenKey(oven);
                    if (smeltingData.OutputMultiplier.TryGetValue(ovenKey, out float amountMultiplier))
                    {
                        int multiplier = (int)amountMultiplier;
                        var currentItems = new HashSet<int>(oven.inventory.itemList.Select(slotItem => slotItem.info.itemid));
                        if (_previousAmounts.TryGetValue(oven.net.ID, out var previousAmounts))
                        {
                            foreach (var itemId in previousAmounts.Keys.ToList())
                            {
                                if (!currentItems.Contains(itemId))
                                {
                                    previousAmounts.Remove(itemId);
                                }
                            }
                            foreach (var slotItem in oven.inventory.itemList)
                            {
                                if (IsMaterialOutput(oven, slotItem))
                                {
                                    if (!previousAmounts.TryGetValue(slotItem.info.itemid, out var previousAmountDict))
                                    {
                                        previousAmountDict = new Dictionary<int, int>();
                                        previousAmounts[slotItem.info.itemid] = previousAmountDict;
                                    }
                                    previousAmountDict.TryGetValue(slotItem.position, out var previousAmount);
                                    if (slotItem.amount < previousAmount)
                                    {
                                        previousAmountDict[slotItem.position] = slotItem.amount;
                                    }
                                    else if (slotItem.amount != previousAmount)
                                    {
                                        int newAmount = slotItem.amount - previousAmount;
                                        if (slotItem.info.shortname != "charcoal")
                                        {
                                            slotItem.amount = previousAmount + newAmount * multiplier;
                                        }
                                        previousAmountDict[slotItem.position] = slotItem.amount;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            #endregion
        }
        void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            #region Gather Rates
            if (gatherData.DisableBtn)
            {
                if (entity is LootContainer barrel)
                {
                    var items = barrel.inventory.itemList;
                    foreach (var item in items)
                    {
                        var originalItem = barrel.ShortPrefabName + item.info.shortname;
                        var itemShortName = item.info.shortname;
                        if (!OrginalBarrelAmount.ContainsKey(originalItem))
                        {
                            OrginalBarrelAmount[originalItem] = item.amount;
                        }
                        float modifier;
                        if (gatherData.GatherRates.TryGetValue(originalItem, out modifier))
                        {
                            item.amount = Math.Max(1, (int)(OrginalBarrelAmount[originalItem] * modifier));
                        }
                        else
                        {
                            if (gatherData.GatherRates.TryGetValue(itemShortName, out float defaultModifier))
                            {
                                item.amount = Math.Max(1, (int)(OrginalBarrelAmount[originalItem] * defaultModifier));
                            }
                        }
                    }
                    OrginalBarrelAmount.Clear();
                }
            }
            #endregion
            #region Rewards
            if (rewardsData.DisableBtn)
            {
                BasePlayer player = entity as BasePlayer;
                BasePlayer initiator = info?.Initiator?.ToPlayer();
                if (player != null && !player.ShortPrefabName.Contains("npc"))
                {
                    HandlePlayerDeath(player, initiator, info);
                }
                else if (initiator != null)
                {
                    HandleEntityDeath(entity, initiator, info);
                }
                if (entity.ShortPrefabName == "patrolhelicopter")
                {
                    if (rewardsData.Rewards.TryGetValue(entity.ShortPrefabName, out RewardsData.RewardValues rewardValues) &&
                        rewardsData.Settings.TryGetValue("Divided_Loot", out string divideLoot))
                    {
                        float TotalEcoReward = rewardValues.Economics;
                        int TotalScrapReward = rewardValues.Scrap;
                        float TotalServerReward = rewardValues.ServerRewards;

                        if (divideLoot == "True")
                        {
                            float totalDamage = playerDamageHeli.Values.Sum();

                            foreach (var entry in playerDamageHeli)
                            {
                                ulong playerID = entry.Key;
                                float damage = entry.Value;
                                float percentage = (damage / totalDamage) * 100;
                                percentage = (float)Math.Round(percentage, 0);

                                float ecoReward = (percentage / 100) * TotalEcoReward;
                                int scrapReward = (int)Math.Round((percentage / 100) * TotalScrapReward);
                                float serverReward = (percentage / 100) * TotalServerReward;

                                player = BasePlayer.FindByID(playerID);
                                if (player != null)
                                {
                                    RewardAmount(player, "kill", ecoReward, scrapReward, serverReward, entity.ShortPrefabName);

                                    var message = string.Format(GetMessage("damageMessage", player.UserIDString), player.displayName, percentage, entity.ShortPrefabName);
                                    PrintToChat(player, $"<color=#cd412bff>{message}</color>");
                                }
                            }

                            playerDamageHeli.Clear();
                            totalHealthHeli = 0;
                        }
                        else if (divideLoot == "False")
                        {
                            if (lastPlayer != null)
                            {
                                RewardPlayer(lastPlayer, "kill", entity.ShortPrefabName);
                            }
                        }
                    }
                }
            }

            #endregion
        }
        Item OnFishCatch(Item item, BaseFishingRod rod, BasePlayer player)
        {
            if (gatherData.DisableBtn)
            {
                if (item.info.shortname.Contains("fish"))
                {
                    if (gatherData.GatherRates.TryGetValue("fish", out float defaultModifier))
                    {
                        item.amount = Math.Max(1, (int)(item.amount * defaultModifier));
                    }
                }
            }
            return item;
        }
        void OnQuarryGather(MiningQuarry quarry, Item item)
        {
            if (gatherData.DisableBtn)
            {
                float stonesQuarryRate = (gatherData.GatherRates["quarryStones"]);
                float metalQuarryRate = (gatherData.GatherRates["quarryMetal"]);
                float sulfurQuarryRate = (gatherData.GatherRates["quarrySulfur"]);
                float hqMetalQuarryRate = (gatherData.GatherRates["quarryHQM"]);
                if (item.info.shortname == "stones")
                {
                    item.amount *= (int)stonesQuarryRate;
                }
                if (item.info.shortname == "metal.ore")
                {
                    item.amount *= (int)metalQuarryRate;
                }
                if (item.info.shortname == "sulfur.ore")
                {
                    item.amount *= (int)sulfurQuarryRate;
                }
                if (item.info.shortname == "hq.metal.ore")
                {
                    item.amount *= (int)hqMetalQuarryRate;
                }
            }
        }
        object OnExcavatorGather(ExcavatorArm arm, Item item)
        {
            if (gatherData.DisableBtn)
            {
                float sulfurExcavRate = (gatherData.GatherRates["excavSulfur"]);
                float stoneExcavRate = (gatherData.GatherRates["excavStones"]);
                float metalExcavRate = (gatherData.GatherRates["excavMetal"]);
                float hqMetalExcavRate = (gatherData.GatherRates["excavHQM"]);
                if (item.info.shortname == "hq.metal.ore")
                {
                    item.amount *= (int)hqMetalExcavRate;
                }
                if (item.info.shortname == "metal.fragments")
                {
                    item.amount *= (int)metalExcavRate;
                }
                if (item.info.shortname == "stones")
                {
                    item.amount *= (int)stoneExcavRate;
                }
                if (item.info.shortname == "sulfur.ore")
                {
                    item.amount *= (int)sulfurExcavRate;
                }
            }
            return null;
        }
        void UnloadWaterCatcher()
        {
            foreach (var waterCatcher in BaseNetworkable.serverEntities.OfType<WaterCatcher>())
            {
                waterCatcher.collectionRates.baseRate = defaultBaseRate;
                waterCatcher.collectionRates.rainRate = defaultRainRate;
                waterCatcher.collectionRates.snowRate = defaultSnowRate;
                waterCatcher.collectionRates.fogRate = defaultFogRate;
                catcherUnloaded = false;
            }
        }
        object OnWaterCollect(WaterCatcher waterCatcher)
        {
            if (!gatherData.DisableBtn)
            {
                if (catcherUnloaded == true)
                {
                    UnloadWaterCatcher();
                }
            }
            if (gatherData.DisableBtn)
            {
                if (catcherUnloaded == false)
                {
                    catcherUnloaded = true;
                }
                float largeWaterRate = (gatherData.GatherRates["largeWaterCatcher"]);
                float smallWaterRate = (gatherData.GatherRates["smallWaterCatcher"]);
                if (waterCatcher.ShortPrefabName.Contains("small"))
                {
                    waterCatcher.collectionRates.baseRate = defaultBaseRate * smallWaterRate;
                    waterCatcher.collectionRates.rainRate = defaultRainRate * smallWaterRate;
                    waterCatcher.collectionRates.snowRate = defaultSnowRate * smallWaterRate;
                    waterCatcher.collectionRates.fogRate = defaultFogRate * smallWaterRate;
                }
                else
                {
                    waterCatcher.collectionRates.baseRate = defaultBaseRate * largeWaterRate;
                    waterCatcher.collectionRates.rainRate = defaultRainRate * largeWaterRate;
                    waterCatcher.collectionRates.snowRate = defaultSnowRate * largeWaterRate;
                    waterCatcher.collectionRates.fogRate = defaultFogRate * largeWaterRate;
                }
            }
            return null;
        }
        #endregion
        #region Stack Size  
        private void CreateStackSizePage(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "StackSizePage", "0 0 0 0", currentPage == 1, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "StackSizeTitle", "StackSizesName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "StackSizeTitle", "0.8 0.25 0.17 1", "STACK SIZE", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (stackSizeData.DisableBtn)
            {
                CreateMultiplierButtons(ref container);
                CUIClass.CreateButton(ref container, "StackSizePage", "NextButton", "0.8 0.25 0.17 0", "►", 30, "0.96 0.03", "0.99 0.12", "set.pagetwo", "", "0.76 0.43 0.2 1", 0);
                CUIClass.CreateText(ref container, "StackSizePage", "HelpInfo", "0.8 0.25 0.17 1", "IF VALUE IS 0 THEN MULTIPLIER FOR ITEM STACK SIZE IS SET FROM CATEGORY", 16, "0.05 0.93", "0.95 0.99", TextAnchor.MiddleCenter, "RobotoCondensed-Bold.ttf", 0f, 0f, "0 0 0 1", "1 1");

                for (int i = 0; i < StackNames.Count; i++)
                {
                    float defaultValue = stackSizeData.StackSize.ContainsKey(StackNames[i]) ? stackSizeData.StackSize[StackNames[i]].StackSize : 1.0f;
                    defaultValue = Clamp(defaultValue, 0f, 100000f);

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];

                    CUIClass.CreatePanel(ref container, "StackSizePage", $"StNamePanel_{i}", "0 0 0 1", $"{xPos} {yPos}", $"{xPos + 0.175} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"StNamePanel_{i}", "StackSize", "1 1 1 1", StackDisplayNames[i], 20, "0.1 0.1", "0.9 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreatePanel(ref container, "StackSizePage", $"StPanel_{i}", "0.12 0.51 0.67 1", $"{xPos + 0.18} {yPos}", $"{xPos + 0.215} {yPos + 0.07}");
                    CUIClass.CreateInputField(ref container, $"StPanel_{i}", "StackSize", "1 1 1 1", "0 0.1", "1 0.9", $"set.stacksize {StackNames[i]}", defaultValue.ToString(), 6);
                }
            }
        }
        private void CreateStackSizePage2(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "StackSizePage2", "0 0 0 0", currentPage == 1, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "StackSizeTitle2", "StackSizesName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "StackSizeTitle2", "0.8 0.25 0.17 1", "STACK SIZE", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (stackSizeData.DisableBtn)
            {
                CreateMultiplierButtons(ref container);

                CUIClass.CreateButton(ref container, "StackSizePage2", "BackButton", "0.8 0.25 0.17 0", "◄", 30, "0.96 0.03", "0.99 0.12", "set.pageone", "", "0.76 0.43 0.2 1", 0);
                CUIClass.CreateText(ref container, "StackSizePage2", "HelpInfo", "0.8 0.25 0.17 1", "IF VALUE IS 0 THEN MULTIPLIER FOR ITEM STACK SIZE IS SET FROM CATEGORY", 16, "0.05 0.93", "0.95 0.99", TextAnchor.MiddleCenter, "RobotoCondensed-Bold.ttf", 0f, 0f, "0 0 0 1", "1 1");
                for (int i = 0; i < StackNames2.Count; i++)
                {
                    float defaultValue = stackSizeData.StackSize.ContainsKey(StackNames2[i]) ? stackSizeData.StackSize[StackNames2[i]].StackSize : 1.0f;
                    defaultValue = Clamp(defaultValue, 0f, 100000f);

                    int fontSize = 20;
                    string fontColor = "1 1 1 1";

                    if (Category.Contains(StackNames2[i]))
                    {
                        defaultValue = Clamp(defaultValue, 1.0f, 100000f);
                        fontSize = 22;
                        fontColor = "0.48 0.67 0.12 1";
                    }

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];

                    CUIClass.CreatePanel(ref container, "StackSizePage2", $"StNamePanel_{i}", "0 0 0 1", $"{xPos} {yPos}", $"{xPos + 0.175} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"StNamePanel_{i}", "StackSize", fontColor, StackDisplayNames2[i], fontSize, "0.1 0.1", "0.9 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreatePanel(ref container, "StackSizePage2", $"StPanel_{i}", "0.12 0.51 0.67 1", $"{xPos + 0.18} {yPos}", $"{xPos + 0.215} {yPos + 0.07}");
                    CUIClass.CreateInputField(ref container, $"StPanel_{i}", "StackSize", "1 1 1 1", "0 0.1", "1 0.9", $"set.stacksize {StackNames2[i]}", defaultValue.ToString(), 6);
                }
            }
        }
        private int GetStackSize(Item item)
        {
            string itemId = item.info.itemid.ToString();
            if (stackSizeCache.ContainsKey(itemId))
            {
                return stackSizeCache[itemId];
            }

            int stackSize = CalculateStackSize(item);
            stackSizeCache[itemId] = stackSize;
            return stackSize;
        }
        object CanStackItem(Item item, Item targetItem)
        {
            if (targetItem.blueprintTarget != item.blueprintTarget ||
                targetItem.info.shortname != item.info.shortname ||
                targetItem.name != item.name ||
                targetItem.text != item.text ||
                targetItem.skin != item.skin)
                return false;

            return null;
        }
        Item OnItemSplit(Item item, int amount)
        {
            if (amount <= 0 || item.amount < amount)
                return null;

            if (item.IsBlueprint())
            {
                return null;
            }

            Item newItem = ItemManager.CreateByItemID(item.info.itemid, amount, item.skin);
            if (newItem == null)
                return null;

            bool shouldReturnNewItem = false;

            if (!string.IsNullOrEmpty(item.name) && item.name != item.info.displayName.english)
            {
                newItem.name = item.name;
                shouldReturnNewItem = true;
            }

            if (!string.IsNullOrEmpty(item.text))
            {
                newItem.text = item.text;
                shouldReturnNewItem = true;
            }

            if (item.skin != 0)
            {
                newItem.skin = item.skin;
                shouldReturnNewItem = true;
            }

            if (shouldReturnNewItem)
            {
                item.amount -= amount;
                item.MarkDirty();
                return newItem;
            }
            return null;
        }
        private int CalculateStackSize(Item item)
        {
            if (stackSizeData.DisableBtn)
            {
                string itemId = item.info.itemid.ToString();
                string itemCategory = item.info.category.ToString();
                ItemData itemData;

                if (item.info.shortname == "water")
                {
                    return item.info.stackable;
                }

                if (!originalStackSizes.ContainsKey(item.info.itemid))
                {
                    originalStackSizes[item.info.itemid] = item.info.stackable;
                }

                if (item.info.stackable == 1)
                {
                    singleStackItems.Add(item.info.itemid.ToString());
                    item.info.stackable = 2;
                }

                if (stackSizeData.StackSize.TryGetValue(item.info.shortname, out itemData))
                {
                    float stackSize;
                    if (float.TryParse(itemData.StackSize.ToString(), out stackSize) && stackSize != 0)
                    {
                        if (itemData.Mode == "x")
                        {
                            item.info.stackable = (int)(item.info.stackable * stackSize);
                        }
                        else
                        {
                            item.info.stackable = Mathf.RoundToInt(stackSize);
                        }
                        return item.info.stackable;
                    }
                }

                if (stackSizeData.StackSize.TryGetValue(itemCategory, out itemData))
                {
                    float categorySize;
                    if (float.TryParse(itemData.StackSize.ToString(), out categorySize))
                    {
                        if (item.info.stackable == 1)
                        {
                            singleStackItems.Add(item.info.itemid.ToString());
                            item.info.stackable = 2;
                        }

                        item.info.stackable = singleStackItems.Contains(item.info.itemid.ToString()) ?
                        (int)((item.info.stackable / 2) * categorySize) :
                        (int)(item.info.stackable * categorySize);
                        return item.info.stackable;

                    }
                }
            }

            return item.info.stackable;
        }
        int OnMaxStackable(Item item)
        {
            return GetStackSize(item);
        }
        void ClearStackSizeCache()
        {
            stackSizeCache.Clear();
        }
        void UnloadStackSizes()
        {
            foreach (var itemId in singleStackItems)
            {
                var item = ItemManager.FindItemDefinition(Convert.ToInt32(itemId));
                if (item != null)
                {
                    item.stackable = 1;
                    singleStackItems.Remove(itemId);
                }
            }
        }
        void UpdateModeButton(BasePlayer player, string itemName)
        {
            if (stackSizeData.DisableBtn)
            {
                var container = new CuiElementContainer();
                bool mode = stackSizeData.StackSize[itemName].Mode == "x";
                string modeValue = mode ? "x" : "=";
                string modeColor = mode ? "0.48 0.67 0.12 0.7" : "0.8 0.25 0.17 0.7";
                string buttonId = $"xBtn_{itemName}";
                if (stackSizePage == 0)
                {
                    CuiHelper.DestroyUi(player, buttonId);
                    int itemIndex = StackNames.IndexOf(itemName);
                    int column = itemIndex / columnPositions.Count;
                    int position = itemIndex % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];
                    CUIClass.CreateButton(ref container, "StackSizePage", buttonId, modeColor, modeValue, 16, $"{xPos + 0.159} {yPos + 0.015}", $"{xPos + 0.17} {yPos + 0.053}", $"set.mode {itemName}", "", "1 1 1 1", 0);
                }
                else
                {
                    CuiHelper.DestroyUi(player, buttonId);
                    int itemIndex2 = StackNames2.IndexOf(itemName);
                    int column = itemIndex2 / columnPositions.Count;
                    int position = itemIndex2 % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];
                    if (!Category.Contains(StackNames2[itemIndex2]))
                    {
                        CUIClass.CreateButton(ref container, "StackSizePage2", buttonId, modeColor, modeValue, 16, $"{xPos + 0.158} {yPos + 0.015}", $"{xPos + 0.17} {yPos + 0.055}", $"set.mode {itemName}", "", "1 1 1 1", 0);
                    }
                }
                CuiHelper.AddUi(player, container);
            }
        }
        #endregion
        #region Smelting Speeds
        private void CreateSmeltingSpeedsPage(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "SmeltingSpeedsPage", "0 0 0 0", currentPage == 1, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "SmeltingSpeedsTitle", "SmeltingName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "SmeltingSpeedsTitle", "0.8 0.25 0.17 1", "SMELTING", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }


            if (smeltingData.DisableBtn)
            {
                CUIClass.CreatePanel(ref container, "SmeltingSpeedsPage", "CenterSmeltingPage", "0 0 0 0", "0.2 0.12", "0.8 0.88");
                CUIClass.CreateText(ref container, "CenterSmeltingPage", "smeltSpeeds", "0.48 0.67 0.12 1", "Speed", 26, "0.325 0.845", "0.42 0.935", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                CUIClass.CreateText(ref container, "CenterSmeltingPage", "charcoalAmount", "0.48 0.67 0.12 1", "Charcoal", 26, "0.475 0.845", "0.615 0.935", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                CUIClass.CreateText(ref container, "CenterSmeltingPage", "fuelUsageNames", "0.48 0.67 0.12 1", "Fuel", 26, "0.69 0.845", "0.76 0.935", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                CUIClass.CreateText(ref container, "CenterSmeltingPage", "outputMultiplierNames", "0.48 0.67 0.12 1", "Output", 26, "0.853 0.845", "0.953 0.935", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                for (int i = 0; i < smeltingNames.Count; i++)
                {
                    float defaultValue = smeltingData.Smelting.ContainsKey(smeltingNames[i]) ? smeltingData.Smelting[smeltingNames[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 1.0f, 100f);
                    int column = i / smeltingColumnPositions.Count;
                    int position = i % smeltingColumnPositions.Count;
                    float yPos = smeltingColumnPositions[position];
                    float xPos = columnXPositions[column];
                    CUIClass.CreatePanel(ref container, "CenterSmeltingPage", $"SNamePanel_{i}", "0 0 0 0.9", $"{xPos + 0.005} {yPos - 0.09}", $"{xPos + 0.303} {yPos}");
                    CUIClass.CreateText(ref container, $"SNamePanel_{i}", "SmeltingNames", "1 1 1 1", DisplayNames[i], 20, "0.1 0.1", "0.9 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreatePanel(ref container, "CenterSmeltingPage", $"SPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.313} {yPos - 0.09}", $"{xPos + 0.375} {yPos}");
                    CUIClass.CreateInputField(ref container, $"SPanel_{i}", "Speed", "1 1 1 1", $"0.1 0.1", $"0.9 0.9", $"set.smelting {smeltingNames[i]}", defaultValue.ToString(), 3);
                }
                for (int i = 0; i < charcoalNames.Count; i++)
                {
                    float defaultValue = smeltingData.CharcoalMultiplier.ContainsKey(charcoalNames[i]) ? smeltingData.CharcoalMultiplier[charcoalNames[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 1.0f, 100f);
                    int column = i / smeltingColumnPositions.Count;
                    int position = i % smeltingColumnPositions.Count;
                    float yPos = smeltingColumnPositions[position];
                    float xPos = columnXPositions[column];
                    CUIClass.CreatePanel(ref container, "CenterSmeltingPage", $"ChPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.488} {yPos - 0.09}", $"{xPos + 0.55} {yPos}");
                    CUIClass.CreateInputField(ref container, $"ChPanel_{i}", "Charcoal", "1 1 1 1", "0.1 0.1", "0.9 0.9", $"set.charcoal {charcoalNames[i]}", defaultValue.ToString(), 3);
                }
                for (int i = 0; i < fuelUsageNames.Count; i++)
                {
                    float defaultValue = smeltingData.FuelUsageNames.ContainsKey(fuelUsageNames[i]) ? smeltingData.FuelUsageNames[fuelUsageNames[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 1.0f, 100f);
                    int column = i / smeltingColumnPositions.Count;
                    int position = i % smeltingColumnPositions.Count;
                    float yPos = smeltingColumnPositions[position];
                    float xPos = columnXPositions[column];
                    CUIClass.CreatePanel(ref container, "CenterSmeltingPage", $"FPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.663} {yPos - 0.09}", $"{xPos + 0.725} {yPos}");
                    CUIClass.CreateInputField(ref container, $"FPanel_{i}", "Fuel", "1 1 1 1", "0.1 0.1", "0.9 0.9", $"set.fueluse {fuelUsageNames[i]}", defaultValue.ToString(), 3);
                }
                for (int i = 0; i < outputMultiplierNames.Count; i++)
                {
                    float defaultValue = smeltingData.OutputMultiplier.ContainsKey(outputMultiplierNames[i]) ? smeltingData.OutputMultiplier[outputMultiplierNames[i]] : 1.0f;
                    defaultValue = Clamp(defaultValue, 1.0f, 100f);
                    int column = i / smeltingColumnPositions.Count;
                    int position = i % smeltingColumnPositions.Count;
                    float yPos = smeltingColumnPositions[position];
                    float xPos = columnXPositions[column];
                    CUIClass.CreatePanel(ref container, "CenterSmeltingPage", $"OPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.838} {yPos - 0.09}", $"{xPos + 0.9} {yPos}");
                    CUIClass.CreateInputField(ref container, $"OPanel_{i}", "Output", "1 1 1 1", "0.1 0.1", "0.9 0.9", $"set.output {outputMultiplierNames[i]}", defaultValue.ToString(), 3);
                }
            }
        }
        void UnloadSmelting()
        {
            foreach (var oven in BaseNetworkable.serverEntities.OfType<BaseOven>())
            {
                string ovenKey = GetOvenKey(oven);
                if (originalSmeltSpeed.ContainsKey(ovenKey))
                {
                    oven.smeltSpeed = originalSmeltSpeed[ovenKey];
                }
                if (originalByproductAmounts.ContainsKey(ovenKey))
                {
                    foreach (Item item in oven.inventory.itemList)
                    {
                        ItemModBurnable burnable = item.info.GetComponent<ItemModBurnable>();
                        if (burnable != null)
                        {
                            burnable.byproductAmount = originalByproductAmounts[ovenKey];
                        }
                    }
                }
                if (oven.IsOn())
                {
                    oven.StopCooking();
                    oven.StartCooking();
                }
            }
        }
        void UpdateSmelting()
        {
            if (smeltingData.DisableBtn)
            {
                foreach (var oven in BaseNetworkable.serverEntities.OfType<BaseOven>())
                {
                    string ovenKey = GetOvenKey(oven);
                    if (smeltingData.Smelting.TryGetValue(ovenKey, out float speedMultiplier) && originalSmeltSpeed.ContainsKey(ovenKey))
                    {
                        oven.smeltSpeed = originalSmeltSpeed[ovenKey] * (int)speedMultiplier;
                        updatedSmeltSpeed[ovenKey] = true;
                    }
                    if (oven.IsOn())
                    {
                        oven.StopCooking();
                        oven.StartCooking();
                    }
                }
            }
        }
        object CanMoveItem(Item item, PlayerInventory playerLoot, ItemContainerId targetContainer, int targetSlot, int amount, ItemMoveModifier itemMoveModifier)
        {
            BaseEntity targetEntity = null;
            string targetEntityName = "";

            if (item?.parent != null)
            {
                targetEntity = item.parent.entityOwner;
                if (targetEntity != null)
                {
                    targetEntityName = targetEntity.ShortPrefabName;
                }
            }

            if (targetEntity is BaseOven oven)
            {
                if (!_previousAmounts.TryGetValue(oven.net.ID, out var previousAmounts))
                {
                    previousAmounts = new Dictionary<int, Dictionary<int, int>>();
                    _previousAmounts[oven.net.ID] = previousAmounts;
                }

                if (item != null)
                {
                    if (!previousAmounts.TryGetValue(item.info.itemid, out var previousAmountDict))
                    {
                        previousAmountDict = new Dictionary<int, int>();
                        previousAmounts[item.info.itemid] = previousAmountDict;
                    }

                    if (previousAmountDict.ContainsKey(targetSlot))
                    {
                        previousAmountDict[targetSlot] += item.amount;
                    }
                    else
                    {
                        previousAmountDict[targetSlot] = item.amount;
                    }
                }
            }

            return null;
        }
        void OnOvenCooked(BaseOven oven, Item item, BaseEntity slot)
        {
            if (smeltingData.DisableBtn)
            {
                string ovenKey = GetOvenKey(oven);
                int multiplier = 1;
                if (smeltingData.OutputMultiplier.TryGetValue(ovenKey, out float amountMultiplier))
                {
                    multiplier = (int)amountMultiplier;
                }
                if (!_previousAmounts.TryGetValue(oven.net.ID, out var previousAmounts))
                {

                    previousAmounts = new Dictionary<int, Dictionary<int, int>>();
                    _previousAmounts[oven.net.ID] = previousAmounts;
                }
                var currentItems = new HashSet<int>(oven.inventory.itemList.Select(slotItem => slotItem.info.itemid));
                foreach (var itemId in previousAmounts.Keys.ToList())
                {
                    if (!currentItems.Contains(itemId))
                    {
                        previousAmounts.Remove(itemId);
                    }
                }
                foreach (var slotItem in oven.inventory.itemList)
                {
                    if (IsMaterialOutput(oven, slotItem))
                    {
                        if (!previousAmounts.TryGetValue(slotItem.info.itemid, out var previousAmountDict))
                        {
                            previousAmountDict = new Dictionary<int, int>();
                            previousAmounts[slotItem.info.itemid] = previousAmountDict;
                        }
                        previousAmountDict.TryGetValue(slotItem.position, out var previousAmount);
                        if (slotItem.amount < previousAmount)
                        {
                            previousAmountDict[slotItem.position] = slotItem.amount;
                        }
                        else if (slotItem.amount != previousAmount)
                        {
                            int newAmount = slotItem.amount - previousAmount;
                            if (slotItem.info.shortname != "charcoal")
                            {
                                slotItem.amount = previousAmount + newAmount * multiplier;
                            }
                            previousAmountDict[slotItem.position] = slotItem.amount;
                        }
                    }
                }
            }
        }
        object OnOvenCook(BaseOven oven, Item item)
        {
            if (smeltingData.DisableBtn)
            {
                string ovenKey = GetOvenKey(oven);
                if (!updatedOvens.ContainsKey(oven.ToString()))
                {
                    if (!originalSmeltSpeed.ContainsKey(ovenKey))
                    {
                        originalSmeltSpeed[ovenKey] = oven.smeltSpeed;
                    }
                    UpdateSmelting();
                    updatedOvens[oven.ToString()] = true;
                }
            }
            return null;
        }
        object OnFuelConsume(BaseOven oven, Item fuel, ItemModBurnable burnable)
        {
            if (smeltingData.DisableBtn)
            {
                string ovenKey = GetOvenKey(oven);
                if (smeltingData.CharcoalMultiplier.TryGetValue(ovenKey, out float fuelUsageMultiplier))
                {
                    if (!originalByproductAmounts.ContainsKey(ovenKey))
                    {
                        originalByproductAmounts[ovenKey] = burnable.byproductAmount;
                    }
                    burnable.byproductAmount = (int)fuelUsageMultiplier;
                }
                if (smeltingData.FuelUsageNames.TryGetValue(ovenKey, out fuelUsageMultiplier))
                {
                    fuel.UseItem((int)(fuelUsageMultiplier - 1));
                }
            }
            return null;
        }
        private void OnMixingTableToggle(MixingTable table, BasePlayer player)
        {
            if (smeltingData.DisableBtn)
            {
                if (smeltingData.Smelting.TryGetValue("mixingtable", out float speedMultiplier))
                {

                    if (table.IsOn())
                    {
                        return;
                    }
                    NextTick(() =>
                    {
                        table.RemainingMixTime /= speedMultiplier;
                        table.TotalMixTime /= speedMultiplier;
                        table.SendNetworkUpdateImmediate();
                        if (table.RemainingMixTime < 1.0f)
                        {
                            table.CancelInvoke(table.TickMix);
                            table.Invoke(table.TickMix, table.RemainingMixTime);
                        }
                    });
                }
                else
                {
                    Console.WriteLine($"Invalid speed multiplier: {speedMultiplier}");
                }
            }
        }
        public bool IsMaterialOutput(BaseOven oven, Item item)
        {
            if (smeltingData.DisableBtn)
            {
                if (_materialOutputCache == null)
                    BuildMaterialOutputCache();
            }
            return _materialOutputCache.TryGetValue(oven.cookingTemperature, out var itemDefinitionSet) && itemDefinitionSet.Contains(item.info);
        }
        private void BuildMaterialOutputCache()
        {
            if (smeltingData.DisableBtn)
            {
                _materialOutputCache = new Dictionary<float, HashSet<ItemDefinition>>();
                foreach (var oven in GameManager.server.preProcessed.prefabList.Values.Select(x => x.GetComponent<BaseOven>()).Where(x => x != null))
                {
                    var itemDefinitionSet = new HashSet<ItemDefinition>();
                    _materialOutputCache[oven.cookingTemperature] = itemDefinitionSet;
                    foreach (var itemDefinition in ItemManager.itemList)
                    {
                        var itemModCookable = itemDefinition.ItemModCookable;
                        if (itemModCookable != null && itemModCookable.CanBeCookedByAtTemperature(oven.cookingTemperature))
                            itemDefinitionSet.Add(itemModCookable.becomeOnCooked);
                    }
                }
            }
        }
        private string GetOvenKey(BaseOven oven)
        {
            string ovenKey = oven.ShortPrefabName;
            switch (ovenKey)
            {
                case "legacy_furnace":
                    return "furnace";
                case "small_refinery_static":
                    return "refinery_small_deployed";
                case "bbq.static":
                    return "bbq.deployed";
                default:
                    return ovenKey;
            }
        }
        private void ApplyOvenChanges()
        {
            foreach (var entity in BaseNetworkable.serverEntities)
            {
                var oven = entity as BaseOven;
                if (oven != null && oven.IsOn())
                {
                    oven.StopCooking();
                    oven.StartCooking();
                }
            }
        }
        void OnEntitySpawned(BaseCombatEntity entity)
        {
            #region Smelting
            if (smeltingData.DisableBtn)
            {
                var oven = entity as BaseOven;
                if (oven != null)
                {
                    ovens.Add(oven);
                }
            }
            #endregion
            #region Rewards
            if (rewardsData.DisableBtn)
            {
                if (entity.ShortPrefabName == "patrolhelicopter")
                {
                    playerDamageHeli.Clear();
                    totalHealthHeli = 0;
                }
            }
            #endregion
        }
        #endregion
        #region Rewards
        private void CreateRewardsPage(ref CuiElementContainer container, BasePlayer player)
        {

            CreatePage(ref container, "RewardsPage", "0 0 0 0", currentPage == 3, player);
            rewardPage = "RewardsPage";
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "RewardsTitle", "RewardsName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "RewardsTitle", "0.8 0.25 0.17 1", "REWARDS", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (rewardsData.DisableBtn)
            {
                CUIClass.CreateButton(ref container, "RewardsPage", "NextButton", "0.8 0.25 0.17 0", "►", 30, "0.96 0.03", "0.99 0.12", "set.pagetwo", "", "0.76 0.43 0.2 1", 0);
                for (int i = 0; i < rNames.Count; i++)
                {
                    RewardsData.RewardValues defaultValues = rewardsData.Rewards.ContainsKey(rNames[i]) ? rewardsData.Rewards[rNames[i]] : new RewardsData.RewardValues { Economics = 0f, Scrap = 0 };
                    float defaultValueEconomics = defaultValues.Economics;
                    int defaultValueScrap = defaultValues.Scrap;

                    defaultValueEconomics = Clamp(defaultValueEconomics, -99999, 999999);

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];
                    CUIClass.CreatePanel(ref container, "RewardsPage", $"RNamePanel_{i}", "0 0 0 1", $"{xPos - 0.02} {yPos}", $"{xPos + 0.13} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"RNamePanel_{i}", "Rewards", "1 1 1 1", rDisplayNames[i], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    if (rewardsData.Settings.TryGetValue("Use_Economics", out string useEconomics) && useEconomics == "True")
                    {
                        CUIClass.CreatePanel(ref container, "RewardsPage", $"XPanel_{i}", "0.12 0.51 0.67 1", $"{xPos + 0.135} {yPos}", $"{xPos + 0.17} {yPos + 0.07}");
                        CUIClass.CreateInputField(ref container, $"XPanel_{i}", "Rewards", "1 1 1 1", "0 0.1", "1 0.9", $"set.eco {rNames[i]}", defaultValueEconomics.ToString(), 6);
                    }
                    if (rewardsData.Settings.TryGetValue("Use_Scrap", out string useScrap) && useScrap == "True")
                    {
                        CUIClass.CreatePanel(ref container, "RewardsPage", $"XPanelScrap_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.175} {yPos}", $"{xPos + 0.21} {yPos + 0.07}");
                        CUIClass.CreateInputField(ref container, $"XPanelScrap_{i}", "ScrapRewards", "1 1 1 1", "0 0.1", "1 0.9", $"set.scrap {rNames[i]}", defaultValueScrap.ToString(), 6);
                    }
                }
                int displayIndex = 0;
                for (int i = 0; i < settings.Count; i++)
                {
                    if (settings[i] == "Use_ServerRewards") continue;

                    string defaultValue = rewardsData.Settings.ContainsKey(settings[i]) ? rewardsData.Settings[settings[i]] : "";
                    float yPos = settingsPositions[displayIndex];
                    CUIClass.CreatePanel(ref container, "RewardsPage", $"SNamePanel_{i}", "0 0 0 1", $"{settingsXPos - 0.02} {yPos}", $"{settingsXPos + 0.17} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"SNamePanel_{i}", "Settings", "0.48 0.67 0.12 1", sDisplayNames[displayIndex], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    string initialButtonState = defaultValue == "False" ? "False" : "True";
                    CUIClass.CreateButton(ref container, "RewardsPage", initialButtonState + "#" + i, initialButtonState == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", initialButtonState, 18, $"{settingsXPos + 0.175} {yPos}", $"{settingsXPos + 0.21} {yPos + 0.07}", $"set.{(initialButtonState == "False" ? "false" : "true")} " + i, "", "1 1 1 1", 0);

                    displayIndex++;
                }
                for (int i = 0; i < mNames.Count; i++)
                {
                    float defaultValue = rewardsData.Modifiersettings.ContainsKey(mNames[i]) ? rewardsData.Modifiersettings[mNames[i]] : 1.0f;

                    defaultValue = Clamp(defaultValue, (float)0.1, 1000);


                    float yPos = ModifierPositions[i];
                    CUIClass.CreatePanel(ref container, "RewardsPage", $"MNamePanel_{i}", "0 0 0 1", $"{settingsXPos - 0.02} {yPos}", $"{settingsXPos + 0.17} {yPos + 0.07}");
                    CUIClass.CreatePanel(ref container, "RewardsPage", $"Modifiersettings_{i}", "0.12 0.51 0.67 1", $"{settingsXPos + 0.175} {yPos}", $"{settingsXPos + 0.21} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"MNamePanel_{i}", "Modifiersettings", "0.48 0.67 0.12 1", mDisplayNames[i], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    CUIClass.CreateInputField(ref container, $"Modifiersettings_{i}", "Modifiersettings", "1 1 1 1", "0 0.1", "1 0.9", $"set.mod {mNames[i]}", defaultValue.ToString(), 4);
                }
            }
        }
        private string rewardPage;
        private void CreateServerRewardsPage(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "ServerRewardsPage", "0 0 0 0", currentPage == 3, player);
            rewardPage = "ServerRewardsPage";
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "ServerRewardsTitle", "ServerRewardsName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "ServerRewardsTitle", "0.8 0.25 0.17 1", "SERVER REWARDS", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }
            if (rewardsData.DisableBtn)
            {
                CUIClass.CreateButton(ref container, "ServerRewardsPage", "BackButton", "0.8 0.25 0.17 0", "◄", 30, "0.96 0.03", "0.99 0.12", "set.pageone", "", "0.76 0.43 0.2 1", 0);
                for (int i = 0; i < rNames.Count; i++)
                {
                    RewardsData.RewardValues defaultValues = rewardsData.Rewards.ContainsKey(rNames[i]) ? rewardsData.Rewards[rNames[i]] : new RewardsData.RewardValues { ServerRewards = 0f };
                    float defaultValueServer = defaultValues.ServerRewards;

                    defaultValueServer = Clamp(defaultValueServer, -99999, 999999);

                    int column = i / columnPositions.Count;
                    int position = i % columnPositions.Count;
                    float xPos = columnXPositions[column];
                    float yPos = columnPositions[position];
                    CUIClass.CreatePanel(ref container, "ServerRewardsPage", $"SrNamePanel_{i}", "0 0 0 1", $"{xPos - 0.02} {yPos}", $"{xPos + 0.13} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"SrNamePanel_{i}", "ServerRewards", "1 1 1 1", rDisplayNames[i], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");

                    if (rewardsData.Settings.TryGetValue("Use_ServerRewards", out string useServerRewards) && useServerRewards == "True")
                    {
                        CUIClass.CreatePanel(ref container, "ServerRewardsPage", $"SrXPanel_{i}", "0.8 0.25 0.17 1", $"{xPos + 0.135} {yPos}", $"{xPos + 0.17} {yPos + 0.07}");
                        CUIClass.CreateInputField(ref container, $"SrXPanel_{i}", "ServerRewards", "1 1 1 1", "0 0.1", "1 0.9", $"set.server {rNames[i]}", defaultValueServer.ToString(), 6);
                    }
                }
                int displayIndex = 0;
                for (int i = 0; i < settings.Count; i++)
                {
                    if (settings[i] != "Use_ServerRewards") continue;
                    string defaultValue = rewardsData.Settings.ContainsKey(settings[i]) ? rewardsData.Settings[settings[i]] : "";
                    float yPos = ModifierPositions[displayIndex];
                    CUIClass.CreatePanel(ref container, "ServerRewardsPage", $"SrNamePanel_{i}", "0 0 0 1", $"{settingsXPos - 0.02} {yPos}", $"{settingsXPos + 0.17} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"SrNamePanel_{i}", "ServerSettings", "0.48 0.67 0.12 1", sSrDisplayNames[displayIndex], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    string initialButtonState = defaultValue == "False" ? "False" : "True";
                    CUIClass.CreateButton(ref container, "ServerRewardsPage", initialButtonState + "#" + i, initialButtonState == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", initialButtonState, 18, $"{settingsXPos + 0.175} {yPos}", $"{settingsXPos + 0.21} {yPos + 0.07}", $"set.{(initialButtonState == "False" ? "false" : "true")} " + i, "", "1 1 1 1", 0);
                    displayIndex++;
                }
            }
        }
        private void RefreshGUI(BasePlayer player)
        {
            DestroyCurrentPage(player);
            CreateCurrentPage(player);
        }
        private bool CanAcceptItem(PlayerInventory inventory, Item item)
        {
            return inventory.containerMain.capacity > inventory.containerMain.itemList.Count;
        }
        private void DropItemInFrontOfPlayer(BasePlayer player, Item item)
        {
            if (rewardsData.DisableBtn)
            {
                var positionInFrontOfPlayer = player.eyes.position + (player.eyes.rotation * Vector3.forward);
                item.Drop(positionInFrontOfPlayer, Vector3.up);
            }
        }
        private void RewardPlayer(BasePlayer player, string type, string gathered)
        {
            if (rewardsData.DisableBtn)
            {
                if (!rewardsData.Rewards.TryGetValue(gathered, out RewardsData.RewardValues rewardValues))
                {
                    return;
                }
                #region Economics
                if (Economics && rewardValues.Economics != 0 || rewardValues.Economics == 0f)
                {
                    if (rewardsData.Settings.TryGetValue("Use_Economics", out var useEconomicsString) && useEconomicsString == "True")
                    {
                        if (Economics != null)
                        {
                            float amount = rewardValues.Economics;
                            if (amount != 0 && amount > 0)
                            {
                                Economics.Call("Deposit", player.UserIDString, (double)amount);
                                if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                {
                                    var message = string.Format(GetMessage("addEco", player.UserIDString));
                                    PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>${amount}</color>{message}</color>");
                                }
                            }
                            else if (amount != 0 && amount < 0)
                            {
                                double currentBalance = (double)Economics.Call("Balance", player.UserIDString);
                                if (currentBalance < Math.Abs(amount))
                                {
                                    Economics.Call("Withdraw", player.UserIDString, currentBalance);
                                    if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                    {
                                        var message = string.Format(GetMessage("removeEco", player.UserIDString));
                                        PrintToChat(player, $"<color=#cd412bff><color=#FFCA51>${currentBalance}</color>{message}</color>");
                                    }
                                }
                                else
                                {
                                    Economics.Call("Withdraw", player.UserIDString, (double)-amount);
                                    if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                    {
                                        var message = string.Format(GetMessage("removeEco", player.UserIDString));
                                        PrintToChat(player, $"<color=#cd412bff>${Math.Abs(amount)}{message}</color>");
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion

                #region ServerRewards
                if (ServerRewards && rewardValues.ServerRewards != 0 || rewardValues.ServerRewards == 0f)
                {
                    if (rewardsData.Settings.TryGetValue("Use_ServerRewards", out var useServerRewardsString) && useServerRewardsString == "True")
                    {
                        if (ServerRewards != null)
                        {
                            float amount = rewardValues.ServerRewards;
                            if (amount != 0 && amount > 0)
                            {
                                ServerRewards?.Call("AddPoints", player.UserIDString, (int)amount);
                                if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                {
                                    var message = string.Format(GetMessage("addSR", player.UserIDString));
                                    PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>{amount}</color>{message}</color>");
                                }
                            }
                            else if (amount != 0 && amount < 0)
                            {
                                int currentBalance = (int)ServerRewards?.Call("CheckPoints", player.UserIDString);
                                if (currentBalance < Math.Abs(amount))
                                {
                                    ServerRewards?.Call("TakePoints", player.UserIDString, currentBalance);
                                    if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                    {
                                        var message = string.Format(GetMessage("removeSR", player.UserIDString));
                                        PrintToChat(player, $"<color=#cd412b>{currentBalance}{message}</color>");
                                    }
                                }
                                else
                                {
                                    ServerRewards?.Call("TakePoints", player.UserIDString, (int)-amount);
                                    if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                    {
                                        var message = string.Format(GetMessage("removeSR", player.UserIDString));
                                        PrintToChat(player, $"<color=#cd412b>{Math.Abs(amount)}{message}</color>");
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion

                #region Scrap
                if (rewardsData.Settings.TryGetValue("Use_Scrap", out var useScrap) && useScrap == "True" && rewardValues.Scrap != 0 || rewardValues.Scrap == 0)
                {
                    if (rewardsData.Settings.TryGetValue("Use_Scrap", out var useScrapString) && useScrapString == "True")
                    {
                        int scrapRewardAmount = rewardValues.Scrap;

                        if (scrapRewardAmount != 0 && scrapRewardAmount > 0)
                        {
                            var item = ItemManager.CreateByName("scrap", scrapRewardAmount);

                            if (CanAcceptItem(player.inventory, item))
                            {
                                player.inventory.GiveItem(item);

                                if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                {
                                    var message = string.Format(GetMessage("addScrap", player.UserIDString));
                                    PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>{scrapRewardAmount}</color>{message}</color>");
                                }
                            }
                            else
                            {
                                DropItemInFrontOfPlayer(player, item);

                                if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                                {
                                    var message = string.Format(GetMessage("dropScrap", player.UserIDString));
                                    PrintToChat(player, $"<color=#ff2300ff><b> <color=#FFCA51>{scrapRewardAmount}</color>{message}</b>.</color>");
                                }
                            }
                        }
                    }
                }
                #endregion

            }
        }
        void OnPlayerRespawned(BasePlayer player, string type, string gathered)
        {
            if (rewardsData.DisableBtn)
            {
                ulong userID = player.userID.Get();
                if (deadPlayerSteamIds.Contains(userID))
                {
                    RewardPlayer(player, "death", "Death");
                    deadPlayerSteamIds.Remove(userID);
                }
                if (suicidePlayerSteamIds.Contains(userID))
                {
                    RewardPlayer(player, "death", "Suicide");
                    suicidePlayerSteamIds.Remove(userID);
                }
            }
        }
        private void RewardAmount(BasePlayer player, string type, float ecoamount, float scrapamount, float serveramount, string gathered)
        {
            if (!rewardsData.DisableBtn || !rewardsData.Rewards.TryGetValue(gathered, out RewardsData.RewardValues rewardValues))
            {
                return;
            }

            #region Handle Economics reward
            if (rewardValues.Economics != 0)
            {
                if (rewardsData.Settings.TryGetValue("Use_Economics", out var useEconomicsString) && useEconomicsString == "True" && Economics != null)
                {
                    ecoamount = rewardValues.Economics;

                    if (ecoamount > 0)
                    {
                        Economics.Call("Deposit", player.UserIDString, (double)ecoamount);
                        if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                        {
                            var message = string.Format(GetMessage("addEco", player.UserIDString));
                            PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>${ecoamount}</color>{message}</color>");
                        }
                    }
                    else if (ecoamount < 0)
                    {
                        double currentBalance = (double)Economics.Call("Balance", player.UserIDString);
                        if (currentBalance < Math.Abs(ecoamount))
                        {
                            Economics.Call("Withdraw", player.UserIDString, currentBalance);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("removeEco", player.UserIDString));
                                PrintToChat(player, $"<color=#cd412bff>${currentBalance}{message}</color>");
                            }
                        }
                        else
                        {
                            Economics.Call("Withdraw", player.UserIDString, (double)-ecoamount);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("removeEco", player.UserIDString));
                                PrintToChat(player, $"<color=#cd412bff>${Math.Abs(ecoamount)}{message}</color>");
                            }
                        }
                    }
                }
            }
            #endregion
            #region Handle ServerRewards
            if (rewardValues.ServerRewards != 0)
            {
                if (rewardsData.Settings.TryGetValue("Use_ServerRewards", out var useServerRewardsString) && useServerRewardsString == "True" && ServerRewards != null)
                {
                    serveramount = rewardValues.ServerRewards;

                    if (serveramount > 0)
                    {
                        ServerRewards.Call("AddPoints", player.UserIDString, (int)serveramount);
                        if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                        {
                            var message = string.Format(GetMessage("addSR", player.UserIDString));
                            PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>{serveramount}</color>{message}</color>");
                        }
                    }
                    else if (serveramount < 0)
                    {
                        double currentBalance = (int)ServerRewards.Call("CheckPoints", player.UserIDString);
                        if (currentBalance < Math.Abs(serveramount))
                        {
                            ServerRewards.Call("TakePoints", player.UserIDString, currentBalance);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("removeSR", player.UserIDString));
                                PrintToChat(player, $"<color=#cd412b>{currentBalance}{message}</color>");
                            }
                        }
                        else
                        {
                            ServerRewards.Call("TakePoints", player.UserIDString, (int)-serveramount);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("removeSR", player.UserIDString));
                                PrintToChat(player, $"<color=#cd412b>{Math.Abs(serveramount)}{message}</color>");
                            }
                        }
                    }
                }
            }
            #endregion
            #region Handle Scrap reward
            if (rewardValues.Scrap != 0)
            {
                if (rewardsData.Settings.TryGetValue("Use_Scrap", out var useScrapString) && useScrapString == "True")
                {
                    scrapamount = (int)rewardValues.Scrap;

                    if (scrapamount > 0)
                    {
                        var item = ItemManager.CreateByName("scrap", (int)scrapamount);
                        if (CanAcceptItem(player.inventory, item))
                        {
                            player.inventory.GiveItem(item);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("addScrap", player.UserIDString));
                                PrintToChat(player, $"<color=#7aab1fff><color=#FFCA51>{scrapamount}</color>{message}</color>");
                            }
                        }
                        else
                        {
                            DropItemInFrontOfPlayer(player, item);
                            if (rewardsData.Settings.TryGetValue("Show_Messages_On_Award", out string showMessagesOnAward) && showMessagesOnAward == "True")
                            {
                                var message = string.Format(GetMessage("dropScrap", player.UserIDString));
                                PrintToChat(player, $"<color=#ff2300ff><b> <color=#FFCA51>{scrapamount}</color>{message}</b>.</color>");
                            }
                        }
                    }
                }
            }
            #endregion
        }
        void HandlePlayerDeath(BaseCombatEntity entity, BasePlayer initiator, HitInfo info)
        {
            if (!rewardsData.DisableBtn || entity == null || initiator == null)
            {
                return;
            }

            if (!(entity is BasePlayer player))
            {
                return;
            }

            ulong userID = player.userID.Get();
            ulong initiatorUserID = initiator.userID.Get();
            string causeOfDeath = null;

            float deathEconomicsAmount = 0f;
            if (rewardsData.Rewards.TryGetValue("Death", out RewardsData.RewardValues deathRewardValues))
            {
                deathEconomicsAmount = deathRewardValues.Economics;
                if (deathEconomicsAmount != 0)
                {
                    causeOfDeath = "Death";
                }
            }

            float suicideEconomicsAmount = 0f;
            if (initiator == player && rewardsData.Rewards.TryGetValue("Suicide", out RewardsData.RewardValues suicideRewardValues))
            {
                suicideEconomicsAmount = suicideRewardValues.Economics;
                if (suicideEconomicsAmount != 0)
                {
                    causeOfDeath = "Suicide";
                }
            }

            if (initiator.Team != null && initiator.Team.members.Contains(userID))
            {
                float teamMemberEconomicsAmount = 0f;
                if (rewardsData.Rewards.TryGetValue("Team_Member", out RewardsData.RewardValues teamMemberRewardValues))
                {
                    teamMemberEconomicsAmount = teamMemberRewardValues.Economics;
                    if (teamMemberEconomicsAmount != 0)
                    {
                        RewardPlayer(initiator, "death", "Team_Member");
                    }
                }
                return;
            }

            if (!initiator.ShortPrefabName.Contains("npc"))
            {
                if (info.HitEntity != null && info.HitEntity.ShortPrefabName.Contains("scarecrow"))
                {
                    causeOfDeath = "scarecrow";
                }
                else
                {
                    causeOfDeath = "Player";
                }
                RewardPlayer(initiator, "death", causeOfDeath);

                if (initiator.Team == null || (initiator.Team != null && !initiator.Team.members.Contains(userID)))
                {
                    causeOfDeath = "Death";
                    deadPlayerSteamIds.Add(userID);
                }
            }

            if (causeOfDeath != null)
            {
                if (causeOfDeath == "Death")
                {
                    deadPlayerSteamIds.Add(userID);
                }
                else if (causeOfDeath == "Suicide")
                {
                    suicidePlayerSteamIds.Add(userID);
                }
            }
        }
        void HandleEntityDeath(BaseCombatEntity entity, BasePlayer initiator, HitInfo info)
        {
            if (!rewardsData.DisableBtn || entity == null || initiator == null)
            {
                return;
            }

            string causeOfDeath = null;
            float amount = 0f;

            if (info != null && info.HitEntity != null)
            {
                if (info.HitEntity.ShortPrefabName.Contains("cargo"))
                {
                    if (rewardsData.Rewards.TryGetValue("CargoScientist", out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        causeOfDeath = "CargoScientist";
                    }
                }
                else if (OtherScientist.Any(scientist => info.HitEntity.ShortPrefabName.Contains(scientist)))
                {
                    if (rewardsData.Rewards.TryGetValue("otherScientist", out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        causeOfDeath = "otherScientist";
                    }
                }
                else if (info.HitEntity.ShortPrefabName.Contains("wolf2"))
                {
                    if (rewardsData.Rewards.TryGetValue("wolf", out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        causeOfDeath = "wolf";
                    }
                }
                else if (entity is NPCPlayer npcPlayer)
                {
                    causeOfDeath = npcPlayer?.displayName ?? info.HitEntity.ShortPrefabName;

                    if (!rewardsData.Rewards.TryGetValue(causeOfDeath, out RewardsData.RewardValues rewardValues))
                    {
                        if (rewardsData.Rewards.TryGetValue(entity.ShortPrefabName, out rewardValues))
                        {
                            amount = rewardValues.Economics;
                            causeOfDeath = info.HitEntity.ShortPrefabName;
                        }
                    }
                    else
                    {
                        amount = rewardValues.Economics;
                    }
                }
                else
                {
                    if (rewardsData.Rewards.TryGetValue(entity.ShortPrefabName, out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        causeOfDeath = entity.ShortPrefabName;
                    }
                }
            }

            if (rewardsData.Settings.TryGetValue("Divided_Loot", out string divideLoot) && divideLoot == "False")
            {
                if ((entity.ShortPrefabName == "bradleyapc" || entity.ShortPrefabName == "patrolhelicopter") && info.InitiatorPlayer != null)
                {
                    if (rewardsData.Rewards.TryGetValue(entity.ShortPrefabName, out RewardsData.RewardValues rewardValues))
                    {
                        amount = rewardValues.Economics;
                        causeOfDeath = entity.ShortPrefabName;
                    }
                }
            }

            if (causeOfDeath != null)
            {

                RewardPlayer(initiator, "kill", causeOfDeath);
            }
        }
        void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
        {
            if (rewardsData.DisableBtn)
            {
                if (entity.ShortPrefabName == "patrolhelicopter" && info.InitiatorPlayer != null)
                {
                    if (info.InitiatorPlayer != null)
                    {
                        lastPlayer = info.InitiatorPlayer;
                    }
                    if (!playerDamageHeli.ContainsKey(info.InitiatorPlayer.userID))
                    {
                        playerDamageHeli.Add(info.InitiatorPlayer.userID, 0);
                    }
                    float damage = info.damageTypes.Total();
                    playerDamageHeli[info.InitiatorPlayer.userID] += damage;
                    if (totalHealthHeli == 0)
                    {
                        totalHealthHeli = entity.startHealth;
                    }
                }
                if (entity.ShortPrefabName == "bradleyapc" && info.InitiatorPlayer != null)
                {


                    if (!playerDamageBradley.ContainsKey(info.InitiatorPlayer.userID))
                    {
                        playerDamageBradley.Add(info.InitiatorPlayer.userID, 0);
                    }

                    float damage = info.damageTypes.Total();
                    playerDamageBradley[info.InitiatorPlayer.userID] += damage;
                    if (totalHealthBradley == 0)
                    {
                        totalHealthBradley = entity.startHealth;
                    }
                }
            }
            if (settingsData.DisableBtn)
            {

                float currentTime = TOD_Sky.Instance.Cycle.Hour;
                float PvEOnTime = float.Parse(settingsData.Settings["PvEOn"]);
                float PvEOffTime = float.Parse(settingsData.Settings["PvEOff"]);
                string mode = settingsData.Settings.ContainsKey("PvEMode") ? settingsData.Settings["PvEMode"] : "False";
                if (mode == "True" || (settingsData.Settings["autoPvEMode"] == "True" && currentTime >= PvEOnTime && currentTime <= PvEOffTime) || (PvEOnTime > PvEOffTime && (currentTime >= PvEOnTime || currentTime <= PvEOffTime)))
                {
                    if (info.InitiatorPlayer != null && entity.ToPlayer() != null)
                    {
                        if (!info.InitiatorPlayer.IsNpc && !entity.ToPlayer().IsNpc && !entity.ShortPrefabName.Contains("zombie") && !info.InitiatorPlayer.ShortPrefabName.Contains("zombie"))
                        {
                            CancelDamage(info);
                        }
                    }
                }
                if (entity is BuildingBlock || entity.PrefabName.Contains("door") || entity.PrefabName.Contains("window") || entity.PrefabName.Contains("deployable") || entity.PrefabName.Contains("misc"))
                {

                    float protOnTime = float.Parse(settingsData.Settings["ProtOn"]);
                    float protOffTime = float.Parse(settingsData.Settings["ProtOff"]);

                    bool isRaidProtectionActive = settingsData.Settings["raidProt"] == "True" || (settingsData.Settings["autoRaidProt"] == "True" && ((protOnTime <= protOffTime && currentTime >= protOnTime && currentTime <= protOffTime) || (protOnTime > protOffTime && (currentTime >= protOnTime || currentTime <= protOffTime))));

                    if (isRaidProtectionActive)
                    {
                        BasePlayer attacker = info.InitiatorPlayer;
                        HandleDamageProtection(entity, attacker, info);
                    }

                }
            }
        }
        void OnEntityDestroy(BaseCombatEntity entity)
        {
            if (!rewardsData.DisableBtn || entity == null)
            {
                return;
            }

            if (entity.ShortPrefabName == "bradleyapc")
            {
                if (rewardsData.Rewards.TryGetValue(entity.ShortPrefabName, out RewardsData.RewardValues rewardValues))
                {
                    float TotalEcoReward = rewardValues.Economics;
                    int TotalScrapReward = rewardValues.Scrap;
                    float TotalServerReward = rewardValues.ServerRewards;

                    float totalDamage = playerDamageBradley.Values.Sum();

                    foreach (var entry in playerDamageBradley)
                    {
                        ulong playerID = entry.Key;
                        float damage = entry.Value;
                        float percentage = (damage / totalDamage) * 100;
                        percentage = (float)Math.Round(percentage, 0);

                        float ecoReward = (percentage / 100) * TotalEcoReward;
                        int scrapReward = (int)((percentage / 100) * TotalScrapReward);
                        float serverReward = (percentage / 100) * TotalServerReward;

                        BasePlayer player = BasePlayer.FindByID(playerID);

                        if (player != null && rewardsData.Settings.TryGetValue("Divided_Loot", out string divideLoot) && divideLoot == "True")
                        {
                            RewardAmount(player, "kill", ecoReward, scrapReward, serverReward, entity.ShortPrefabName);

                            var message = string.Format(GetMessage("damageMessage", player.UserIDString), player.displayName, percentage, entity.ShortPrefabName);
                            PrintToChat(player, $"<color=#cd412bff>{message}</color>");
                        }
                    }

                    playerDamageBradley.Clear();
                    totalHealthBradley = 0;
                }
            }
        }
        #endregion
        #region Settings
        private void CreateSettingsPage(ref CuiElementContainer container, BasePlayer player)
        {
            CreatePage(ref container, "SettingsPage", "0 0 0 0", currentPage == 4, player);
            if (plugins.Exists("ImageLibrary"))
            {
                CreateImageFromLibrary(ref container, "TotalControlGUI", "SettingsTitle", "SettingsName", "0.02 0.83", "0.26 0.93");
            }
            else
            {
                CUIClass.CreateText(ref container, "TotalControlGUI", "SettingsTitle", "0.8 0.25 0.17 1", "SETTINGS", 32, "0.02 0.83", "0.26 0.93", TextAnchor.MiddleCenter, "PermanentMarker.ttf", 0f, 0f, "0 0 0 1", "1 1");
            }

            if (settingsData.DisableBtn)
            {
                voteDayValue = settingsData.Settings["VoteDayCmd"];
                for (int i = 0; i < settingsNames.Count; i++)
                {
                    if (settingsNames[i] == "")
                    {
                        continue;
                    }
                    string defaultValue = settingsData.Settings.ContainsKey(settingsNames[i]) ? settingsData.Settings[settingsNames[i]] : "1";

                    float defaultValueFloat;
                    if (float.TryParse(defaultValue, out defaultValueFloat))
                    {
                        if (new List<string> { "SOD", "EOD" }.Contains(settingsNames[i]))
                        {
                            defaultValueFloat = Clamp(defaultValueFloat, 0, 24);
                        }
                        if (settingsNames[i] == "VotePass")
                        {
                            defaultValueFloat = Clamp(defaultValueFloat, 0, 100);
                        }
                        else
                        {
                            defaultValueFloat = Clamp(defaultValueFloat, -1, 900);
                        }
                        defaultValue = defaultValueFloat.ToString();
                    }
                    int column = i / SettingscolumnPositions.Count;
                    int position = i % SettingscolumnPositions.Count;
                    float xPos = SettingscolumnXPositions[column];
                    float yPos = SettingscolumnPositions[position];
                    CUIClass.CreatePanel(ref container, "SettingsPage", $"SetNamePanel_{i}", "0 0 0 1", $"{xPos - 0.01} {yPos}", $"{xPos + 0.21} {yPos + 0.07}");
                    CUIClass.CreateText(ref container, $"SetNamePanel_{i}", "Settings", "1 1 1 1", settingsDisplayNames[i], 20, "0.05 0.1", "0.95 0.9", TextAnchor.UpperLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                    if (settingsNames[i] == "VoteDayCmd")
                    {
                        CUIClass.CreatePanel(ref container, "SettingsPage", $"VoteDay_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.215} {yPos}", $"{xPos + 0.3} {yPos + 0.07}");
                        CUIClass.CreateInputField(ref container, $"VoteDay_{i}", "VoteSettings", "1 1 1 1", "0.05 0.1", "0.95 0.9", $"set.settings {settingsNames[i]}", voteDayValue, 10, 0, TextAnchor.MiddleLeft);
                    }
                    else
                    {
                        CUIClass.CreatePanel(ref container, "SettingsPage", $"SetPanel_{i}", "0.76 0.43 0.2 1", $"{xPos + 0.215} {yPos}", $"{xPos + 0.25} {yPos + 0.07}");
                        CUIClass.CreateInputField(ref container, $"SetPanel_{i}", "Settings", "1 1 1 1", "0.05 0.1", "0.95 0.9", $"set.settings {settingsNames[i]}", defaultValue, 5);

                    }


                }
                for (int i = 0; i < buttons.Count; i++)
                {
                    string defaultValue = settingsData.Settings.ContainsKey(buttons[i]) ? settingsData.Settings[buttons[i]] : "";
                    int column = i / ButtonscolumnPositions.Count;
                    int position = i % ButtonscolumnPositions.Count;
                    float xPos = SettingscolumnXPositions[column];
                    float yPos = ButtonscolumnPositions[position];
                    string initialButtonState = defaultValue == "False" ? "False" : "True";
                    CUIClass.CreatePanel(ref container, "SettingsPage", $"ButtonNamePanel_{i}", "0 0 0 1", $"{xPos - 0.01} {yPos}", $"{xPos + 0.21} {yPos + 0.07}");
                    CUIClass.CreateButton(ref container, "SettingsPage", initialButtonState + "#" + i, initialButtonState == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", initialButtonState, 18, $"{xPos + 0.215} {yPos}", $"{xPos + 0.25} {yPos + 0.07}", $"set.{(initialButtonState == "False" ? "false" : "true")} " + i, "", "1 1 1 1", 0);
                    CUIClass.CreateText(ref container, $"ButtonNamePanel_{i}", "Buttons", "0.48 0.67 0.12 1", buttonsDisplayNames[i], 20, "0.05 0.1", "0.95 0.9", TextAnchor.MiddleLeft, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 1", "1 1");
                }
            }
        }
        void UpdateButton(BasePlayer player, int buttonIndex, string value)
        {
            var container = new CuiElementContainer();
            string newValue;
            string displayValue;
            float yPos = 1.0f - (buttonIndex * 0.08f);
            CuiHelper.DestroyUi(player, value == "True" ? "False#" + buttonIndex : "True#" + buttonIndex);
            newValue = value == "True" ? "False" : "True";
            displayValue = newValue;

            if (currentPage == 3)
            {
                if (rewardsData.DisableBtn)
                {
                    if (settings[buttonIndex] == "Use_Economics" && newValue == "True" && !plugins.Exists("Economics"))
                    {
                        newValue = "False";
                        SendMessageToAdmins("Economics plugin is not loaded. Download it from the uMod website to use Economics options.");
                    }
                    if (settings[buttonIndex] == "Use_ServerRewards" && newValue == "True" && !plugins.Exists("ServerRewards"))
                    {
                        newValue = "False";
                        SendMessageToAdmins("ServerRewards plugin is not loaded. Download it from the uMod website to use ServerRewards options.");
                    }
                    if (rewardPage == "RewardsPage")
                    {
                        CUIClass.CreateButton(ref container, "RewardsPage", $"{newValue}#{buttonIndex}", newValue == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", newValue, 18, $"{settingsXPos + 0.215} {yPos}", $"{settingsXPos + 0.25} {yPos + 0.07}", $"set.{newValue.ToLower()} {buttonIndex}", "", "1 1 1 1", 0);
                    }
                    else
                    {
                        CUIClass.CreateButton(ref container, "ServerRewardsPage", $"{newValue}#{buttonIndex}", newValue == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", newValue, 18, $"{settingsXPos + 0.215} {yPos}", $"{settingsXPos + 0.25} {yPos + 0.07}", $"set.{newValue.ToLower()} {buttonIndex}", "", "1 1 1 1", 0);
                    }
                    rewardsData.Settings[settings[buttonIndex]] = newValue;
                    CuiHelper.AddUi(player, container);
                }
            }

            if (currentPage == 4)
            {
                if (settingsData.DisableBtn)
                {
                    #region skip night
                    if (buttons[buttonIndex] == "vote" && newValue == "True")
                    {
                        settingsData.Settings["skip"] = "False";
                        settingsData.Settings["freeze"] = "False";
                        if (freezeTimeOn == true)
                        {
                            UnfreezeTime();
                        }
                    }
                    else if (buttons[buttonIndex] == "skip" && newValue == "True")
                    {
                        settingsData.Settings["vote"] = "False";
                        settingsData.Settings["freeze"] = "False";
                        if (freezeTimeOn == true)
                        {
                            UnfreezeTime();
                        }
                    }
                    else if (buttons[buttonIndex] == "freeze" && newValue == "True")
                    {
                        settingsData.Settings["vote"] = "False";
                        settingsData.Settings["skip"] = "False";
                        if (freezeTimeOn == false)
                        {
                            FreezeTime();
                        }
                    }
                    else if (buttons[buttonIndex] == "freeze" && newValue == "False")
                    {
                        UnfreezeTime();
                    }
                    #endregion

                    #region PvE/PvP mode
                    if (buttons[buttonIndex] == "PvEMode" && newValue == "True")
                    {
                        OnIcon(player, "Mode");
                        settingsData.Settings["autoPvEMode"] = "False";
                    }
                    else if (buttons[buttonIndex] == "autoPvEMode" && newValue == "True")
                    {
                        settingsData.Settings["PvEMode"] = "False";
                    }
                    if (buttons[buttonIndex] == "ModeIcon" && newValue == "True" && settingsData.Settings["PvEMode"] == "True")
                    {
                        var ModeBtn = new CuiElementContainer();
                        CuiHelper.DestroyUi(player, "IconMode");
                        OnIcon(player, "Mode");
                        CuiHelper.AddUi(player, ModeBtn);
                    }
                    else if (buttons[buttonIndex] == "ModeIcon" && newValue == "False")
                    {
                        CuiHelper.DestroyUi(player, "IconMode");
                    }
                    if (buttons[buttonIndex] == "ModeIcon" && newValue == "True" && settingsData.Settings["PvEMode"] == "False" && settingsData.Settings["autoPvEMode"] == "False")
                    {
                        OffIcon(player, "Mode");
                    }
                    if (buttons[buttonIndex] == "PvEMode" && newValue == "False" && settingsData.Settings["ModeIcon"] == "True")
                    {
                        OffIcon(player, "Mode");
                    }
                    if (buttons[buttonIndex] == "autoPvEMode" && newValue == "False" && settingsData.Settings["ModeIcon"] == "True")
                    {
                        OffIcon(player, "Mode");
                    }
                    #endregion

                    #region raid protection
                    if (buttons[buttonIndex] == "raidProt" && newValue == "True")
                    {
                        settingsData.Settings["autoRaidProt"] = "False";
                        OnIcon(player, "Raid");
                    }
                    else if (buttons[buttonIndex] == "autoRaidProt" && newValue == "True")
                    {
                        settingsData.Settings["raidProt"] = "False";
                    }


                    if (buttons[buttonIndex] == "RaidIcon" && newValue == "True")
                    {
                        if (settingsData.Settings["raidProt"] == "True")
                        {
                            OnIcon(player, "Raid");
                        }

                    }
                    else if (buttons[buttonIndex] == "RaidIcon" && newValue == "False")
                    {
                        CuiHelper.DestroyUi(player, "IconRaid");
                    }

                    if (buttons[buttonIndex] == "raidProt" && newValue == "False" && settingsData.Settings["RaidIcon"] == "True")
                    {
                        OffIcon(player, "Raid");
                    }
                    if (buttons[buttonIndex] == "autoRaidProt" && newValue == "False" && settingsData.Settings["RaidIcon"] == "True")
                    {
                        OffIcon(player, "Raid");
                    }
                    #endregion
                    CUIClass.CreateButton(ref container, "SettingsPage", $"{newValue}#{buttonIndex}", newValue == "True" ? "0.48 0.67 0.12 1" : "0.8 0.25 0.17 1", displayValue, 18, $"{settingsXPos + 0.215} {yPos}", $"{settingsXPos + 0.25} {yPos + 0.07}", $"set.{newValue.ToLower()} {buttonIndex}", "", "1 1 1 1", 0);
                    settingsData.Settings[buttons[buttonIndex]] = newValue;
                    CuiHelper.AddUi(player, container);
                }
            }
            RefreshGUI(player);
            foreach (BasePlayer players in BasePlayer.activePlayerList)
            {
                UpdateUI(players);
            }
        }
        void OnIcon(BasePlayer player, string button)
        {
            if (settingsData.DisableBtn)
            {
                var ModeBtn = new CuiElementContainer();
                if (settingsData.Settings["ModeIcon"] == "True" && button == "Mode")
                {
                    CuiHelper.DestroyUi(player, "IconMode");
                    CUIClass.CreatePanel(ref ModeBtn, "Hud", "IconMode", "1 1 1 0.02", "1 0", "1 0", "-350 16", "-210 42", false, 0, 0);
                    CUIClass.CreateText(ref ModeBtn, "IconMode", "PvE", "0.48 0.67 0.12 1", "<b>PvE MODE ENABLED</b>", 14, "0 0", "1 1", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 0", "0 0");

                }
                if (settingsData.Settings["RaidIcon"] == "True" && button == "Raid")
                {
                    if (settingsData.Settings["ModeIcon"] == "True")
                    {
                        raidOffsetMin = "-350 44";
                        raidOffsetMax = "-210 77";
                    }
                    else if (settingsData.Settings["ModeIcon"] == "False")
                    {
                        raidOffsetMin = "-350 16";
                        raidOffsetMax = "-210 42";
                    }

                    CuiHelper.DestroyUi(player, "IconRaid");

                    CUIClass.CreatePanel(ref ModeBtn, "Hud", "IconRaid", "1 1 1 0.02", "1 0", "1 0", raidOffsetMin, raidOffsetMax, false, 0, 0);
                    CUIClass.CreateText(ref ModeBtn, "IconRaid", "raidProtOff", "0.48 0.67 0.12 1", "<b>RAID PROTECTION ON</b>", 14, "0 0", "1 1", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 0", "0 0");
                }
                CuiHelper.AddUi(player, ModeBtn);
            }
        }
        void OffIcon(BasePlayer player, string button)
        {
            if (settingsData.DisableBtn)
            {
                var ModeBtn = new CuiElementContainer();
                if (button == "Mode")
                {
                    CuiHelper.DestroyUi(player, "IconMode");

                    CUIClass.CreatePanel(ref ModeBtn, "Hud", "IconMode", "1 1 1 0.02", "1 0", "1 0", "-350 16", "-210 42", false, 0, 0);
                    CUIClass.CreateText(ref ModeBtn, "IconMode", "PvP", "0.8 0.25 0.17 1", "<b>PvP MODE ENABLED</b>", 14, "0 0", "1 1", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 0", "0 0");


                }
                if (button == "Raid")
                {

                    if (settingsData.Settings["ModeIcon"] == "True")
                    {
                        raidOffsetMin = "-350 44";
                        raidOffsetMax = "-210 77";
                    }
                    else if (settingsData.Settings["ModeIcon"] == "False")
                    {
                        raidOffsetMin = "-350 16";
                        raidOffsetMax = "-210 42";
                    }
                    CuiHelper.DestroyUi(player, "IconRaid");


                    CUIClass.CreatePanel(ref ModeBtn, "Hud", "IconRaid", "1 1 1 0.02", "1 0", "1 0", raidOffsetMin, raidOffsetMax, false, 0, 0);
                    CUIClass.CreateText(ref ModeBtn, "IconRaid", "raidProtOff", "0.8 0.25 0.17 1", "<b>RAID PROTECTION OFF</b>", 14, "0 0", "1 1", TextAnchor.MiddleCenter, "RobotoCondensed-Regular.ttf", 0f, 0f, "0 0 0 0", "0 0");


                }

                CuiHelper.AddUi(player, ModeBtn);

            }
        }
        void CheckTime()
        {
            if (settingsData.DisableBtn)
            {
                if (settingsData.Settings["autoPvEMode"] == "True" && settingsData.Settings["ModeIcon"] == "True")
                {
                    if (TOD_Sky.Instance?.Cycle != null && settingsData?.Settings != null)
                    {
                        float currentTime = TOD_Sky.Instance.Cycle.Hour;
                        if (settingsData.Settings.ContainsKey("PvEOn") && settingsData.Settings.ContainsKey("PvEOff"))
                        {
                            float PvEOn = float.Parse(settingsData.Settings["PvEOn"]);
                            float PvEOff = float.Parse(settingsData.Settings["PvEOff"]);
                            foreach (BasePlayer player in BasePlayer.activePlayerList)
                            {
                                var ModeBtn = new CuiElementContainer();
                                bool isPvEActive = (PvEOn <= PvEOff && currentTime >= PvEOn && currentTime < PvEOff) || (PvEOn > PvEOff && (currentTime >= PvEOn || currentTime < PvEOff));

                                if (isPvEActive)
                                {
                                    OnIcon(player, "Mode");
                                }
                                else
                                {
                                    OffIcon(player, "Mode");
                                }

                                CuiHelper.AddUi(player, ModeBtn);
                            }
                        }
                    }
                }
                if (settingsData.Settings["autoRaidProt"] == "True" && settingsData.Settings["RaidIcon"] == "True")
                {
                    if (TOD_Sky.Instance?.Cycle != null && settingsData?.Settings != null)
                    {
                        float currentTime = TOD_Sky.Instance.Cycle.Hour;
                        if (settingsData.Settings.ContainsKey("ProtOn") && settingsData.Settings.ContainsKey("ProtOff"))
                        {
                            float ProtOn = float.Parse(settingsData.Settings["ProtOn"]);
                            float ProtOff = float.Parse(settingsData.Settings["ProtOff"]);

                            foreach (BasePlayer player in BasePlayer.activePlayerList)
                            {
                                var ModeBtn = new CuiElementContainer();
                                bool isProtActive = (ProtOn <= ProtOff && currentTime >= ProtOn && currentTime < ProtOff) || (ProtOn > ProtOff && (currentTime >= ProtOn || currentTime < ProtOff));

                                if (isProtActive)
                                {
                                    OnIcon(player, "Raid");
                                }
                                else
                                {
                                    OffIcon(player, "Raid");
                                }

                                CuiHelper.AddUi(player, ModeBtn);
                            }
                        }
                    }
                }
                if (settingsData.Settings["ModeIcon"] == "False" || settingsData.Settings["RaidIcon"] == "False")
                {
                    foreach (BasePlayer player in BasePlayer.activePlayerList)
                    {
                        if (settingsData.Settings["ModeIcon"] == "False")
                        {
                            CuiHelper.DestroyUi(player, "IconMode");
                        }
                        if (settingsData.Settings["RaidIcon"] == "False")
                        {
                            CuiHelper.DestroyUi(player, "IconRaid");
                        }
                    }
                }
                if (settingsData.Settings["skip"] == "True")
                {
                    if (TOD_Sky.Instance?.Cycle != null && settingsData?.Settings != null)
                    {
                        float currentTime = TOD_Sky.Instance.Cycle.Hour;
                        if (settingsData.Settings.ContainsKey("EOD"))
                        {

                            float EOD = float.Parse(settingsData.Settings["EOD"]);
                            if (currentTime >= EOD - 0.01f && currentTime <= EOD + 0.01f)
                            {
                                SetTimeToDawn();
                            }
                        }
                    }
                    else
                    {
                        SetTimeToDawn();
                    }
                }
                if (settingsData.Settings["vote"] == "True")
                {
                    if (TOD_Sky.Instance?.Cycle != null && settingsData?.Settings != null)
                    {
                        float currentTime = TOD_Sky.Instance.Cycle.Hour;
                        if (settingsData.Settings.ContainsKey("EOD"))
                        {
                            float SkipDays = float.Parse(settingsData.Settings["MaxSkipDays"]);
                            float EOD = float.Parse(settingsData.Settings["EOD"]);
                            if (currentTime >= EOD - 0.01f && currentTime <= EOD + 0.01f)
                            {

                                if ((skippedDays < SkipDays && !skipDayCooldown) || SkipDays == -1)
                                {
                                    if (_timerVote == null && !votingInProgress)
                                    {
                                        float IntervalSeconds = float.Parse(settingsData.Settings["MessageDelay"]);
                                        votingInProgress = true;

                                        foreach (BasePlayer player in BasePlayer.activePlayerList)
                                        {
                                            var message = string.Format(GetMessage("voteMessage", player.UserIDString));
                                            PrintToChat(player, $"<size=18><color=#cd412b>/{voteDayValue}</color>{message}</size>");
                                        }

                                        printCount++;
                                        _timerVote = timer.Every(IntervalSeconds, () =>
                                        {
                                            float votePercentage = (float)votes.Count / BasePlayer.activePlayerList.Count;
                                            float votePassRate = float.Parse(settingsData.Settings["VotePass"]) / 100;
                                            if (printCount < 5 && votePercentage < votePassRate)
                                            {
                                                foreach (BasePlayer player in BasePlayer.activePlayerList)
                                                {
                                                    var message = string.Format(GetMessage("voteMessage", player.UserIDString));
                                                    PrintToChat(player, $"<size=18><color=#cd412b>/{voteDayValue}</color>{message}</size>");
                                                }
                                                printCount++;
                                            }
                                            else
                                            {
                                                if (votePercentage >= votePassRate)
                                                {
                                                    SetTimeToDawn();
                                                    skippedDays++;
                                                }
                                                else
                                                {
                                                    foreach (BasePlayer player in BasePlayer.activePlayerList)
                                                    {
                                                        var message = string.Format(GetMessage("voteMessageFail", player.UserIDString));
                                                        PrintToChat(player, $"<size=18>{message}</size>");
                                                    }
                                                }
                                                votes.Clear();
                                                _timerVote.Destroy();
                                                _timerVote = null;
                                                printCount = 0;
                                                votingInProgress = false;
                                            }
                                        });
                                    }
                                }
                                else
                                {
                                    if (skippedDays >= SkipDays)
                                    {
                                        if (!resetCooldown)
                                        {
                                            skipDayCooldown = true;
                                            timer.Once(5f, () =>
                                            {
                                                skipDayCooldown = false;
                                                skippedDays = 0;
                                                resetCooldown = false;
                                            });
                                            resetCooldown = true;
                                        }
                                    }
                                    else
                                    {
                                        skipDayCooldown = false;
                                    }
                                    return;
                                }
                                return;
                            }
                            return;
                        }
                    }
                }
            }
        }
        void FreezeTime()
        {
            freezeTimeOn = true;
            if (TOD_Sky.Instance?.Cycle != null && settingsData?.Settings != null)
            {
                float currentTime = TOD_Sky.Instance.Cycle.Hour;
                if (settingsData.Settings.ContainsKey("SOD"))
                {
                    float SOD = float.Parse(settingsData.Settings["SOD"]);
                    ConsoleSystem.Run(ConsoleSystem.Option.Server.Quiet(), "env.progresstime false");
                    ConsoleSystem.Run(ConsoleSystem.Option.Server.Quiet(), "env.time", SOD.ToString());
                }
            }
        }
        void UnfreezeTime()
        {
            freezeTimeOn = false;
            ConsoleSystem.Run(ConsoleSystem.Option.Server.Quiet(), "env.progresstime true");

        }
        void SetTimeToDawn()
        {
            if (settingsData.DisableBtn)
            {
                foreach (BasePlayer player in BasePlayer.activePlayerList)
                {
                    var message = string.Format(GetMessage("voteMessagePass", player.UserIDString));
                    PrintToChat(player, $"<size=18><color=#d9a807>{message}</size></color>");
                }
                float SOD = float.Parse(settingsData.Settings["SOD"]);
                ConsoleSystem.Run(ConsoleSystem.Option.Server.Quiet(), "env.time", SOD.ToString());
                skippedDays++;
            }
        }
        private void CancelDamage(HitInfo hit)
        {
            if (settingsData.DisableBtn)
            {
                hit.damageTypes = new DamageTypeList();
                hit.HitMaterial = 0;
                hit.PointStart = Vector3.zero;
                hit.HitEntity = null;
                hit.DidHit = false;
                hit.DoHitEffects = false;
                hit.damageTypes.ScaleAll(0);
            }
        }
        private void HandleDamageProtection(BaseCombatEntity entity, BasePlayer attacker, HitInfo info)
        {
            if (attacker != null)
            {
                BuildingPrivlidge privilege = entity.GetBuildingPrivilege();
                if (privilege != null && privilege.OwnerID != 0 && !privilege.IsAuthed(attacker))
                {
                    CancelDamage(info);
                }
            }
            else if (attacker == null && info.damageTypes.Has(DamageType.Bullet) || info.damageTypes.Has(DamageType.Explosion) || info.damageTypes.Has(DamageType.Heat))
            {
                CancelDamage(info);
            }

        }
        private void SetVoteCommand()
        {
            if (tempValue != voteDayValue)
            {
                voteDayValue = settingsData.Settings["VoteDayCmd"];
                tempValue = $"{voteDayValue}";
                cmd.AddChatCommand(voteDayValue, this, nameof(VoteDayCommand));
            }
        }
        #endregion
        #region Chat Commands
        [ChatCommand("tc")]
        private void SetCommand(BasePlayer player, string command, string[] args)
        {

            if (player.IPlayer.HasPermission(openGui))
            {
                gatherData = Interface.Oxide.DataFileSystem.ReadObject<GatherData>("TotalControl/Gather");
                stackSizeData = Interface.Oxide.DataFileSystem.ReadObject<StackSizeData>("TotalControl/StackSize");
                smeltingData = Interface.Oxide.DataFileSystem.ReadObject<SmeltingData>("TotalControl/Smelting");
                rewardsData = Interface.Oxide.DataFileSystem.ReadObject<RewardsData>("TotalControl/Rewards");
                settingsData = Interface.Oxide.DataFileSystem.ReadObject<SettingsData>("TotalControl/Settings");

                MainGui(player);
                UpdateDisableButton(player);
            }
            else
            {
                var message = string.Format(GetMessage("noPerm", player.UserIDString));
                PrintToChat(player, $"{message}");
            }
        }
        void VoteDayCommand(BasePlayer player, string command, string[] args)
        {
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            if (votingInProgress)
            {
                if (votes.ContainsKey(player.UserIDString))
                {
                    var message = string.Format(GetMessage("voted", player.UserIDString));
                    PrintToChat(player, $"{message}");
                }
                else
                {
                    votes[player.UserIDString] = true;
                    var message = string.Format(GetMessage("voteCounted", player.UserIDString));
                    PrintToChat(player, $"<size=16>{message}</size>");
                    float votePercentage = (float)votes.Count / BasePlayer.activePlayerList.Count;
                    float votePassRate = float.Parse(settingsData.Settings["VotePass"]) / 100;
                    if (votePercentage > votePassRate)
                    {
                        SetTimeToDawn();
                        votes.Clear();
                        _timerVote.Destroy();
                        _timerVote = null;
                        printCount = 0;
                        votingInProgress = false;
                    }
                }
            }
            else
            {
                var message = string.Format(GetMessage("noVoting", player.UserIDString));
                PrintToChat(player, $"{message}");
            }
        }

        #endregion
        #region Console Commands
        [ConsoleCommand("set.close")]
        private void CloseCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            CuiHelper.DestroyUi(player, "TotalControlGUI");
            gatherRatesPage = 0;
            stackSizePage = 0;
            rewardsPage = 0;
            currentPage = 0;

            rewardsData = Interface.Oxide.DataFileSystem.ReadObject<RewardsData>("TotalControl/Rewards");
            settingsData = Interface.Oxide.DataFileSystem.ReadObject<SettingsData>("TotalControl/Settings");
            UpdateUI(player);
        }
        [ConsoleCommand("set.apply")]
        private void ApplyCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            foreach (var kvp in tempSettings)
            {
                settingsData.Settings[kvp.Key] = kvp.Value;
            }
            foreach (var itemId in originalStackSizes.Keys)
            {
                ItemDefinition itemDef = ItemManager.FindItemDefinition(itemId);
                if (itemDef != null)
                {
                    itemDef.stackable = originalStackSizes[itemId];
                }
            }

            originalStackSizes.Clear();
            tempSettings.Clear();

            SendMessageToAdmins("New settings have been saved!");
            Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Gather", gatherData);
            ClearStackSizeCache();
            Interface.Oxide.DataFileSystem.WriteObject("TotalControl/StackSize", stackSizeData);
            Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Smelting", smeltingData);
            UpdateSmelting();
            Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Rewards", rewardsData);
            Interface.Oxide.DataFileSystem.WriteObject("TotalControl/Settings", settingsData);

            RefreshGUI(player);

            switch (currentPage)
            {
                case 0:
                    SubscribeUnsubscribe(gatherData.DisableBtn, "GatherRate");
                    break;

                case 1:
                    SubscribeUnsubscribe(stackSizeData.DisableBtn, "StackSize");
                    var stackNames = stackSizePage == 0 ? StackNames : StackNames2;
                    foreach (var itemName in stackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                    break;

                case 2:
                    SubscribeUnsubscribe(smeltingData.DisableBtn, "Smelting");
                    break;

                case 3:
                    SubscribeUnsubscribe(rewardsData.DisableBtn, "Rewards");
                    break;

                case 4:
                    SubscribeUnsubscribe(settingsData.DisableBtn, "Settings");
                    if (!settingsData.DisableBtn)
                    {
                        foreach (var activePlayer in BasePlayer.activePlayerList)
                        {
                            CuiHelper.DestroyUi(activePlayer, "IconMode");
                            CuiHelper.DestroyUi(activePlayer, "IconRaid");
                        }
                    }

                    if (settingsData.Settings["freeze"] == "True")
                    {
                        FreezeTime();
                    }
                    SetVoteCommand();
                    break;
            }

            ApplyOvenChanges();
        }
        [ConsoleCommand("set.applyx2")]
        private void ApplyX2Command(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (currentPage == 0)
            {
                foreach (var key in gatherData.GatherRates.Keys.ToList())
                {
                    float currentValue = gatherData.GatherRates.ContainsKey(key) ? gatherData.GatherRates[key] : 1.0f;
                    currentValue *= 2;
                    currentValue = Clamp(currentValue, 0.1f, 1000f);
                    gatherData.GatherRates[key] = currentValue;

                }
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                foreach (var key in stackSizeData.StackSize.Keys.ToList())
                {
                    if (ExcludedCategory.Contains(key))
                        continue;
                    float currentValue = stackSizeData.StackSize.ContainsKey(key) ? stackSizeData.StackSize[key].StackSize : 1.0f;
                    currentValue *= 2;
                    currentValue = Clamp(currentValue, 1.0f, 1000f);
                    stackSizeData.StackSize[key].StackSize = currentValue;
                }
            }
            RefreshGUI(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                {
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
                if (stackSizePage == 1)
                {
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
            }
        }
        [ConsoleCommand("set.applyx3")]
        private void ApplyX3Command(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (currentPage == 0)
            {
                foreach (var key in gatherData.GatherRates.Keys.ToList())
                {
                    float currentValue = gatherData.GatherRates.ContainsKey(key) ? gatherData.GatherRates[key] : 1.0f;
                    currentValue *= 3;
                    currentValue = Clamp(currentValue, 0.1f, 1000f);
                    gatherData.GatherRates[key] = currentValue;
                }
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                foreach (var key in stackSizeData.StackSize.Keys.ToList())
                {
                    if (ExcludedCategory.Contains(key))
                        continue;
                    float currentValue = stackSizeData.StackSize.ContainsKey(key) ? stackSizeData.StackSize[key].StackSize : 1.0f;
                    currentValue *= 3;
                    currentValue = Clamp(currentValue, 1.0f, 1000f);
                    stackSizeData.StackSize[key].StackSize = currentValue;
                }
            }
            RefreshGUI(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                {
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
                if (stackSizePage == 1)
                {
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
            }
        }
        [ConsoleCommand("set.applyx5")]
        private void ApplyX5Command(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (currentPage == 0)
            {
                foreach (var key in gatherData.GatherRates.Keys.ToList())
                {
                    float currentValue = gatherData.GatherRates.ContainsKey(key) ? gatherData.GatherRates[key] : 1.0f;
                    currentValue *= 5;
                    currentValue = Clamp(currentValue, 0.1f, 1000f);
                    gatherData.GatherRates[key] = currentValue;
                }
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                foreach (var key in stackSizeData.StackSize.Keys.ToList())
                {
                    if (ExcludedCategory.Contains(key))
                        continue;
                    float currentValue = stackSizeData.StackSize.ContainsKey(key) ? stackSizeData.StackSize[key].StackSize : 1.0f;
                    currentValue *= 5;
                    currentValue = Clamp(currentValue, 1.0f, 1000f);
                    stackSizeData.StackSize[key].StackSize = currentValue;
                }
            }
            RefreshGUI(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                {
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
                if (stackSizePage == 1)
                {
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
            }
        }
        [ConsoleCommand("set.applyx10")]
        private void ApplyX10Command(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (currentPage == 0)
            {
                foreach (var key in gatherData.GatherRates.Keys.ToList())
                {
                    float currentValue = gatherData.GatherRates.ContainsKey(key) ? gatherData.GatherRates[key] : 1.0f;
                    currentValue *= 10;
                    currentValue = Clamp(currentValue, 0.1f, 1000f);
                    gatherData.GatherRates[key] = currentValue;
                }
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                foreach (var key in stackSizeData.StackSize.Keys.ToList())
                {
                    if (ExcludedCategory.Contains(key))
                        continue;

                    float currentValue = stackSizeData.StackSize.ContainsKey(key) ? stackSizeData.StackSize[key].StackSize : 1.0f;
                    currentValue *= 10;
                    currentValue = Clamp(currentValue, 1.0f, 1000f);
                    stackSizeData.StackSize[key].StackSize = currentValue;
                }
            }
            RefreshGUI(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                {
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
                if (stackSizePage == 1)
                {
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
            }
        }
        [ConsoleCommand("set.applyreset")]
        private void ApplyResetCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (currentPage == 0)
            {
                foreach (var key in gatherData.GatherRates.Keys.ToList())
                {
                    float currentValue = gatherData.GatherRates.ContainsKey(key) ? gatherData.GatherRates[key] : 1.0f;
                    currentValue = 1;
                    currentValue = Clamp(currentValue, 0.1f, 1000f);
                    gatherData.GatherRates[key] = currentValue;
                }
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                foreach (var key in stackSizeData.StackSize.Keys.ToList())
                {

                    float currentValue = stackSizeData.StackSize.ContainsKey(key) ? stackSizeData.StackSize[key].StackSize : 1.0f;
                    currentValue = 1;
                    currentValue = Clamp(currentValue, 1.0f, 100000f);
                    stackSizeData.StackSize[key].StackSize = currentValue;
                    if (stackSizeData.StackSize[key].Mode != "x")
                    {
                        stackSizeData.StackSize[key].Mode = "x";
                    }
                }
            }
            RefreshGUI(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                {
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
                if (stackSizePage == 1)
                {
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
                }
            }
        }
        [ConsoleCommand("set.page.left")]
        void SetPageLeft(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) return;
            DestroyCurrentPage(player);
            currentPage = Math.Max(0, currentPage - 1);
            CreateCurrentPage(player);
            UpdateDisableButton(player);
            if (currentPage == 1)
            {
                foreach (var itemName in StackNames)
                {
                    UpdateModeButton(player, itemName);
                }
            }
        }
        [ConsoleCommand("set.page.right")]
        void SetPageRight(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) return;
            DestroyCurrentPage(player);
            currentPage = Math.Min(4, currentPage + 1);
            CreateCurrentPage(player);
            UpdateDisableButton(player);
            if (currentPage == 1)
            {
                foreach (var itemName in StackNames)
                {
                    UpdateModeButton(player, itemName);
                }
            }
        }
        [ConsoleCommand("set.true")]
        void SetTrue(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (player == null)
                return;

            int buttonIndex = int.Parse(arg.Args[0]);
            UpdateButton(player, buttonIndex, "True");
        }
        [ConsoleCommand("set.false")]
        void SetFalse(ConsoleSystem.Arg arg)
        {
            var player = arg.Connection.player as BasePlayer;
            if (player == null)
                return;

            int buttonIndex = int.Parse(arg.Args[0]);
            UpdateButton(player, buttonIndex, "False");
        }
        [ConsoleCommand("set.eco")]
        private void SetEcoCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value1;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value1))
            {
                value1 = Math.Max(-99999, Math.Min(999999, value1));
            }
            else
            {
                value1 = 1.0f;
            }
            if (rewardsData.Rewards.TryGetValue(name, out RewardsData.RewardValues rewardValues))
            {
                rewardValues.Economics = value1;
                rewardsData.Rewards[name] = rewardValues;
            }
        }
        [ConsoleCommand("set.scrap")]
        private void SetScrapCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            int value2;

            if (arg.Args.Length > 1 && int.TryParse(arg.Args[1], out value2))
            {
                value2 = Math.Max(0, Math.Min(999999, value2));
            }
            else
            {
                value2 = 1;
            }

            if (rewardsData.Rewards.TryGetValue(name, out RewardsData.RewardValues rewardValues))
            {
                rewardValues.Scrap = value2;
                rewardsData.Rewards[name] = rewardValues;
            }
        }
        [ConsoleCommand("set.server")]
        private void SetServerCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value3;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value3))
            {
                value3 = Math.Max(-99999, Math.Min(999999, value3));
            }
            else
            {
                value3 = 1.0f;
            }
            if (rewardsData.Rewards.TryGetValue(name, out RewardsData.RewardValues rewardValues))
            {
                rewardValues.ServerRewards = value3;
                rewardsData.Rewards[name] = rewardValues;
            }
        }
        [ConsoleCommand("set.mod")]
        private void SetModifierCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = (float)Math.Max(0.01, Math.Min(100, value));
            }

            else
            {
                value = 1.0f;
            }
            rewardsData.Modifiersettings[name] = value;
        }
        [ConsoleCommand("set.smelting")]
        private void SetSmeltingCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = Math.Max(1, Math.Min(100, value));
            }
            else
            {
                value = 1.0f;
            }
            smeltingData.Smelting[name] = value;
        }
        [ConsoleCommand("set.charcoal")]
        private void SetCharcoalCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;

            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = Math.Max(1, Math.Min(100, value));
            }
            else
            {
                value = 1.0f;
            }
            smeltingData.CharcoalMultiplier[name] = value;
        }
        [ConsoleCommand("set.fueluse")]
        private void SetFuelCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = Math.Max(1, Math.Min(100, value));
            }
            else
            {
                value = 1.0f;
            }
            smeltingData.FuelUsageNames[name] = value;
        }
        [ConsoleCommand("set.output")]
        private void SetOutputCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = Math.Max(1, Math.Min(100, value));
            }
            else
            {
                value = 1.0f;
            }
            smeltingData.OutputMultiplier[name] = value;
        }
        [ConsoleCommand("set.gather")]
        private void SetGetherCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;
            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                value = Math.Max(0.1f, Math.Min(999999f, value));
            }
            else
            {
                value = 1.0f;
            }
            gatherData.GatherRates[name] = value;
        }
        [ConsoleCommand("set.stacksize")]
        private void SetStackSizeCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }
            var name = arg.GetString(0);
            float value;

            if (arg.Args.Length > 1 && float.TryParse(arg.Args[1], out value))
            {
                if (Category.Contains(name))
                {
                    value = Math.Max(1.0f, Math.Min(100000f, value));
                }
                else
                {
                    value = Math.Max(0f, Math.Min(100000f, value));
                }
            }
            else
            {
                value = 1.0f;
            }
            stackSizeData.StackSize[name].StackSize = value;
        }

        [ConsoleCommand("set.pageone")]
        void ShowPage1Command(ConsoleSystem.Arg arg)
        {
            BasePlayer player = arg.Player();
            if (player == null) return;
            DestroyCurrentPage(player);

            if (currentPage == 0)
            {
                gatherRatesPage = 0;
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                stackSizePage = 0;
            }
            else if (currentPage == 3)
            {
                rewardsPage = 0;
            }

            CreateCurrentPage(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 0)
                    foreach (var itemName in StackNames)
                    {
                        UpdateModeButton(player, itemName);
                    }
            }

        }
        [ConsoleCommand("set.pagetwo")]
        void ShowPage2Command(ConsoleSystem.Arg arg)
        {
            BasePlayer player = arg.Player();
            if (player == null) return;
            DestroyCurrentPage(player);

            if (currentPage == 0)
            {
                gatherRatesPage = 1;
            }
            else if (currentPage == 1)
            {
                ClearStackSizeCache();
                stackSizePage = 1;
            }
            else if (currentPage == 3)
            {
                rewardsPage = 1;
            }

            CreateCurrentPage(player);
            if (currentPage == 1)
            {
                if (stackSizePage == 1)
                    foreach (var itemName in StackNames2)
                    {
                        UpdateModeButton(player, itemName);
                    }
            }
        }
        [ConsoleCommand("set.disable")]
        private void DisableCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) return;
            switch (currentPage)
            {
                case 0:
                    gatherData.DisableBtn = !gatherData.DisableBtn;
                    break;
                case 1:
                    stackSizeData.DisableBtn = !stackSizeData.DisableBtn;
                    break;
                case 2:
                    smeltingData.DisableBtn = !smeltingData.DisableBtn;
                    break;
                case 3:
                    rewardsData.DisableBtn = !rewardsData.DisableBtn;
                    break;
                case 4:
                    settingsData.DisableBtn = !settingsData.DisableBtn;
                    break;
            }
            RefreshUI(player);
            UpdateDisableButton(player);
            if (currentPage == 1)
            {
                foreach (var itemName in StackNames)
                {
                    UpdateModeButton(player, itemName);
                }
            }

        }
        [ConsoleCommand("set.mode")]
        private void SetModeCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) return;
            string itemName = arg.GetString(0);
            if (string.IsNullOrEmpty(itemName)) return;
            if (stackSizePage == 0)
            {
                if (!StackNames.Contains(itemName)) return;
            }
            else
            {
                if (!StackNames2.Contains(itemName)) return;
            }
            string currentMode = stackSizeData.StackSize[itemName].Mode;
            stackSizeData.StackSize[itemName].Mode = currentMode == "x" ? "=" : "x";
            UpdateModeButton(player, itemName);
        }
        [ConsoleCommand("set.settings")]
        private void SetSettingsCommand(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null)
            {
                Puts("Command must be called by a player.");
                return;
            }

            var name = arg.GetString(0);
            var value = arg.GetString(1);

            if (name == "VoteDayCmd")
            {
                if (!string.IsNullOrEmpty(value))
                {
                    tempSettings[name] = value;
                }
                else
                {
                    tempSettings[name] = "day";
                }
            }
            else
            {
                if (float.TryParse(value, out float floatValue))
                {
                    if (new List<string> { "SOD", "EOD", "PvEOn", "PvEOff", "ProtOn", "ProtOff" }.Contains(name))
                    {
                        floatValue = Math.Max(0, Math.Min(24, floatValue));
                    }

                    if (name == "VotePass")
                    {
                        floatValue = Math.Max(1, Math.Min(100, floatValue));
                    }
                    else
                    {
                        floatValue = Math.Max(-1, Math.Min(900, floatValue));
                    }

                    tempSettings[name] = floatValue.ToString();
                }
                else
                {
                    value = "1";
                    tempSettings[name] = value;
                }
            }
        }

        #endregion
        #region Lang
        void CreateLanguageFiles()
        {
            var en = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} dealt {1}% of the total damage to {2}.",
                ["addEco"] = " has been added to your <color=#E78802>Economics</color> balance.",
                ["removeEco"] = " has been deducted from your <color=#E78802>Economics</color> balance.",
                ["addSR"] = " has been added to your <color=#cd412b>ServerRewards</color> balance.",
                ["removeSR"] = " has been deducted from your ServerRewards balance.",
                ["addScrap"] = " <color=#A47966>scrap</color> has been added to your inventory.",
                ["dropScrap"] = " <color=#A47966>scrap</color> has been dropped in front of you because your inventory is full",
                ["voteMessage"] = " to skip night",
                ["voteMessageFail"] = "Voting has closed, there were not enough votes to skip night.",
                ["voteMessagePass"] = "Voting was successful.",
                ["noPerm"] = "You do not have permission to use Total Control.",
                ["voted"] = "You have already voted.",
                ["voteCounted"] = "Your vote has been counted.",
                ["noVoting"] = "Voting is not currently in progress.",

            };
            lang.RegisterMessages(en, this);

            //   French
            var fr = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} a infligé {1}% des dégâts totaux à {2}.",
                ["addEco"] = " a été ajouté à votre solde <color=#E78802>Économique</color>.",
                ["removeEco"] = " a été déduit de votre solde <color=#E78802>Économique</color>.",
                ["addSR"] = " a été ajouté à votre solde de <color=#cd412b>Récompenses du Serveur</color>.",
                ["removeSR"] = " a été déduit de votre solde de Récompenses du Serveur.",
                ["addScrap"] = " <color=#A47966>des débris</color> ont été ajoutés à votre inventaire.",
                ["dropScrap"] = " <color=#A47966>des débris</color> ont été déposés devant vous car votre inventaire est plein.",
                ["voteMessage"] = " pour passer la nuit.",
                ["voteMessageFail"] = "Le vote est terminé, il n'y avait pas assez de votes pour passer la nuit.",
                ["voteMessagePass"] = "Le vote a réussi.",
                ["noPerm"] = "Vous n'avez pas la permission d'utiliser le contrôle total.",
                ["voted"] = "Vous avez déjà voté.",
                ["voteCounted"] = "Votre vote a été comptabilisé.",
                ["noVoting"] = "Aucun vote n'est actuellement en cours.",
            };
            lang.RegisterMessages(fr, this, "fr");

            // German
            var de = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} hat {1}% des gesamten Schadens an {2} verursacht.",
                ["addEco"] = " wurde Ihrem <color=#E78802>Economics</color>-Kontostand hinzugefügt.",
                ["removeEco"] = " wurde von Ihrem <color=#E78802>Economics</color>-Kontostand abgezogen.",
                ["addSR"] = " wurde Ihrem <color=#cd412b>ServerRewards</color>-Kontostand hinzugefügt.",
                ["removeSR"] = " wurde von Ihrem ServerRewards-Kontostand abgezogen.",
                ["addScrap"] = " <color=#A47966>Schrott</color> wurde zu Ihrem Inventar hinzugefügt.",
                ["dropScrap"] = " <color=#A47966>Schrott</color> wurde vor Ihnen abgeworfen, weil Ihr Inventar voll ist.",
                ["voteMessage"] = " um die Nacht zu überspringen.",
                ["voteMessageFail"] = "Die Abstimmung ist geschlossen, es gab nicht genug Stimmen, um die Nacht zu überspringen.",
                ["voteMessagePass"] = "Die Abstimmung war erfolgreich.",
                ["noPerm"] = "Sie haben keine Berechtigung, Total Control zu verwenden.",
                ["voted"] = "Sie haben bereits abgestimmt.",
                ["voteCounted"] = "Ihre Stimme wurde gezählt.",
                ["noVoting"] = "Es findet derzeit keine Abstimmung statt.",
            };
            lang.RegisterMessages(de, this, "de");

            // Polish
            var pl = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} zadał {1}% całkowitych obrażeń {2}.",
                ["addEco"] = " został dodany do twojego salda <color=#E78802>Economics</color>.",
                ["removeEco"] = " został odjęty z twojego salda <color=#E78802>Economics</color>.",
                ["addSR"] = " został dodany do twojego salda <color=#cd412b>ServerRewards</color>.",
                ["removeSR"] = " został odjęty z twojego salda ServerRewards.",
                ["addScrap"] = " <color=#A47966>złom</color> został dodany do twojego ekwipunku.",
                ["dropScrap"] = " <color=#A47966>złom</color> został upuszczony przed tobą, ponieważ twój ekwipunek jest pełny.",
                ["voteMessage"] = " aby pominąć noc.",
                ["voteMessageFail"] = "Głosowanie zakończone, nie było wystarczającej liczby głosów, aby pominąć noc.",
                ["voteMessagePass"] = "Głosowanie zakończone sukcesem.",
                ["noPerm"] = "Nie masz uprawnień do korzystania z Total Control.",
                ["voted"] = "Już głosowałeś.",
                ["voteCounted"] = "Twój głos został policzony.",
                ["noVoting"] = "Obecnie nie trwa żadne głosowanie.",
            };
            lang.RegisterMessages(pl, this, "pl");

            // Russian
            var ru = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} нанес {1}% от общего урона по {2}.",
                ["addEco"] = " было добавлено на ваш баланс <color=#E78802>Economics</color>.",
                ["removeEco"] = " было вычтено из вашего баланса <color=#E78802>Economics</color>.",
                ["addSR"] = " было добавлено на ваш баланс <color=#cd412b>ServerRewards</color>.",
                ["removeSR"] = " было вычтено из вашего баланса ServerRewards.",
                ["addScrap"] = " <color=#A47966>лом</color> был добавлен в ваш инвентарь.",
                ["dropScrap"] = " <color=#A47966>лом</color> был сброшен перед вами, так как ваш инвентарь переполнен.",
                ["voteMessage"] = " чтобы пропустить ночь.",
                ["voteMessageFail"] = "Голосование завершено, недостаточно голосов, чтобы пропустить ночь.",
                ["voteMessagePass"] = "Голосование прошло успешно.",
                ["noPerm"] = "У вас нет прав на использование Total Control.",
                ["voted"] = "Вы уже проголосовали.",
                ["voteCounted"] = "Ваш голос засчитан.",
                ["noVoting"] = "Голосование в данный момент не проводится.",
            };
            lang.RegisterMessages(ru, this, "ru");

            // Spanish
            var es = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} infligió {1}% del daño total a {2}.",
                ["addEco"] = " se ha añadido a tu saldo de <color=#E78802>Economics</color>.",
                ["removeEco"] = " se ha deducido de tu saldo de <color=#E78802>Economics</color>.",
                ["addSR"] = " se ha añadido a tu saldo de <color=#cd412b>Recompensas del Servidor</color>.",
                ["removeSR"] = " se ha deducido de tu saldo de Recompensas del Servidor.",
                ["addScrap"] = " <color=#A47966>chatarra</color> se ha añadido a tu inventario.",
                ["dropScrap"] = " <color=#A47966>chatarra</color> se ha dejado frente a ti porque tu inventario está lleno.",
                ["voteMessage"] = " para saltarse la noche.",
                ["voteMessageFail"] = "La votación ha cerrado, no hubo suficientes votos para saltarse la noche.",
                ["voteMessagePass"] = "La votación fue exitosa.",
                ["noPerm"] = "No tienes permiso para usar Total Control.",
                ["voted"] = "Ya has votado.",
                ["voteCounted"] = "Tu voto ha sido contado.",
                ["noVoting"] = "No hay votación en curso.",
            };
            lang.RegisterMessages(es, this, "es-ES");

            // Chinese 
            var zh = new Dictionary<string, string>
            {
                ["damageMessage"] = "{0} 对 {2} 造成了 {1}% 的总伤害。",
                ["addEco"] = " 已添加到你的 <color=#E78802>经济</color> 余额中。",
                ["removeEco"] = " 已从你的 <color=#E78802>经济</color> 余额中扣除。",
                ["addSR"] = " 已添加到你的 <color=#cd412b>服务器奖励</color> 余额中。",
                ["removeSR"] = " 已从你的服务器奖励余额中扣除。",
                ["addScrap"] = " <color=#A47966>废料</color> 已添加到你的背包中。",
                ["dropScrap"] = " <color=#A47966>废料</color> 被丢在你面前，因为你的背包已满。",
                ["voteMessage"] = " 投票跳过夜晚。",
                ["voteMessageFail"] = "投票已结束，未有足够的票数跳过夜晚。",
                ["voteMessagePass"] = "投票成功。",
                ["noPerm"] = "你没有权限使用 Total Control。",
                ["voted"] = "你已经投过票了。",
                ["voteCounted"] = "你的投票已被计数。",
                ["noVoting"] = "当前没有正在进行的投票。",
            };
            lang.RegisterMessages(zh, this, "zh-CN");


        }
        #endregion
    }
}