[Guide]Coding your own source

[BaussHacker]

Notice this is not a guide how to setup a source, neither will I provide you with exact copy pasting. I will make a guide how you can start to learn code for a private server and such. It will be nothing fancy, but more a general knowledge about server/client programming and then basic conquer knowledge.

Everything provided will be in C#, but it's for the fact most here is coding in C#.

Before you start to code on your private server, then it's important you understand the C# language itself. You will never get anywhere, if you just jump directly into the private server coding. Lucky for you there is a tons of resource available for C# on the internet and there is a lot forums that you can get help and tutorials in, but a good idea is to take 1-2 months just focusing on learning the actual C# language and after that time you can start to look into coding a private server. It might be a long time and you think making a private server is just 2 steps and then having it running, but if you want a proper server, then you need to put effort into it. Not only will this help you coding a private server, but programming can get you long in life and you can also use it to code a lot other things. In fact there is not a lot limits, if you know how to code.

First of all a good idea would be to understand what a programming language is, so please take the time to read this:
Computer programming - Wikipedia, the free encyclopedia

If you do not understand it, then don't panic. You can either read it again or lookup on it later. It's not neccessary to know it right now and I don't expect you to know any coding at all, when you start reading all this.

Next thing is choosing a language that you want to design your server in, but in this case we will choose C#.

If you want to know what C# exactly is, then here isa wikipedia page for it:
C Sharp (programming language) - Wikipedia, the free encyclopedia)

Learning the actualy language is not something that takes 1 day, 2days, 1 week or a month, but it takes very long time to get advanced in it.

A good idea would be reading some e-books or watching videos at youtube.
I will provide some links to some.

There is a lot books here:


C# for dummies:


Hybrids:


New bostons video tutorials: (This is the first, just continue to rest.)

MSDN:





Other sites and communities:







Now that might be a lot information at ones, but take the time you need to actually understand the language and so. You don't have to rush making a server. Some are learning faster than others, but we all got the same goal basically.

Now ones you understand the language and be HONEST to yourself. Do not try cheat or skip things. If you don't understand it, you might reread and learn some more, because it's important you understand the language, because I will not provide copy-paste neither a lot codes.

I will also only learn you how to communicate with the client and about server/client things, but not exactly how to code a private server. There is more than enough resources on that already.

Well first of all we need to make a new project. Choose console application, because having a GUI or using a form application is just a waste. No others are gonna see your server other than you.

The first thing you code for your server is the socket system. The socket system is the connection between the client and server. It's also where you send the data through.

When I'm coding a socket system, then I'm using a 3 way prencip.


Most people might actually do it this way and what so ever. Well let me explain the system.

The global socket wrapper
This is where everything is going to be handled. You can call this a kernel of our socket system. It's where we create our listener, our connections, our events that's going to be raised upon connections and receiving data from the clients. It will handle basically everything with our socket system.

The socket handlers
There is mainly 3 handlers that will be used and then a wrapper around it. The handlers or events are where we will handle the actual data received and every connection.

The socket client
This is the wrapper for the client and where you handle the client itself, but also the data that's going to be send back to the client.

First thing you gotta do, when coding the socket system is making a new folder, because we want to have a namespace for our sockets. Call the folder Network, because sockets have to do with the network. Once you have done that, then create a new class called ServerSocket, which will be our global socket wrapper or the 'kernel socket'.

The socket system we're going to use is an asynchronus socket system, which means it will not wait on the other events to be done, where it would if we used a synchronus socket system.

Read more about it here:


The socket class, we're going to use is the System.Net.Sockets, which you can read more about here:


The first thing we're going to code is our listener. Which will listen on a specific port. In this case it's the authserver and that's port 9959.

We need some global fields in our socket wrapper, which are the following.
(Read comments, because I explain what they are used for there.)

//This is the max buffer size of a packet. The default value is 1024 and it's also what we're going to use.
public int BufferSize;

//This is the actual socket, which will handle everything we do. The wrapper is basically just handling the methods within this class.
public System.Net.Sockets.Socket Socket;

//This is the port the gameserver have and for a co server it's 5816
public int Port;

We will add more fields later, but so far this is what we're going to have.
Within this method we create our socket, binds it to an endpoint and then starts to listen after connections.

First thing we gotta do is coding the actual listener. We start making a method called Listen.

        public void Listen()
        {
        }

Creating the socket takes 3 steps.
We have to create an address family, a socket type and a protocol.
The address family we're going to use is InterNetwork, becuase it has to do with the actual network.

The socket type will be stream, because that's what's normal to use when working with a 2 way connection system, which we do, because it's a client/server connection.

The protocol is tcp, because that's what the conquer client uses. I don't want to explain about the difference of tcp and udp, but basically udp is about speed and it can loose packets easy and when it do, then it will not report back and it will just think, whatever, then continue its work. Tcp will always report back if there was an error when sending/receiving a packet. Usually udp is used for streaming and such things, where tcp is better when working with server/client stuff, but it doesn't mean you cannot use it. If I'm correct HoN uses udp.

Socket = new System.Net.Sockets.Socket(
                System.Net.Sockets.AddressFamily.InterNetwork,
                System.Net.Sockets.SocketType.Stream,
                System.Net.Sockets.ProtocolType.Tcp);

Next thing we do is binding our socket to an endpoint or to be more specific a network. To do that we will make a new method called GetEndPoint().
In this method we will use the field we created before for the Port. The return type of it should be System.Net.IPEndPoint. We will just create a new IPEndPoint.

We will use IPAddress.Any, but I don't want to explain why, but you can read up on it yourself.

Then we will use the Port field we defined earlier.

        public System.Net.IPEndPoint GetEndPoint()
        {
            return new System.Net.IPEndPoint(System.Net.IPAddress.Any, Port);
        }

Now we can just bind our socket calling this method then.

Socket.Bind(GetEndPoint());

Now we will start to listen calling Socket.Listen() and we need to specify a backlog, if you want to know more about backlogs, then read here:

And in the actual Listen document:

Socket.Listen(100);

Now the last thing we gotta do to finish our listener is calling the Socket.BeginAccept method, but we will make a new method for that and call that method within the listen method, because we're going to call it more than ones.

Before we create it, then we will make 2 new methods with the parameter IAsyncResult. One called AcceptCallback and one called ReceiveCallback.

        public void AcceptCallback(IAsyncResult result)
        {
        }
        public void ReceiveCallback(IAsyncResult result)
        {
        }

Then we will create a new class called SocketClient, but so far the class should be empty.

    public class SocketClient
    {
    }

Now the BeginAccept method should look like this:

        public void BeginAccept()
        {
            Socket.BeginAccept(new AsyncCallback(AcceptCallback), new SocketClient());
        }

The first parameter we're seing is a new AsyncCallback, where we call the AcceptCallback method, because that's where will handled accepted connections. Next thing is what object our callback should handle and in this case it will be our socket client.

So far our socket wrapper should look like this:

    public class ServerSocket
    {
        public int BufferSize;
        public System.Net.Sockets.Socket Socket;
        public int Port;

        public void Listen()
        {
            Socket = new System.Net.Sockets.Socket(
                System.Net.Sockets.AddressFamily.InterNetwork,
                System.Net.Sockets.SocketType.Stream,
                System.Net.Sockets.ProtocolType.Tcp);
            Socket.Bind(GetEndPoint());
            Socket.Listen(100);
        }
        public void BeginAccept()
        {
            Socket.BeginAccept(new AsyncCallback(AcceptCallback), new SocketClient());
        }
        public System.Net.IPEndPoint GetEndPoint()
        {
            return new System.Net.IPEndPoint(System.Net.IPAddress.Any, Port);
        }

        public void AcceptCallback(IAsyncResult result)
        {
        }
        public void ReceiveCallback(IAsyncResult result)
        {
        }
    }

Now we have finished our listener and can start to handle actual connections and data. Now let's work on the AcceptCallback method. First thing we do is making a try and catch block in case our event actually fails to get handled proper.

            try
            {
            }
            catch
            {
            }

Next thing is we will get the object from our async result, which should be the SocketClient, but we will make a method to get it and it should return the type SocketClient. The parameter should be IAsyncResult.

        public SocketClient Get(IAsyncResult result)
        {
        }

Now what we try in this method is converting the result to a SocketClient and if it fails we return null. We can do this using either checks if the type of the result is a SocketClient or simply use a try/catch.

I'm just using a try/catch block.

        public SocketClient Get(IAsyncResult result)
        {
            try
            {
                return result.AsyncState as SocketClient;
            }
            catch
            {
                return null;
            }
        }

I don't wanna explain the code, because nothing to explain really. If you know C# as told in the beginning, then you should understand this very simple method.

Now what we do is calling this method in our AcceptCallback to get the SocketClient.

        public void AcceptCallback(IAsyncResult result)
        {
            try
            {
                SocketClient Client = Get(result);
            }
            catch
            {
            }
        }

Now we will look into our SocketClient, because we will work with that and our wrapper now.

First thing we have to do is making a field as a byte array called Buffer. Which is the packet we're receiving from the client.

public byte[] Buffer;

Then I will make a new property field to get the length of the buffer, but it's not neccessary, but I like to make things simple.

public int BufferLen
        {
            get
            {
                return Buffer.Length;
            }
        }

Then we will add another field for the client socket.

public System.Net.Sockets.Socket Socket;

Then we add a field as a bool to check if the socket is connected. We call Socket.Connected within this property.

        public bool Connected
        {
            get { return Socket.Connected; }
        }

The last thing for now is a string property field to get the IPAddress of the connected client.

We do that converting the RemoteEndPoint to an IPAddress and then returning the Address as a string.

        public string IP
        {
            get
            {
                try
                {
                    return (this.Socket.RemoteEndPoint as System.Net.IPEndPoint).Address.ToString();
                }
                catch { return "127.0.0.1"; }
            }
        }

Now we gotta create 2 methods.
A Disconnection method and an EndAccept method.
The disconnection method should call Socket.Disconnect() and we will put the reuse to false, because otherwise we're not allowed to reuse the socket. I don't want to go in details with it.

public void Disconnect()
        {
            Socket.Disconnect(false);
        }

The EndAccept method will take 2 parameters. The first parameter is just a socket parameter and the second parameter is IAsyncResult.
Within this method we will set our client socket using Socket.EndAccept from the socket in the parameter and the async result.

        public void EndAccept(System.Net.Sockets.Socket socket, IAsyncResult result)
        {
            Socket = socket.EndAccept(result);
        }

Now let's get back to our socket wrapper, where we're going to use these methods and fields.

Look at the AcceptCallback again and the next thing we do is creating the buffer using the buffersize in our wrapper.

Client.Buffer = new byte[BufferSize];

Now we will make a new method as a bool called Accepted with the parameters SocketClient and IAsyncResult.

We will make a try/catch block and in the catch we put a return false, because then it's not accepted. In the try block we will call the EndAccept method from the client in the parameter. Then we return it true after.

        private bool Accepted(SocketClient Client, IAsyncResult result)
        {
            try
            {
                Client.EndAccept(Socket, result);
                return true;
            }
            catch
            {
                return false;
            }
        }

Now we will look into the socket handlers. We will make a new class called SocketEvents. Make a parameter within the socket wrapper to it.

public SocketEvents Events;

Make 3 delegates above the socket events class.
2 with the parameter SocketClient only and they should be called OnConnection and OnDisconnection, then another one with 2 parameters SocketClient and a byte array as Buffer called OnReceive.

public delegate void OnConnection(SocketClient Client);
    public delegate void OnDisconnection(SocketClient Client);
    public delegate void OnReceive(SocketClient Client, byte[] Buffer);

Now within our class we add 3 fields for these delegates.

public OnConnection Connection;
        public OnDisconnection Disconnection;
        public OnReceive Receive;

Now in our AcceptCallback we will make a bool called accept. We make a check if accept is equal to the Accepted method. If it's true, then we invoke the Connection event and then later we check if it's accepted and we call the next method we will make called BeginReceive, but right before that we call BeginAccept again, but make a method with the parameter SocketClient called BeginReceive.

        public void BeginReceive(SocketClient Client)
        {
        }

Within this method we will call Socket.BeginReceive() and it's done with 6 parameters.

First parameter is the buffer from our Client.
Next parameter is how many buffers and it should just be 0.
Next parameter is the max buffer size and we already specified that as a parameter.
Next parameter is socket flags and we don't want any, so choose None.
Now we need an AsyncCallback and it's of course to the ReceiveCallback.
The last thing is an object we want to send through the async event and it's the client.

Client.Socket.BeginReceive(Client.Buffer, 0, BufferSize, System.Net.Sockets.SocketFlags.None, new AsyncCallback(ReceiveCallback), Client);

Our final AcceptCallback should look like this:

        public void AcceptCallback(IAsyncResult result)
        {
            try
            {
                SocketClient Client = Get(result);
                Client.Buffer = new byte[BufferSize];

                bool accepted;
                if (accepted = Accepted(Client, result))
                    Events.Connection.Invoke(Client);

                BeginAccept();

                if (accepted)
                    BeginReceive(Client);
            }
            catch
            {
            }
        }

Now we will go to the next step. Working with the ReceiveCallback and handling data.

Okay you can either use memcpy or Buffer.BlockCopy later, but I will just use Buffer.BlockCopy. However using msvcrt would be more efficient.

Well the first thing we do in the ReceiveCallback is calling the Get method again. Then we make a check if the client is not null. If it's null we call the disconnect event.

            SocketClient Client = Get(result);
            if (Client != null)
            {
            }
            else
            {
                Events.Disconnection.Invoke(Client);
            }

Now we make a try/catch block. In both the try and catch we call the disconnect event as well. You will see later why.

                try
                {
                    Events.Disconnection.Invoke(Client);
                }
                catch
                {
                    Events.Disconnection.Invoke(Client);
                }

Now we will work above the disconnection in the try block. It's important we ain't working under it.

Now we check if the client is connected calling the field from before. Client.Connected.

                    if (Client.Connected)
                    {
                    }

Now we will make a variable as a SocketError.

System.Net.Sockets.SocketError error;

Now let's look back at our SocketClient, because we will make another method called EndReceive. The method should be an int and it should have 2 parameters. One for IAsyncResult and an out parameter for SocketError.
We will return Socket.EndReceive in it and basically what it does is returning the length of the buffer and giving us a callback on how it all went. We will only use Socket.Success tho.

        public int EndReceive(IAsyncResult result, out System.Net.Sockets.SocketError SE)
        {
            return Socket.EndReceive(result, out SE);
        }

Now what we do in the ReceiveCallback is making an int variable called BufferLength, which will be the length of our buffer, but mke it equal to the EndReceive method.

int BufferLength = Client.EndReceive(result, out error);

Now check if error is success.

if (error == System.Net.Sockets.SocketError.Success)
{
}

Now we check if the BufferLength is above 0.

if (BufferLength > 0)
{
}

Now make a new byte array using the BufferLength variable.

byte[] rBuffer = new byte[BufferLength];

Now we call Buffer.BlockCopy.

Buffer.BlockCopy(Client.Buffer, 0, rBuffer, 0, Client.BufferLen);

If you want to know more about it, read up on it here:


Now what we do is invoking the receive event and then calling beginreceive again. When that's done we just put a return to avoid the disconnection.

                                Events.Receive.Invoke(Client, rBuffer);
                                BeginReceive(Client);
                                return;

This should be the final ReceiveCallback.

        public void ReceiveCallback(IAsyncResult result)
        {
            SocketClient Client = Get(result);
            if (Client != null)
            {
                try
                {
                    if (Client.Connected)
                    {
                        System.Net.Sockets.SocketError error;
                        int BufferLength = Client.EndReceive(result, out error);
                        if (error == System.Net.Sockets.SocketError.Success)
                        {
                            if (BufferLength > 0)
                            {
                                byte[] rBuffer = new byte[BufferLength];
                                Buffer.BlockCopy(Client.Buffer, 0, rBuffer, 0, Client.BufferLen);
                                Events.Receive.Invoke(Client, rBuffer);
                                BeginReceive(Client);
                                return;
                            }
                        }
                    }

                    Events.Disconnection.Invoke(Client);
                }
                catch
                {
                    Events.Disconnection.Invoke(Client);
                }
            }
            else
            {
                Events.Disconnection.Invoke(Client);
            }
        }

Now our socket wrapper is basically done. Nothing Conquer specified things yet, but that's what to come now. We will look at how the source could be structured and how you can start off with the auth server, but I will not help you coding the server and everything in it. There is a plenty of sources and other things available for you and it shouldn't be a problem continue from this.

Go to program.cs, because we will create our connection now and the handlers for our auth server.

First thing we do is creating our sockets. Basically we just create the events calling the delegates and then making our own static methods. Then we just call the Listen() within our wrapper.

            ServerSocket socket = new ServerSocket();
            socket.Events = new SocketEvents();
            socket.Events.Connection = new OnConnection(Auth_Connection);
            socket.Events.Disconnection = new OnDisconnection(Auth_Disconnection);
            socket.Events.Receive = new OnReceive(Auth_Receive);
            socket.BufferSize = 1024;
            socket.Port = 9959;
            socket.Listen();

And the methods.

        static void Auth_Connection(SocketClient Client)
        {
        }
        static void Auth_Disconnection(SocketClient Client)
        {
        }
        static void Auth_Receive(SocketClient Client, byte[] Buffer)
        {
        }

In Auth_Connection you handle all the connections from client to server.
In Auth_Disconnection you handle all disconnections from server.
In Auth_Receive you handle all datas from the client, this is also where the packethandler should be called. This is basically the packethandler, but the reason you split it to a new method is for a better structure, because it does nothing performance wise.

Basically you do same for Game Server.

I will not really provide much more information, because it's now up to yourself to study, but now you have a socket system to work of to make your own server from scratch.

Other threads you should read:






I think that's it. I'm aware there might be a few grammar mistakes, but English is not my main language. I hope this will be useful for some and if you got questions feel free to ask.

Please don't ask how to fix errors or ask for codes here.

Good luck .

Then to have your server working fully, you must have Arco bless your server with Holy Water

[Arco.]

You forgot last part.

[F i n c h i]

Badass guide!

[BaussHacker]

Thank you. Took me about 4-5 hours to write.

[MegaArcherZGX]

<3ing your cookie Guide,Excellent,Thank you xD

[BaussHacker]

Originally Posted by MegaArcherZGX

<3ing your cookie Guide,Excellent,Thank you xD

Thank you, glad you like it.

[pro4never]

this thread makes it hard




































































to ignore your coding prowess

[BaussHacker]

Originally Posted by pro4never

this thread makes it hard
to ignore your coding prowess

I thought it was something else it made hard.

[jackpotsvr]

Originally Posted by BaussHacker

I thought it was something else it made hard.

It should be.

+2,147,483,647

On-Topic
Very nice guide! Read most of it yet. I guess this will get me on the road ..
Imma start on a source tomorow, now i've to learn exam =]
Youve got my thanks.

[.Beatz]

Good guide! Hope this spurs people on to writing their own sources

[BaussHacker]

Originally Posted by jackpotsvr

It should be.

+2,147,483,647

On-Topic
Very nice guide! Read most of it yet. I guess this will get me on the road ..
Imma start on a source tomorow, now i've to learn exam =]
Youve got my thanks.

Thank you a lot and I hope it will help you

Originally Posted by .Beatz

Good guide! Hope this spurs people on to writing their own sources

Indeed. I hope it will become helpful.

[miketheking]

contains most of the stuff i didnt know how to code i think i ll start coding my own source when i have some time thnx alot

[Lateralus]

ok man this is good but i ned halp with source 5375 null reference exception when i start server





- Good thread though, seriously. Some solid general information about creating a simple socket system.

[BioHazarxPaul]

wow thats a hell of a guide, one of the first times i was like yah i really dont feel like reading all that right now..

[BaussHacker]

Originally Posted by miketheking

contains most of the stuff i didnt know how to code i think i ll start coding my own source when i have some time thnx alot

That's good. Good luck with it.

Originally Posted by Lateralus

ok man this is good but i ned halp with source 5375 null reference exception when i start server

You need to code net framework.

Originally Posted by Lateralus

- Good thread though, seriously. Some solid general information about creating a simple socket system.

Thank you a lot bro

Originally Posted by BioHazarxPaul

wow thats a hell of a guide, one of the first times i was like yah i really dont feel like reading all that right now..

Coming up with a part 2 soon, if I get time for it. This is only the sockets.