FREE UnlimitedItems : 1.0.1 1.0.1

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

namespace Oxide.Plugins
{
    [Info("Unlimited Items", "Lincoln", "1.0.1")]
    [Description("Allows players with permission to have unlimited items in their inventory.")]
    class UnlimitedItems : RustPlugin
    {
        #region Fields
        private const string PermissionName = "unlimiteditems.use";
        private const string ForcePermissionName = "unlimiteditems.force";
        private const string Prefix = "<color=#f1c232>[Unlimited Items]</color>";
        private Configuration _config;
        private StoredData _storedData;
        #endregion

        #region Data Classes
        private class StoredData
        {
            public Dictionary<ulong, bool> PlayerToggles = new Dictionary<ulong, bool>();
        }

        private class Configuration
        {
            [JsonProperty("Enable Unlimited Items")]
            public bool EnableUnlimitedItems { get; set; } = true;

            [JsonProperty("Enable Health Restoration")]
            public bool EnableHealthRestoration { get; set; } = true;
        }
        #endregion

        #region Data Management
        private void LoadData()
        {
            _storedData = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, _storedData);
        }

        private bool IsUnlimitedEnabled(BasePlayer player)
        {
            if (!_storedData.PlayerToggles.TryGetValue(player.userID, out bool enabled))
            {
                _storedData.PlayerToggles[player.userID] = true;
                SaveData();
                return true;
            }
            return enabled;
        }

        private void ToggleUnlimited(BasePlayer player, bool enabled)
        {
            _storedData.PlayerToggles[player.userID] = enabled;
            SaveData();
        }
        #endregion

        #region Configuration
        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                _config = Config.ReadObject<Configuration>();
                if (_config == null) LoadDefaultConfig();
            }
            catch
            {
                PrintError("Configuration file is corrupted, creating new default config");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void LoadDefaultConfig()
        {
            _config = new Configuration
            {
                EnableUnlimitedItems = true,
                EnableHealthRestoration = true
            };
        }

        protected override void SaveConfig() => Config.WriteObject(_config, true);

        private void UpdateConfigValues()
        {
            PrintWarning("Configuration update detected! Updating config values...");
        }
        #endregion

        #region Localization
        private void LoadMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoPermission"] = $"{Prefix} You do not have permission to use unlimited items.",
                ["PluginDisabled"] = $"{Prefix} This plugin is currently disabled.",
                ["ToggleOn"] = $"{Prefix} Unlimited items enabled.",
                ["ToggleOff"] = $"{Prefix} Unlimited items disabled.",
                ["ToggleUsage"] = $"{Prefix} Usage: /ui to enable/disable unlimited items.",
                ["ForceEnabled"] = $"{Prefix} Your unlimited items are forced on and cannot be toggled."
            }, this);
        }

        private string GetMessage(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId), args);
        }
        #endregion

        #region Oxide Hooks
        private void Init()
        {
            permission.RegisterPermission(PermissionName, this);
            permission.RegisterPermission(ForcePermissionName, this);
            LoadMessages();
            LoadData();
            PrintWarning("UnlimitedItems plugin initialized!");
            PrintWarning($"Permission {PermissionName} registered: {permission.PermissionExists(PermissionName)}");
            PrintWarning($"Permission {ForcePermissionName} registered: {permission.PermissionExists(ForcePermissionName)}");
        }

        private bool HasUnlimitedItemsPermission(BasePlayer player)
        {
            if (!_config.EnableUnlimitedItems) return false;
            if (permission.UserHasPermission(player.UserIDString, ForcePermissionName)) return true;
            return permission.UserHasPermission(player.UserIDString, PermissionName) && IsUnlimitedEnabled(player);
        }

        object OnItemUse(Item item, int amount)
        {
            if (item == null || amount <= 0 || !_config.EnableUnlimitedItems) return null;
            BasePlayer player = item.GetOwnerPlayer();
            if (player != null && HasUnlimitedItemsPermission(player))
            {
                item.amount += amount;
                item.MarkDirty();
                return false;
            }
            return null;
        }

        object OnItemDeploy(Item item, BaseEntity entity)
        {
            if (item == null || entity == null || !_config.EnableUnlimitedItems) return null;
            BasePlayer player = item.GetOwnerPlayer();
            if (player != null && HasUnlimitedItemsPermission(player))
            {
                item.amount++;
                item.MarkDirty();
                if (_config.EnableHealthRestoration && entity is BaseCombatEntity combatEntity)
                {
                    combatEntity.SetHealth(combatEntity.MaxHealth());
                    combatEntity.SendNetworkUpdateImmediate();
                }
                return false;
            }
            return null;
        }

        [ChatCommand("ui")]
        private void CmdToggleUnlimited(BasePlayer player, string command, string[] args)
        {
            PrintWarning($"UI command called by {player.displayName} (ID: {player.UserIDString})");
            PrintWarning($"Has permission {PermissionName}: {permission.UserHasPermission(player.UserIDString, PermissionName)}");
            PrintWarning($"Has permission {ForcePermissionName}: {permission.UserHasPermission(player.UserIDString, ForcePermissionName)}");
            PrintWarning($"Plugin enabled: {_config.EnableUnlimitedItems}");

            if (!permission.UserHasPermission(player.UserIDString, PermissionName))
            {
                player.ChatMessage(GetMessage("NoPermission", player.UserIDString));
                return;
            }

            if (permission.UserHasPermission(player.UserIDString, ForcePermissionName))
            {
                player.ChatMessage(GetMessage("ForceEnabled", player.UserIDString));
                return;
            }

            if (!_config.EnableUnlimitedItems)
            {
                player.ChatMessage(GetMessage("PluginDisabled", player.UserIDString));
                return;
            }

            bool currentState = IsUnlimitedEnabled(player);
            ToggleUnlimited(player, !currentState);
            player.ChatMessage(GetMessage(currentState ? "ToggleOff" : "ToggleOn", player.UserIDString));
        }
        #endregion
    }
}