FREE AdvancedRates : 1.0.5 1.0.5

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;

namespace Oxide.Plugins
{
    [Info("AdvancedRates", "Drop Dead", "1.0.5")]
    public class AdvancedRates : RustPlugin
    {
        #region Var [Определения]

        public List<ulong> LootedBoxes = new List<ulong>();

        #endregion

        #region Data [Работа с датой]

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject($"{Title}/LootedBoxes", LootedBoxes);
        }

        private void LoadData()
        {
            if (Interface.Oxide.DataFileSystem.ExistsDatafile($"{Title}/LootedBoxes"))
                LootedBoxes = Interface.Oxide.DataFileSystem.ReadObject<List<ulong>>($"{Title}/LootedBoxes");
        }

        private void WipeData()
        {
            LootedBoxes.Clear();
        }

        #endregion

        #region Config [Конфигурация плагина]

        private PluginConfig cfg;

        public class PluginConfig
        {
            [JsonProperty("Настройки рейтов фарма")]
            public GatherSettings gather = new GatherSettings();
            [JsonProperty("Настройки рейтов на бонус-добычу")]
            public BonusSettings bonus = new BonusSettings();
            [JsonProperty("Настройки рейтов подбора")]
            public CollectibleSettings collectible = new CollectibleSettings();
            [JsonProperty("Настройки рейтов компонтентов (ящики)")]
            public ComponentsSettings components = new ComponentsSettings();
            [JsonProperty("Настройки рейтов компонтентов (бочки)")]
            public BarrelsSettings barrels = new BarrelsSettings();
            [JsonProperty("Настройки рейтов карьеров")]
            public QuarrySettings quarry = new QuarrySettings();
            [JsonProperty("Настройки рейтов большого экскаватора")]
            public ExcavatorSettings excavator = new ExcavatorSettings();

            public class GatherSettings
            {
                [JsonProperty("Включить рейты на добычу (камни, деревья)?")]
                public bool enablegatherrate = true;
                [JsonProperty("Рейты на добычу по умолчанию")]
                public float gatherrate = 2f;
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
                [JsonProperty("Пермишны для увеличения рейтов на добычу", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> perms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class BonusSettings
            {
                [JsonProperty("Включить рейты на бонус-добычу (бонус дается в конце фарма)?")]
                public bool enablebonusrate = true;
                [JsonProperty("Рейты на бонус-добычу по умолчанию")]
                public float bonusrate = 2f;
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
                [JsonProperty("Пермишны для увеличения рейтов на бонус-добычу", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> perms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class CollectibleSettings
            {
                [JsonProperty("Включить рейты на подбор (collectible ресурсы)?")]
                public bool enablepickuprate = true;
                [JsonProperty("Рейты на подбор по умолчанию")]
                public float pickuprate = 2f;
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
                [JsonProperty("Пермишны для увеличения рейтов на подбор", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> perms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class ComponentsSettings
            {
                [JsonProperty("Включить рейты на компоненты?")]
                public bool enablecomponentsrate = true;
                [JsonProperty("Рейты на компоненты отдельно для каждого ящика", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> rate = new Dictionary<string, float>
                {
                    ["bradley_crate"] = 1f,
                    ["heli_crate"] = 1f,
                    ["crate_basic"] = 2f,
                    ["crate_elite"] = 2f,
                    ["crate_mine"] = 1f,
                    ["crate_normal"] = 2f,
                    ["crate_normal_2"] = 2f,
                    ["crate_normal_2_food"] = 1f,
                    ["crate_normal_2_medical"] = 2f,
                    ["crate_tools"] = 1f,
                    ["crate_underwater_advanced"] = 2f,
                    ["crate_underwater_basic"] = 1f,
                    ["codelockedhackablecrate"] = 3f,
                    ["codelockedhackablecrate_oilrig"] = 2f,
                };
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них в любом ящике)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" },
                };
                [JsonProperty("Пермишны для увеличения рейтов на компоненты", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> perms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class BarrelsSettings
            {
                [JsonProperty("Включить рейты на компоненты с бочкек?")]
                public bool enablebarrelsrate = true;
                [JsonProperty("Рейты на компоненты отдельно для каждой бочки", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> rate = new Dictionary<string, float>
                {
                    ["loot-barrel-1"] = 2f,
                    ["loot-barrel-2"] = 2f,
                    ["loot_barrel_1"] = 2f,
                    ["loot_barrel_2"] = 2f,
                    ["oil_barrel"] = 2f
                };
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них в любой бочке)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
                [JsonProperty("Пермишны для увеличения рейтов на бочки", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> perms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class QuarrySettings
            {
                [JsonProperty("Включить рейты на карьеры?")]
                public bool enablequarryrate = true;
                [JsonProperty("Рейты на карьеры игроков по умолчанию")]
                public float defaultplayerrate = 2f;
                [JsonProperty("Рейты на карьеры которые спавняться сами по карте по умолчанию")]
                public float defaultspawnrate = 1f;
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
                [JsonProperty("Пермишны для увеличения рейтов на карьеры игроков", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> playerperms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
                [JsonProperty("Пермишны для увеличения рейтов на карьеры которые спавняться сами по карте", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public Dictionary<string, float> spawnperms = new Dictionary<string, float>
                {
                    ["advancedrates.vip"] = 3f,
                    ["advancedrates.prem"] = 4f
                };
            }

            public class ExcavatorSettings
            {
                [JsonProperty("Включить рейты на большой экскаватор?")]
                public bool enableexcavatorrate = true;
                [JsonProperty("Рейты на большой экскаватор по умолчанию")]
                public float defaultrate = 2f;
                [JsonProperty("Список запрещенных предметов (рейты не будут распространятся на них)", ObjectCreationHandling = ObjectCreationHandling.Replace)]
                public List<string> blacklist = new List<string>()
                {
                    { "example" },
                    { "example" }
                };
            }
        }

        private void Init()
        {
            cfg = Config.ReadObject<PluginConfig>();
            Config.WriteObject(cfg);
        }

        protected override void LoadDefaultConfig()
        {
            Config.WriteObject(new PluginConfig(), true);
        }

        #endregion

        #region Methods [Методы]

        float GetPlayerRate(string playerid, string type, string crate)
        {
            float gatherrate = cfg.gather.gatherrate;
            float bonusrate = cfg.bonus.bonusrate;
            float collectiblerate = cfg.collectible.pickuprate;
            float cratesrate = 1f;
            float barrelsrate = 1f;
            float quarryrate_player = cfg.quarry.defaultplayerrate;
            float quarryrate_spawn = cfg.quarry.defaultspawnrate;

            if (type == "gather")
            {
                foreach (var num in cfg.gather.perms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > gatherrate) gatherrate = num.Value;
                    }
                }
                return gatherrate;
            }
            if (type == "bonus")
            {
                foreach (var num in cfg.bonus.perms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > bonusrate) bonusrate = num.Value;
                    }
                }
                return bonusrate;
            }
            if (type == "collectible")
            {
                foreach (var num in cfg.collectible.perms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > collectiblerate) collectiblerate = num.Value;
                    }
                }
                return collectiblerate;
            }
            if (type == "components")
            {
                cratesrate = cfg.components.rate[crate];
                foreach (var num in cfg.components.perms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > cratesrate) cratesrate = num.Value;
                    }
                }
                return cratesrate;
            }
            if (type == "barrel")
            {
                barrelsrate = cfg.barrels.rate[crate];
                foreach (var num in cfg.barrels.perms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > cratesrate) barrelsrate = num.Value;
                    }
                }
                return barrelsrate;
            }
            if (type == "quarry_player")
            {
                foreach (var num in cfg.quarry.playerperms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > quarryrate_player) quarryrate_player = num.Value;
                    }
                }
                return quarryrate_player;
            }
            if (type == "quarry_spawn")
            {
                foreach (var num in cfg.quarry.spawnperms)
                {
                    if (permission.UserHasPermission(playerid, num.Key))
                    {
                        if (num.Value > quarryrate_spawn) quarryrate_spawn = num.Value;
                    }
                }
                return quarryrate_spawn;
            }

            return 1f;
        }

        #endregion

        #region Hooks [Хуки]

        void OnNewSave()
        {
            WipeData();
        }

        void OnServerSave()
        {
            SaveData();
        }

        void Unload()
        {
            SaveData();
        }

        void OnServerInitialized()
        {
            LoadData();
            foreach (var perm in cfg.gather.perms) if (!permission.PermissionExists(perm.Key)) permission.RegisterPermission(perm.Key, this);
            foreach (var perm in cfg.bonus.perms) if (!permission.PermissionExists(perm.Key)) permission.RegisterPermission(perm.Key, this);
            foreach (var perm in cfg.collectible.perms) if (!permission.PermissionExists(perm.Key)) permission.RegisterPermission(perm.Key, this);
            foreach (var perm in cfg.components.perms) if (!permission.PermissionExists(perm.Key)) permission.RegisterPermission(perm.Key, this);
            foreach (var perm in cfg.barrels.perms) if (!permission.PermissionExists(perm.Key)) permission.RegisterPermission(perm.Key, this);
        }

        void OnCollectiblePickup(CollectibleEntity collectible, BasePlayer player)
        {
            if (player == null || collectible == null || !cfg.collectible.enablepickuprate) return;
            foreach (var item in collectible.itemList)
            {
                if (cfg.collectible.blacklist.Contains(item.itemDef.shortname) || item.itemDef.shortname.Contains("clone") || item.itemDef.shortname.Contains("seed")) return;
                item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.UserIDString, "collectible", ""));
            }
        }

        void OnGrowableGathered(GrowableEntity collectible, Item item, BasePlayer player)
        {
            if (player == null || item == null || collectible == null || !cfg.collectible.enablepickuprate) return;
            if (cfg.collectible.blacklist.Contains(item.info.shortname) || item.info.shortname.Contains("clone") || item.info.shortname.Contains("seed")) return;
            item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.UserIDString, "collectible", ""));
        }

        void OnDispenserBonus(ResourceDispenser dispenser, BasePlayer player, Item item)
        {
            if (item == null || player == null || dispenser == null || !cfg.bonus.enablebonusrate) return;
            if (cfg.bonus.blacklist.Contains(item.info.shortname)) return;
            item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.UserIDString, "bonus", ""));
        }

        void OnDispenserGather(ResourceDispenser dispenser, BaseEntity entity, Item item)
        {
            if (dispenser == null || entity == null || item == null || !cfg.gather.enablegatherrate) return;
            if (!entity.ToPlayer()) return;
            var player = entity.ToPlayer();
            if (player == null) return;
            if (cfg.gather.blacklist.Contains(item.info.shortname) || item.info.shortname == "hq.metal.ore") return;
            item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.UserIDString, "gather", ""));
        }

        public Dictionary<ulong, ulong> quarries = new Dictionary<ulong, ulong>();

        void OnQuarryGather(MiningQuarry quarry, Item item)
        {
            if (!cfg.quarry.enablequarryrate) return;
            if (quarry == null || item == null) return;
            if (cfg.quarry.blacklist.Contains(item.info.shortname)) return;
            if (quarry.OwnerID == 0)
            {
                if (!quarries.ContainsKey(quarry.net.ID.Value)) return;
                var player = quarries[quarry.net.ID.Value];
                item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.ToString(), "quarry_spawn", ""));
                return;
            }
            else
            {
                if (!quarries.ContainsKey(quarry.net.ID.Value)) return;
                var player = quarries[quarry.net.ID.Value];
                item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.ToString(), "quarry_player", ""));
                return;
            }
        }

        void OnQuarryToggled(MiningQuarry quarry, BasePlayer player)
        {
            if (quarry == null && player == null) return;

            if (quarries.ContainsKey(quarry.net.ID.Value))
                    quarries[quarry.net.ID.Value] = player.userID;
            else
                quarries.Add(quarry.net.ID.Value, player.userID);
        }

        void OnExcavatorGather(ExcavatorArm arm, Item item)
        {
            if (arm == null || item == null) return;
            if (!cfg.excavator.enableexcavatorrate) return;
            if (cfg.excavator.blacklist.Contains(item.info.shortname)) return;
            item.amount = (int)(Convert.ToDouble(item.amount) * cfg.excavator.defaultrate);
        }

        private void OnLootEntity(BasePlayer player, BaseEntity entity)
        {
            if (player == null || entity == null || entity.net == null || !cfg.components.enablecomponentsrate) return;
            if (entity is LootableCorpse) return;
            var container = entity as LootContainer;
            if (container == null) return;
            if (LootedBoxes.Contains(container.net.ID.Value)) return;
            if (!cfg.components.rate.ContainsKey(container.ShortPrefabName)) return;
            if (container.inventory == null) return;
            if (container.inventory.itemList?.Count == 0) return;
            foreach (var item in container.inventory.itemList)
            {
                if (item == null) continue;
                if (cfg.components.blacklist.Contains(item.info.shortname) || item.info.stackable == 1 ||
                    item.info.shortname.Contains("electric") || item.info.shortname.Contains("electric")) continue;
                item.amount = (int)(Convert.ToDouble(item.amount) * GetPlayerRate(player.UserIDString, "components", container.ShortPrefabName));
            }
            if (!LootedBoxes.Contains(container.net.ID.Value)) LootedBoxes.Add(container.net.ID.Value);
        }

        void OnEntityDeath(BaseEntity entity, HitInfo info)
        {
            if (!entity.ShortPrefabName.Contains("barrel")) return;
            if (info == null || info.InitiatorPlayer == null) return;

            var lootContainer = entity.GetComponent<LootContainer>();
            if (lootContainer == null) return;
            if (lootContainer.inventory?.itemList == null) return;

            if (!cfg.barrels.enablebarrelsrate) return;
            if (lootContainer != null)
            {
                foreach (var barrel in cfg.barrels.rate)
                {
                    if (lootContainer.ShortPrefabName.Contains(barrel.Key))
                    {
                        foreach (var items in lootContainer.inventory.itemList)
                        {
                            if (cfg.barrels.blacklist.Contains(items.info.shortname) || items.info.stackable == 1) continue;
                            items.amount = (int)(Convert.ToDouble(items.amount) * GetPlayerRate(info.InitiatorPlayer.UserIDString, "barrel", entity.ShortPrefabName));
                        }
                    }
                }
            }
        }

        #endregion
    }
}