FREE BlueprintManager : 1.0.5 1.0.5

using System;
using System.Collections.Generic;
using System.Linq;

using Oxide.Core;
using UnityEngine;

using Oxide.Plugins.BlueprintManagerExtensions;

namespace Oxide.Plugins
{
    [Info("Blueprint Manager", "Oxide Россия", "1.0.5")]
    internal class BlueprintManager : RustPlugin
    {
        #region Fields

        public static BlueprintManager Instance;
        private readonly Queue<Action> _unlockQueue = new Queue<Action>();
        private Configuration _configuration;
        private TriggerWorkbench _workbenchTrigger;
        private Workbench _workbench;

        #endregion

        #region Properties

        public List<string> GetDefaultBlueprints =>
            _configuration.DefaultBlueprints.ConvertAll(x => x.ToString());

        #endregion

        #region Configuration 

        private class Configuration
        {
            public readonly List<object> DefaultBlueprints = new List<object>();

            public Configuration()
            {
                GetConfig(ref DefaultBlueprints, "Settings", "Default blueprints");
                Instance.SaveConfig();
            }

            private void GetConfig<T>(ref T variable, params string[] path)
            {
                if (path.Length == 0)
                    return;

                if (Instance.Config.Get(path) == null)
                {
                    SetConfig(ref variable, path);
                    Instance.PrintWarning($"Added field to config: {string.Join("/", path)}");
                }

                variable = (T)Convert.ChangeType(Instance.Config.Get(path), typeof(T));
            }

            private void SetConfig<T>(ref T variable, params string[] path) =>
                Instance.Config.Set(path.Concat(new object[] { variable }).ToArray());
        }

        protected override void LoadDefaultConfig() =>
            PrintWarning("Generating new config file...");

        #endregion

        #region Commands

        [ChatCommand("blueprint")]
        private void BlueprintCommand(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, "blueprintmanager.admin"))
            {
                PrintToChat(player, Lang(player, "NoPermission"));
                return;
            }

            if (args.Length < 2)
            {
                if (args.Length == 1 && args[0].ToLower() == "help")
                    PrintToChat(player, Lang(player, "Help"));
                else
                    PrintToChat(player, Lang(player, "IncorrectArguments"));
                return;
            }

            var target = FindPlayer(player, args[1]);
            if (target == null)
                return;

            switch (args[0].ToLower())
            {
                case "unlock":
                    if (args.Length < 3)
                    {
                        PrintToChat(player, Lang(player, "IncorrectArguments"));
                        return;
                    }

                    var itemDefinition = GetItemDefinition(args[2]);
                    if (itemDefinition == null)
                    {
                        PrintToChat(player, Lang(player, "InvalidItem", args[2].ToLower()));
                        return;
                    }

                    PrintToChat(player, Lang(player, "ItemUnlocked", args[2].ToLower(), target.displayName));
                    target.UnlockItem(args[2]);
                    break;

                case "unlockall":
                    PrintToChat(player, Lang(player, "AllUnlocked", target.displayName));
                    target.UnlockAll();
                    break;

                case "resetall":
                    PrintToChat(player, Lang(player, "AllReset", target.displayName));
                    target.ResetAll();
                    break;
            }
        }

        #endregion

        #region Localization

        protected override void LoadDefaultMessages() => lang.RegisterMessages(
            new Dictionary<string, string>
            {
                {"NoPermission", "Error, you lack permission."},
                {"IncorrectArguments", "Error, incorrect arguments. Try /blueprint help."},

                {"NoPlayerFound", "Error, no player found by the name of {0}."},
                {"MultiplePlayersFound", "Error, multiple players found by the name of {0}."},

                {"ItemUnlocked", "Successfully unlocked item {0} for {1}."},
                {"InvalidItem", "Error, no item found by the name of {0}."},

                {"AllUnlocked", "Successfully unlocked all items for {0}."},
                {"AllReset", "Successfully reset all items for {0}."},

                {"Help", "/blueprint unlock <player> <shortname>\n" +
                         "/blueprint unlockall <player>\n" +
                         "/blueprint resetall <player>"}
            }, this);

        private string Lang(BasePlayer player, string key, params object[] args)
        {
            var message = lang.GetMessage(key, this, player.UserIDString);
            return args.Length > 0 ? string.Format(message, args) : message;
        }

        #endregion

        #region Methods

        private BasePlayer FindPlayer(BasePlayer player, string nameOrID)
        {
            var targets = BasePlayer.activePlayerList
                .Where(x => nameOrID.IsSteamId()
                    ? x.UserIDString == nameOrID
                    : x.displayName.ToLower().Contains(nameOrID.ToLower()))
                .ToList();

            if (targets.Count == 1)
                return targets[0];

            PrintToChat(player, Lang(player,
                targets.Count == 0 ? "NoPlayerFound" : "MultiplePlayersFound"), nameOrID);

            return null;
        }

        public ItemDefinition GetItemDefinition(string shortName)
        {
            if (string.IsNullOrEmpty(shortName))
                return null;

            return ItemManager.FindItemDefinition(shortName.ToLower());
        }

        private void SpawnWorkbench()
        {
            _workbench = GameManager.server.CreateEntity(
                "assets/prefabs/deployable/tier 3 workbench/workbench3.deployed.prefab",
                new Vector3(0, -50, 0)) as Workbench;

            if (_workbench == null)
                return;

            _workbench.enableSaving = false;
            _workbench.Spawn();

            _workbench.GetComponent<DestroyOnGroundMissing>().enabled = false;
            _workbench.GetComponent<GroundWatch>().enabled = false;

            _workbenchTrigger = _workbench.GetComponentInChildren<TriggerWorkbench>();
            _workbenchTrigger.name = "workbench";

            timer.In(1f, () =>
            {
                if (_workbench == null || _workbench.IsDestroyed)
                    SpawnWorkbench();
            });
        }

        #endregion

        #region Console Commands

        [ConsoleCommand("blueprint.unlockall")]
        private void ConsoleUnlockAll(ConsoleSystem.Arg arg)
        {
            if (arg.Connection != null)
            {
                arg.ReplyWith("This command can only be used from server console or RCON.");
                return;
            }

            int count = 0;
            foreach (var player in BasePlayer.activePlayerList)
            {
                player.UnlockAll();
                count++;
            }

            Puts($"[BlueprintManager] Unlocked all blueprints for {count} players.");
        }

        #endregion

        #region Oxide Hooks

        private void Unload()
        {
            if (_workbench != null && !_workbench.IsDestroyed)
                _workbench.DieInstantly();
        }

        private void OnServerInitialized()
        {
            permission.RegisterPermission("blueprintmanager.admin", this);
            permission.RegisterPermission("blueprintmanager.all", this);
            permission.RegisterPermission("blueprintmanager.config", this);
            permission.RegisterPermission("blueprintmanager.noworkbench", this);

            Instance = this;
            _configuration = new Configuration();

            SpawnWorkbench();

            foreach (var player in BasePlayer.activePlayerList)
                OnPlayerInit(player);

            timer.Repeat(10f, 0, () =>
            {
                if (_unlockQueue.Any())
                    _unlockQueue.Dequeue()?.Invoke();
            });
        }

        private void OnPlayerInit(BasePlayer player)
        {
            if (permission.UserHasPermission(player.UserIDString, "blueprintmanager.all"))
                _unlockQueue.Enqueue(player.UnlockAll);
            else if (permission.UserHasPermission(player.UserIDString, "blueprintmanager.config"))
                _unlockQueue.Enqueue(player.UnlockConfig);

            if (!permission.UserHasPermission(player.UserIDString, "blueprintmanager.noworkbench"))
                return;

            if (_workbenchTrigger != null)
                player.EnterTrigger(_workbenchTrigger);
        }

        private void OnEntityLeave(TriggerBase trigger, BaseEntity entity)
        {
            var player = entity.ToPlayer();
            if (player == null)
                return;

            if (trigger.name == "workbench")
                player.EnterTrigger(trigger);
        }

        #endregion
    }

    namespace BlueprintManagerExtensions
    {
        static class Extensions
        {
            public static void UnlockAll(this BasePlayer player)
            {
                var bp = player.blueprints;
                if (bp != null)
                    bp.UnlockAll();
            }

            public static void UnlockItem(this BasePlayer player, string shortName)
            {
                var bp = player.blueprints;
                if (bp == null)
                    return;

                var item = BlueprintManager.Instance.GetItemDefinition(shortName);
                if (item != null)
                    bp.Unlock(item);
            }

            public static void UnlockConfig(this BasePlayer player)
            {
                foreach (var shortName in BlueprintManager.Instance.GetDefaultBlueprints)
                {
                    if (!string.IsNullOrEmpty(shortName))
                        player.UnlockItem(shortName);
                }
            }

            public static void ResetAll(this BasePlayer player)
            {
                var bp = player.blueprints;
                if (bp != null)
                    bp.Reset();
            }
        }
    }
}