FREE NControlES : 0.5.6 0.5.6

using System;
using System.Collections.Generic;
using Facepunch.Extend;
using Newtonsoft.Json;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("NControlES", "Hougan", "0.5.6")]
    [Description("Controlar nicks de jugadores")]
    public class NControlES : RustPlugin
    {
        #region Variables

        [JsonProperty("Kickear jugadores con nick prohibido")]
        private bool CONF_KickBlocked = true;
        [JsonProperty("Ignorar administradores?")]
        private bool CONF_AdminIgnore = false;
        [JsonProperty("Guardar los logs?")]
        private bool CONF_LogChanges = true;
        [JsonProperty("Razon del kickeo si el jugador tiene un nombre especificado en la lista")]
        private string CONF_KickReason = "Tu nick contiene caracres prohibidos no puedes entrar al servidor con este nick: {0}";
        
        [JsonProperty("Lista da palabras o nombres prohibidos")]
        private List<string> CONF_BlockedParts = new List<string>
        {
            ".com",
            ".lt",
            ".net",
            ".org",
            ".gg",
            ".ru",
            ".рф",
            ".int",
            ".info",
            ".ru.com",
            ".ru.net",
            ".com.ru",
            ".net.ru",
            ".org.ru",
            "moscow",
			"#howl.gg // Puedes agregar otros simbolos a los nicks."
        };
        
        #endregion

        #region Initialization

        protected override void LoadDefaultConfig()
        {
            GetConfig("1.Ignorar caracteres prohibidos para los administradores", ref CONF_AdminIgnore);
            GetConfig("2.Kickear del servidor con un nick prohibido", ref CONF_KickBlocked);
            GetConfig("3.Razon del kickeo al jugador que tiene el nick prohibido", ref CONF_KickReason);
            GetConfig("4.Guardar los logs de cambio de nombre, o las razones del kickeo", ref CONF_LogChanges);
            GetConfig("5.Elementos prohibidos de nick en cualquier lugar del nick", ref CONF_BlockedParts);
            
            Config.Save();
        }

        private void OnServerInitialized()
        {
            LoadDefaultConfig();
            permission.RegisterPermission("NControlES.Allow", this);
            
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["SIN.ACCESO"]           = "No tienes permisos suficientes!",
                
                ["SINTAX.CAMBIO"]       = "Usa el coamndo correcto!!\n" +
                                            " - /changename <nombre/ID> <nick> - cambio de nombre",
                
                ["BUSQUEDA.ERROR"]             = "No he podido encontrar el jugador con el nick / ID",
                ["BUSQUEDA.VARIOS"]           = "He encontrado varios jugadores con ese nick",
                
                ["CORRECTAMENTE.CAMBIADO"]      = "Has cambiado el nombre al jugador {0} correctamente"
            }, this);
            
        }

        #endregion

        #region Hooks

        private bool? CanClientLogin(Network.Connection connection)
        {
            string blockedItem;
            if (ContainsAny(connection.username, CONF_BlockedParts, out blockedItem))
            {
                if (CONF_AdminIgnore)
                    return null;

                if (CONF_KickBlocked)
                {
                    ConnectionAuth.Reject(connection, CONF_KickReason.Replace("{0}", blockedItem));
                    connection.rejected = true;
                    
                    LogToFile("Kick", $"Jugador fue kickeado por usar un nick prohibido {connection.username} [{blockedItem}]", this, false);
                    return false;
                }

                string oldName = connection.username;
                connection.username = FormatAll(connection.username, CONF_BlockedParts);
                LogToFile("Changes", $"Cambio de nombre al jugador\nAntiguo: {oldName}\nNuevo: {connection.username}", this, false);
            }

            return null;
        }

        #endregion

        #region Commands

        [ConsoleCommand("changename")]
        private void cmdChange(ConsoleSystem.Arg args)
        {
            BasePlayer player = args.Player();
            if (player != null && !player.IsAdmin && !permission.UserHasPermission(player.UserIDString, "NControlES.Allow"))
            {
                args.ReplyWithObject(GetMessage("SIN.ACCESO"));
                return;
            }
            if (!args.HasArgs(2))
            {
                args.ReplyWithObject(GetMessage("SINTAX.CAMBIO"));
                return;
            }

            List<BasePlayer> findPlayers = FindPlayer(args.Args[0]);
            switch (findPlayers.Count)
            {
                case 0:
                {
                    args.ReplyWithObject(GetMessage("BUSQUEDA.ERROR"));
                    return;
                }
                case 1:
                {
                    BasePlayer target = findPlayers[0];
                    string oldName = target.displayName;

                    target.displayName = args.Args[1];
                    
                    args.ReplyWithObject(GetMessage("CORRECTAMENTE.CAMBIADO").Replace("{0}", target.displayName));
                    LogToFile("Changes", $"Cambio de nombre al jugador\nAntiguo: {oldName}\nNuevo: {target.displayName}", this, false);
                    
                    break;
                }
                default:
                {
                    string resultMessage = GetMessage("BUSQUEDA.VARIOS");
                    foreach (var check in findPlayers)
                        resultMessage += $" - {check.displayName} [{check.userID}]";
                    
                    args.ReplyWithObject(resultMessage);
                    return;
                }
            }
        }

        #endregion

        #region Helpers

        private string FormatAll(string input, List<string> check)
        {
            foreach (var block in check)
            {
                while (input.Contains(block, StringComparison.OrdinalIgnoreCase))
                {
                    input = input.Replace(block, "", StringComparison.OrdinalIgnoreCase);
                }
            }

            return input;
        }
        
        private bool ContainsAny(string input, List<string> check, out string result)
        {
            result = "";
            
            foreach (var block in check)
            {
                if (input.Contains(block))
                {
                    result = block;
                    return true;
                }
            }

            return false;
        }

        private List<BasePlayer> FindPlayer(string input)
        {
            List<BasePlayer> returnList = new List<BasePlayer>();

            foreach (var check in BasePlayer.activePlayerList)
            {
                if (check.displayName.ToLower().Contains(input.ToLower()))
                    returnList.Add(check);
                if (check.userID.ToString() == input)
                    return new List<BasePlayer> { check };
            }

            foreach (var check in BasePlayer.sleepingPlayerList)
            {
                if (check.displayName.ToLower().Contains(input.ToLower()))
                    returnList.Add(check);
                if (check.userID.ToString() == input)
                    return new List<BasePlayer> { check };
            }

            return returnList;
        }
        
        private void GetConfig<T>(string Key, ref T var)
        {
            if (Config[Key] != null)
            {
                var = Config.ConvertValue<T>(Config[Key]);
            }
            else
            {
                Config[Key] = var;
            }
        }

        private string GetMessage(string key) => lang.GetMessage(key, this);

        #endregion
    }
}