[Fixed] Restrict client (ClientVerification.cs) Runuo 2.2

sahisahi

sahisahi

Member
Hey i forgot how to restrict the client version, i want to restrict it to 6.0.0.0

but it doesnt seems to work at all, if player log with higher client version and nothing happens, ive tried to change it to kick,annoy...lenientkick...nothing it just dont work

This is my clientverification.cs


Code: 
using System;
using System.Diagnostics;
using System.IO;
using Server.Gumps;
using Server.Mobiles;
using Server.Network;

namespace Server.Misc
{
    public class ClientVerification
    {
        private enum OldClientResponse
        {
            Ignore,
            Warn,
            Annoy,
            LenientKick,
            Kick
        }

        private static bool m_DetectClientRequirement = true;
        private static OldClientResponse m_OldClientResponse = OldClientResponse.Kick;

        private static ClientVersion m_Required;
        private static bool m_AllowRegular = true, m_AllowUOTD = false, m_AllowGod = false;

        private static readonly TimeSpan m_AgeLeniency = TimeSpan.FromDays(10);
        private static readonly TimeSpan m_GameTimeLeniency = TimeSpan.FromHours(25);

        private static TimeSpan m_KickDelay = TimeSpan.FromSeconds(5.0);

        public static ClientVersion Required
        {
            get
            {
                return m_Required;
            }
            set
            {
                m_Required = value;
            }
        }

        public static bool AllowRegular
        {
            get
            {
                return m_AllowRegular;
            }
            set
            {
                m_AllowRegular = value;
            }
        }

        public static bool AllowUOTD
        {
            get
            {
                return m_AllowUOTD;
            }
            set
            {
                m_AllowUOTD = value;
            }
        }

        public static bool AllowGod
        {
            get
            {
                return m_AllowGod;
            }
            set
            {
                m_AllowGod = value;
            }
        }

        public static TimeSpan KickDelay
        {
            get
            {
                return m_KickDelay;
            }
            set
            {
                m_KickDelay = value;
            }
        }

        public static void Initialize()
        {
            EventSink.ClientVersionReceived += EventSink_ClientVersionReceived;

        
            //ClientVersion.Required = null;
            //Required = new ClientVersion( "6.0.0.0" );

            if (m_DetectClientRequirement)
            {
                string path = Core.FindDataFile("client.exe");

                if (File.Exists(path))
                {
                    FileVersionInfo info = FileVersionInfo.GetVersionInfo(path);

                    if (info.FileMajorPart != 0 || info.FileMinorPart != 0 || info.FileBuildPart != 0 || info.FilePrivatePart != 0)
                    {
                        Required = new ClientVersion(info.FileMajorPart, info.FileMinorPart, info.FileBuildPart, info.FilePrivatePart);
                    }
                }
            }

            if (Required != null)
            {
                Utility.PushColor(ConsoleColor.White);
                Console.WriteLine("Restricting client version to {0}. Action to be taken: {1}", Required, m_OldClientResponse);
                Utility.PopColor();
            }
        }

        private static void EventSink_ClientVersionReceived(ClientVersionReceivedArgs e)
        {
            string kickMessage = null;
            NetState state = e.State;
            ClientVersion version = e.Version;

            if (state.Mobile.AccessLevel > AccessLevel.Player)
                return;

            if (Required != null && version < Required && (m_OldClientResponse == OldClientResponse.Kick || (m_OldClientResponse == OldClientResponse.LenientKick && (DateTime.Now - state.Mobile.CreationTime) > m_AgeLeniency && state.Mobile is PlayerMobile && ((PlayerMobile)state.Mobile).GameTime > m_GameTimeLeniency)))
            {
                kickMessage = String.Format("This server requires your client version be at least {0}.", Required);
            }
            else if (!AllowGod || !AllowRegular || !AllowUOTD)
            {
                if (!AllowGod && version.Type == ClientType.God)
                    kickMessage = "This server does not allow god clients to connect.";
                else if (!AllowRegular && version.Type == ClientType.Regular)
                    kickMessage = "This server does not allow regular clients to connect.";
                else if (!AllowUOTD && state.IsUOTDClient)
                    kickMessage = "This server does not allow UO:TD clients to connect.";

                if (!AllowGod && !AllowRegular && !AllowUOTD)
                {
                    kickMessage = "This server does not allow any clients to connect.";
                }
                else if (AllowGod && !AllowRegular && !AllowUOTD && version.Type != ClientType.God)
                {
                    kickMessage = "This server requires you to use the god client.";
                }
                else if (kickMessage != null)
                {
                    if (AllowRegular && AllowUOTD)
                        kickMessage += " You can use regular or UO:TD clients.";
                    else if (AllowRegular)
                        kickMessage += " You can use regular clients.";
                    else if (AllowUOTD)
                        kickMessage += " You can use UO:TD clients.";
                }
            }

            if (kickMessage != null)
            {
                state.Mobile.SendMessage(0x22, kickMessage);
                state.Mobile.SendMessage(0x22, "You will be disconnected in {0} seconds.", KickDelay.TotalSeconds);

                Timer.DelayCall(KickDelay, delegate
                {
                    if (state.Socket != null)
                    {
                        Console.WriteLine("Client: {0}: Disconnecting, bad version", state);
                        state.Dispose();
                    }
                });
            }
            else if (Required != null && version < Required)
            {
                switch (m_OldClientResponse)
                {
                    case OldClientResponse.Warn:
                        {
                            state.Mobile.SendMessage(0x22, "Your client is out of date. Please update your client.", Required);
                            state.Mobile.SendMessage(0x22, "This server recommends that your client version be at least {0}.", Required);
                            break;
                        }
                    case OldClientResponse.LenientKick:
                    case OldClientResponse.Annoy:
                        {
                            SendAnnoyGump(state.Mobile);
                            break;
                        }
                }
            }
        }

        private static void SendAnnoyGump(Mobile m)
        {
            if (m.NetState != null && m.NetState.Version < Required)
            {
                Gump g = new WarningGump(1060637, 30720, String.Format("Your client is out of date. Please update your client.<br>This server recommends that your client version be at least {0}.<br> <br>You are currently using version {1}.<br> <br>To patch, run UOPatch.exe inside your Ultima Online folder.", Required, m.NetState.Version), 0xFFC000, 480, 360,
                    delegate
                        {
                        m.SendMessage("You will be reminded of this again.");

                        if (m_OldClientResponse == OldClientResponse.LenientKick)
                            m.SendMessage("Old clients will be kicked after {0} days of character age and {1} hours of play time", m_AgeLeniency, m_GameTimeLeniency);

                        Timer.DelayCall(TimeSpan.FromMinutes(Utility.Random(5, 15)), delegate { SendAnnoyGump(m); });
                    }, null, false);

                g.Dragable = false;
                g.Closable = false;
                g.Resizable = false;

                m.SendGump(g);
            }
        }
    }
}

Thanks
 
Last edited:
Edit; for some reason if i restrict the version to my 6.0.0.0 it just dont work, if i restrict it to any other version like 6.0.10.0 it does work.


weird, i really need to use 6.0.0.0 since any other version have issues on my server
 
Code: 
else if (Required != null && version < Required)

You may want to do version > Required or simply Required != version
 
Code: 
 else if (Required != null && Required != version)

like this?

i feel like theres something weird with the client 6.0.0.0 because if i set the requeriment to 6.0.10.0 the restriction does work, but i cant just use that client because there are many graphic issues like empty player corpses

when a player die the corpse appears naked unless u doubleclick, that sucks
 
Well as it is now it only kicks lower versions, since they may lack graphics and so on wich the newer ones have so
 
Ahhhh it worked :)

i tried different versions, and it does kick them, finally! thank you so much @PyrO

I also made the same edit here

Code: 
 if (Required != null && Required != version && (m_OldClientResponse == OldClientResponse.Kick || (m_OldClientResponse == OldClientResponse.LenientKick && (DateTime.Now - state.Mobile.CreationTime) > m_AgeLeniency && state.Mobile is PlayerMobile && ((PlayerMobile)state.Mobile).GameTime > m_GameTimeLeniency)))
            {
                kickMessage = String.Format("This server requires your client version be at least {0}.", Required);
            }

so this is how it looks, not sure if i messed it up :D

Code: 
using System;
using System.Diagnostics;
using System.IO;
using Server.Gumps;
using Server.Mobiles;
using Server.Network;

namespace Server.Misc
{
    public class ClientVerification
    {
        private enum OldClientResponse
        {
            Ignore,
            Warn,
            Annoy,
            LenientKick,
            Kick
        }

        private static bool m_DetectClientRequirement = true;
        private static OldClientResponse m_OldClientResponse = OldClientResponse.Kick;

        private static ClientVersion m_Required;
        private static bool m_AllowRegular = true, m_AllowUOTD = true, m_AllowGod = true;

        private static readonly TimeSpan m_AgeLeniency = TimeSpan.FromDays(10);
        private static readonly TimeSpan m_GameTimeLeniency = TimeSpan.FromHours(25);

        private static TimeSpan m_KickDelay = TimeSpan.FromSeconds(5.0);

        public static ClientVersion Required
        {
            get
            {
                return m_Required;
            }
            set
            {
                m_Required = value;
            }
        }

        public static bool AllowRegular
        {
            get
            {
                return m_AllowRegular;
            }
            set
            {
                m_AllowRegular = value;
            }
        }

        public static bool AllowUOTD
        {
            get
            {
                return m_AllowUOTD;
            }
            set
            {
                m_AllowUOTD = value;
            }
        }

        public static bool AllowGod
        {
            get
            {
                return m_AllowGod;
            }
            set
            {
                m_AllowGod = value;
            }
        }

        public static TimeSpan KickDelay
        {
            get
            {
                return m_KickDelay;
            }
            set
            {
                m_KickDelay = value;
            }
        }

        public static void Initialize()
        {
            EventSink.ClientVersionReceived += EventSink_ClientVersionReceived;

          //  ClientVersion.Required = null;
            Required = new ClientVersion( "6.0.0.0" );

            if (m_DetectClientRequirement)
            {
                string path = Core.FindDataFile("client.exe");

                if (File.Exists(path))
                {
                    FileVersionInfo info = FileVersionInfo.GetVersionInfo(path);

                    if (info.FileMajorPart != 0 || info.FileMinorPart != 0 || info.FileBuildPart != 0 || info.FilePrivatePart != 0)
                    {
                        Required = new ClientVersion(info.FileMajorPart, info.FileMinorPart, info.FileBuildPart, info.FilePrivatePart);
                    }
                }
            }

            if (Required != null)
            {
                Utility.PushColor(ConsoleColor.White);
                Console.WriteLine("Restricting client version to {0}. Action to be taken: {1}", Required, m_OldClientResponse);
                Utility.PopColor();
            }
        }

        private static void EventSink_ClientVersionReceived(ClientVersionReceivedArgs e)
        {
            string kickMessage = null;
            NetState state = e.State;
            ClientVersion version = e.Version;

            if (state.Mobile.AccessLevel > AccessLevel.Player)
                return;

            if (Required != null && Required != version && (m_OldClientResponse == OldClientResponse.Kick || (m_OldClientResponse == OldClientResponse.LenientKick && (DateTime.Now - state.Mobile.CreationTime) > m_AgeLeniency && state.Mobile is PlayerMobile && ((PlayerMobile)state.Mobile).GameTime > m_GameTimeLeniency)))
            {
                kickMessage = String.Format("This server requires your client version be at least {0}.", Required);
            }
            else if (!AllowGod || !AllowRegular || !AllowUOTD)
            {
                if (!AllowGod && version.Type == ClientType.God)
                    kickMessage = "This server does not allow god clients to connect.";
                else if (!AllowRegular && version.Type == ClientType.Regular)
                    kickMessage = "This server does not allow regular clients to connect.";
                else if (!AllowUOTD && state.IsUOTDClient)
                    kickMessage = "This server does not allow UO:TD clients to connect.";

                if (!AllowGod && !AllowRegular && !AllowUOTD)
                {
                    kickMessage = "This server does not allow any clients to connect.";
                }
                else if (AllowGod && !AllowRegular && !AllowUOTD && version.Type != ClientType.God)
                {
                    kickMessage = "This server requires you to use the god client.";
                }
                else if (kickMessage != null)
                {
                    if (AllowRegular && AllowUOTD)
                        kickMessage += " You can use regular or UO:TD clients.";
                    else if (AllowRegular)
                        kickMessage += " You can use regular clients.";
                    else if (AllowUOTD)
                        kickMessage += " You can use UO:TD clients.";
                }
            }

            if (kickMessage != null)
            {
                state.Mobile.SendMessage(0x22, kickMessage);
                state.Mobile.SendMessage(0x22, "You will be disconnected in {0} seconds.", KickDelay.TotalSeconds);

                Timer.DelayCall(KickDelay, delegate
                {
                    if (state.Socket != null)
                    {
                        Console.WriteLine("Client: {0}: Disconnecting, bad version", state);
                        state.Dispose();
                    }
                });
            }
            else if (Required != null && Required != version)
            {
                switch (m_OldClientResponse)
                {
                    case OldClientResponse.Warn:
                        {
                            state.Mobile.SendMessage(0x22, "Your client is out of date. Please update your client.", Required);
                            state.Mobile.SendMessage(0x22, "This server recommends that your client version be at least {0}.", Required);
                            break;
                        }
                    case OldClientResponse.LenientKick:
                    case OldClientResponse.Annoy:
                        {
                            SendAnnoyGump(state.Mobile);
                            break;
                        }
                }
            }
        }

        private static void SendAnnoyGump(Mobile m)
        {
            if (m.NetState != null && m.NetState.Version < Required)
            {
                Gump g = new WarningGump(1060637, 30720, String.Format("Your client is out of date. Please update your client.<br>This server recommends that your client version be at least {0}.<br> <br>You are currently using version {1}.<br> <br>To patch, run UOPatch.exe inside your Ultima Online folder.", Required, m.NetState.Version), 0xFFC000, 480, 360,
                    delegate
                        {
                        m.SendMessage("You will be reminded of this again.");

                        if (m_OldClientResponse == OldClientResponse.LenientKick)
                            m.SendMessage("Old clients will be kicked after {0} days of character age and {1} hours of play time", m_AgeLeniency, m_GameTimeLeniency);

                        Timer.DelayCall(TimeSpan.FromMinutes(Utility.Random(5, 15)), delegate { SendAnnoyGump(m); });
                    }, null, false);

                g.Dragable = false;
                g.Closable = false;
                g.Resizable = false;

                m.SendGump(g);
            }
        }
    }
}
 
private static bool m_DetectClientRequirement = false;



on the bool client requirement is different than the void initialize..
is why kept getting cs0018 no definition...
 
You must log in or register to reply here.

Active Shards

Donations

Total amount
$0.00
Goal
$1,000.00
View
Back