FREE Check : 1.0.0 1.0.0

using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using UnityEngine;
using ox = Oxide.Core;

namespace Oxide.Plugins
{
    [Info("Check", "Работает", "1.0.0")]
    public class Check : RustPlugin
    {
        public static ox.Libraries.Permission perm => ox.Interface.Oxide.GetLibrary<ox.Libraries.Permission>("Permission");

        [JsonProperty("Текущие проверки")]
        private Dictionary<ulong, CheckProcess> checkList = new Dictionary<ulong, CheckProcess>();

        public static long GetTimeStamp() =>
            ((long)DateTime.Now.Subtract(Epoch).TotalSeconds);
        private static DateTime Epoch = new DateTime(2019, 1, 1);

        private class CheckProcess
        {
            [JsonProperty("Проверяющий")]
            public BasePlayer Checker;
            [JsonProperty("Проверяемый")]
            public BasePlayer Target;
            [JsonProperty("Время начала проверки")]
            public double StartTime;

            [JsonProperty("Проверка связи")]
            public bool Accept;

            public CheckProcess(BasePlayer Admin, BasePlayer Check)
            {
                Checker = Admin;
                Target = Check;
                StartTime = GetTimeStamp();
                Accept = false;
            }
        }

        private void UpdateTime(CheckProcess checkProcess)
        {
            timer.Once(1, () => UpdateTime(checkProcess));
        }

        private PluginConfig config;
        class PluginConfig
        {
            [JsonProperty(PropertyName = "Основные настройки")]
            public MainSettings mainSet { get; set; }
            public class MainSettings
            {
                [JsonProperty("Пермишка на /check")]
                public string CheckPerm { get; set; } = "checkperm.s";

                [JsonProperty("Пермишка на принятие репортов")]
                public string text3 { get; set; } = "report.perm";

                [JsonProperty("Пермишка на /uncheck")]
                public string UnCheckPerm { get; set; } = "uncheckperm.s";
            }
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason, string[] args)
        {
            BasePlayer target = BasePlayer.Find(args[0]);
            if (checkList.ContainsKey(player.userID))
            {
                ConsoleSystem.OnSendToServer($"ban { target.userID}");
               
            }
                
        }

        protected override void LoadDefaultConfig()
        {
            var configData = new PluginConfig { mainSet = new PluginConfig.MainSettings() };
            Config.WriteObject(configData, true);
        }
        private void LoadVariables()
        {
            bool changed = false;
            Config.Settings.DefaultValueHandling = DefaultValueHandling.Populate;
            config = Config.ReadObject<PluginConfig>();
            if (config.mainSet == null) { config.mainSet = new PluginConfig.MainSettings(); changed = true; }
            Config.WriteObject(config, true);
            if (changed) PrintWarning("Конфиг обновлен");
        }
        private void OnServerInitialized()
        {
            LoadVariables();
            if (!permission.PermissionExists(config.mainSet.CheckPerm)) permission.RegisterPermission(config.mainSet.CheckPerm, this);
            if (!permission.PermissionExists(config.mainSet.UnCheckPerm)) permission.RegisterPermission(config.mainSet.UnCheckPerm, this);
            if (!permission.PermissionExists(config.mainSet.text3)) permission.RegisterPermission(config.mainSet.text3, this);
        }

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

            foreach (var check in BasePlayer.activePlayerList)
                CuiHelper.DestroyUi(check, Layer);

        }
        static void SendReport(BasePlayer player, string msg)
        {

            if (!perm.UserHasPermission(player.userID.ToString(), "report.perm")) ;
            {
                player.SendConsoleCommand("chat.add", new object[] { 0, msg });
            }
            Interface.GetMod().LogWarning(msg);
        }

        [ChatCommand("check")]
        private void houganlox(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.userID.ToString(), config.mainSet.CheckPerm))
            {
                PrintToChat(player, ($"<size=18>ПРОВЕРКА ПО:</size>\nНету <color=yellow>права</color> на данную команду")); return;
            }

            if (args.Length == 0)
            {
                player.ChatMessage($"<size=18>ПРОВЕРКА ПО:</size>\n<size=15>Вы не написали <color=yellow>ник/steamid</color> проверяемого!</size>");
                return;
            }

            BasePlayer target = BasePlayer.Find(args[0]);
            if (target != null)
            {
                if (checkList.ContainsKey(target.userID))
                {
                    player.ChatMessage("<size=18>ПРОВЕРКА ПО:</size>\n<size=15>Данный игрок уже находится на <color=yellow>проверке</color>!</size>");
                }
                else
                {
                    CheckProcess checkProcess = new CheckProcess(player, target);
                    SendReply(player, "Игрок успешно вызван");
                    SendReply(target, "Вас вызвали на проверку");
                    UI_Interface(target);

                    StartCheck(checkProcess);

                    timer.Once(180, () =>
                    {
                        CuiHelper.DestroyUi(player, Layer);
                    });
                    return;
                }
            }
        }

        private void StartCheck(CheckProcess checkProcess)
        {
            foreach (var check in BasePlayer.activePlayerList)
                SendReply(check, $"<size=18>ПРОВЕРКА ПО:</size>\nИгрок: <color=yellow>{checkProcess.Target.displayName}</color> вызван на проверку модератором: <color=yellow>{checkProcess.Checker.displayName}</color>");
        }

        private void StopCheck(CheckProcess checkProcess)
        {
            foreach (var check in BasePlayer.activePlayerList)
                SendReply(check, $"<size=18>ПРОВЕРКА ПО:</size>\nИгрок: <color=yellow>{checkProcess.Target.displayName}</color> был проверен модератором: <color=yellow>{checkProcess.Checker.displayName}</color> стороннего ПО не обнаружено!");
        }


        [ChatCommand("uncheck")]
        private void uncheck2(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.userID.ToString(), config.mainSet.UnCheckPerm))
            {
                PrintToChat(player, ($"<size=18>ПРОВЕРКА ПО:</size>\nНету <color=yellow>права</color> на данную команду")); return;
            }

            if (args.Length == 0)
            {
                player.ChatMessage($"<size=18>ПРОВЕРКА ПО:</size>\nНапишите <color=yellow>Никнейм</color> игрока или его <color=yellow>Steam ID</color>!");
                return;
            }

            BasePlayer target = BasePlayer.Find(args[0]);
            CuiHelper.DestroyUi(target, Layer);
            CheckProcess checkProcess = new CheckProcess(player, target);
            StopCheck(checkProcess);


            if (target != null)
            {
                if (checkList.ContainsKey(target.userID))
                {
                    checkList.Remove(target.userID);
                }
            }
        }

        [ChatCommand("")]
        private void neanea(BasePlayer player, string command, string[] args)
        {
            if (!checkList.ContainsKey(player.userID))
                return;

            if (args.Length == 0)
            {
                player.ChatMessage($"Вы не написали свой скайп!");
                return;
            }

            string message = "";
            foreach (var check in args)
                message += $" {check}";

            List<Fields> fields = new List<Fields>
            {
                new Fields("Игрок:", $"{player.displayName} [{player.userID}]", true),
                new Fields("Skype:", message, false)
            };
            Message newMessage = new Message(null, false, new Message.Embeds[1] { new Message.Embeds("Получен Skype от игрока!", 14761010, fields) });

            SendReport(player, string.Format($"[Skype] Player: {player.displayName} [{player.userID}]\nСкайп: " + message));
            player.ChatMessage("Сообщение успешно отправлено модераторам!");
        }
        [ChatCommand("")]
        private void nopenope(BasePlayer player, string command, string[] args)
        {
            if (!checkList.ContainsKey(player.userID))
                return;

            if (args.Length == 0)
            {
                player.ChatMessage($"Вы не написали свой дискорд!");
                return;
            }

            string message = "";
            foreach (var check in args)
                message += $" {check}";

            List<Fields> fields = new List<Fields>
            {
                new Fields("Игрок:", $"{player.displayName} [{player.userID}]", true),
                new Fields("Discord:", message, false)
            };
            Message newMessage = new Message(null, false, new Message.Embeds[1] { new Message.Embeds("Получен Discord от игрока!", 14761010, fields) });

            SendReport(player, string.Format($"[Discord] Player: {player.displayName} [{player.userID}]\nДискорд: " + message));
            player.ChatMessage("Сообщение успешно отправлено модераторам!");
        }

        private const string Layer = "GUI_Plugin";
        private void UI_Interface(BasePlayer player)
        {
            CuiHelper.DestroyUi(player, Layer);
            CuiElementContainer container = new CuiElementContainer();
            container.Add(new CuiPanel
            {
                CursorEnabled = false,
                RectTransform = { AnchorMin = "0.5 0.5", AnchorMax = "0.5 0.5", OffsetMin = "-300 150", OffsetMax = "300 250" },
                Image = { Color = "0 0 0 0" }
            }, "Overlay", Layer);

            container.Add(new CuiButton
            {
                RectTransform = { AnchorMin = "0 0", AnchorMax = "1 1" },
                Button = { FadeIn = 1f, Command = "chat.say /houganlisiyhui", Color = HexToRustFormat("#FF8C00") },
                Text = { FadeIn = 1f, Text = $"<size=28><b>ВЫ ПОДОЗРЕВАЕТЕСЬ В ИСПОЛЬЗОВАНИИ ПО!</b></size>\n" +
                                $"<size=20>Отпишитесь в чат и дайте ваш Discord.Игнорирование/Выход с сервера — блокировка.</size>", Align = TextAnchor.MiddleCenter, Font = "robotocondensed-regular.ttf", FontSize = 24 }
            }, Layer);

            CuiHelper.AddUi(player, container);
        }

        public class Message
        {
            public string content { get; set; }
            public bool tts { get; set; }
            public Embeds[] embeds { get; set; }

            public class Embeds
            {
                public string title { get; set; }
                public int color { get; set; }
                public List<Fields> fields { get; set; }
                public Embeds(string title, int color, List<Fields> fields)
                {
                    this.title = title;
                    this.color = color;
                    this.fields = fields;
                }
            }

            public Message(string content, bool tts, Embeds[] embeds)
            {
                this.content = content;
                this.tts = tts;
                this.embeds = embeds;
            }

            public string toJSON() => JsonConvert.SerializeObject(this);
        }
        public class Fields
        {
            public string name { get; set; }
            public string value { get; set; }
            public bool inline { get; set; }
            public Fields(string name, string value, bool inline)
            {
                this.name = name;
                this.value = value;
                this.inline = inline;
            }
        }

        private static string HexToRustFormat(string hex)
        {
            if (string.IsNullOrEmpty(hex))
            {
                hex = "#FFFFFFFF";
            }

            var str = hex.Trim('#');

            if (str.Length == 6)
                str += "FF";

            if (str.Length != 8)
            {
                throw new Exception(hex);
                throw new InvalidOperationException("Cannot convert a wrong format.");
            }

            var r = byte.Parse(str.Substring(0, 2), NumberStyles.HexNumber);
            var g = byte.Parse(str.Substring(2, 2), NumberStyles.HexNumber);
            var b = byte.Parse(str.Substring(4, 2), NumberStyles.HexNumber);
            var a = byte.Parse(str.Substring(6, 2), NumberStyles.HexNumber);

            Color color = new Color32(r, g, b, a);

            return string.Format("{0:F2} {1:F2} {2:F2} {3:F2}", color.r, color.g, color.b, color.a);
        }
    }
}