Don’t kid yourself.  Writing a multiplayer game that runs over the Internet can be tricky. If you are using Unity you have the entire .NET network library at your disposal. Simply making a TCP connection or sending UDP packets is pretty trivial. Why on earth would you bother using someone else’s library?

The debate between TCP and UDP for MMOs is as strong as ever and I’m certainly not going to talk about it here. For Ghostees, I am using UDP and the Lidgren library. It’s open source, free but best of all it solves a lot of the issues revolving around using UDP as your transport.

The types of things you can encounter with UDP can be a pain but since it is low level, you get incredible flexibility and performance. Think of UDP as a message passing protocol as opposed to TCP which is a stream based protocol.  TCP will ensure that your data makes its way across the trenches of the internet in tact and in order.  UDP on the other hand makes no guarantees.  Some messages may go missing.  You might even get two of the same or get messages out of order. Tricky stuff.  Lidgren takes care of all that stuff for your but only where you want it.  It will definitely let you shoot yourself in the foot also.

The (very) Basic Server

By the way, Lidgren builds in Mono so you can run your server on Linux. I’m pretty sure it works but I haven’t done enough testing to say 100% at this point and I’m pretty much a Windows guy. Enough yapping, lets get coding.

Start a new project for your server and create your server class. I prefer to add the Lidgren project to my solution but either way, add a reference to Lidgren.Network.

Your class will need two private members to start: NetServer and NetBuffer, both in the Lidgren.Network namespace.

class MyServer
{
    private NetServer server;
    private NetBuffer buffer;

    public MyServer()
    {
        var config = new NetConfiguration("hello-world");
        config.Port = 42948;

        server = new NetServer(config);
        buffer = new NetBuffer();
        server.Start();
    }
}

Lets go through this quickly.  On line 3 the NetServer is the class from Lidgren that will listen for incoming traffic.  The NetBuffer on the next line is what we read our messages into.  We can reuse it so it is declared as a class member.

We create an instance of NetConfiguration to pass configuration information into the NetServer constructor. NetConfiguration takes a single string argument that is our application identifier.  This can be anything you like as long as both the client and server use the same string.

DOH! you wouldn’t believe how many times I’ve had projects where I change the application identifier on either the client or server but not the other and then subsequently spend w-a-a-a-y too long trying to figure out why I can’t connect.

On line 9 I set the port that the server will listen on for incoming messages. Choose pretty much any number you like that is less than 65535 as long as it doesn’t conflict with another application listening on the same port. Only one port per network card can be in use at any time. You are best off choosing a number somewhere over 32768 to avoid “well known” ports.

Lastly, we just call Start() on the server to have it bind to the port and buffering messages.

The Pump

When the server receives a message, after some processing it places it into a queue. This all happens behind the scenes in another thread. You need to write code to retrieve them.  I usually have a single thread reading and distributing incoming messages and you might as well make it your main thread.  Add this method to your server class:

    public void Process()
    {
        NetMessageType type;
        NetConnection source;

        while (server.ReadMessage(buffer, out type, out source))
        {
            HandleMessage(buffer, type, source);
        }
    }

Your server host, whether its a console application or Windows service, will be responsible for pumping the messages by calling Process. Avoid the temptation of over complicating your server with a thread for the message pump. You won’t see any speed or efficiency increase putting more threads in here.

Each time through the while loop, the server will hand you one message. It will also give you the type of message and which client connection it came from.

The Mail Room

Now we need to decide what’s in the message we just got, and what to do with it. You will receive messages not only from your connected clients but also from Lidgren.  Lets cover Lidgren’s messages first.

Among the several types of messages Lidgren can send you, debug messages are one of the two basic ones you definitely want to handle. They will simply be strings that you can output to the console or debug stream.

Another  message you want to handle is the StatusChanged message. This message tells you when someone has connected or disconnected. I’ve created another method called HandleMessage which is where I will switch on the message type.

The last of the most basic messages is the Data message. These are messages sent to you from your connected clients.

I would suggest you throw an exception or at least log a warning if a message comes through that you didn’t handle. I’ve caught many weird bugs this way simply because I wasn’t aware I was receiving a BadMessageReceived or other message.

    public event Action<NetConnection> ConnectionStatus;

    private void HandleMessage(NetBuffer buffer, NetMessageType type, NetConnection source)
    {
        switch (type)
        {
            case NetMessageType.DebugMessage:
                {
                    Debug.WriteLine(buffer.ReadString());
                    break;
                }

            case NetMessageType.StatusChanged:
                {
                    if (ConnectionStatus != null)
                        ConnectionStatus(source);
                    break;
                }

            case NetMessageType.Data:
                {
                    if (DataReceived != null)
                        DataReceived(source, buffer);
                    break;
                }

            default:
                throw new NotImplementedException("Message type not handled: " + type.ToString());
        }
    }

You can see in the snippet above on the first two lines, I’ve declared two public events. Other classes in your server will want to know when a client comes and goes so its wise to publish this information. The other event gets fired when we receive data from clients.

HandleMessage works its magic by simply switching on the message type. In the case of a debug message, we simply write it to the debug stream.  In the case of a ConnectionStatus or Data message, we fire the appropriate events.

OK so here is the code so far:

using System;
using System.Diagnostics;
using Lidgren.Network;

namespace BakedOn
{
    class MyServer
    {
        private NetServer server;
        private NetBuffer buffer;

        public event Action<NetConnection> ConnectionStatus;
        public event Action<NetConnection, NetBuffer> DataReceived;

        public MyServer()
        {
            var config = new NetConfiguration("hello-world");
            config.Port = 42948;

            server = new NetServer(config);
            buffer = server.CreateBuffer();
        }

        public void Process()
        {
            NetMessageType type;
            NetConnection source;

            while (server.ReadMessage(buffer, out type, out source))
            {
                HandleMessage(buffer, type, source);
            }
        }

        private void HandleMessage(NetBuffer buffer, NetMessageType type, NetConnection source)
        {
            switch (type)
            {
                case NetMessageType.DebugMessage:
                    {
                        Debug.WriteLine(buffer.ReadString());
                        break;
                    }

                case NetMessageType.StatusChanged:
                    {
                        if (ConnectionStatus != null)
                            ConnectionStatus(source);
                        break;
                    }

                case NetMessageType.Data:
                    {
                        if (DataReceived != null)
                            DataReceived(source, buffer);
                        break;
                    }

                default:
                    throw new NotImplementedException("Message type not handled: " + type.ToString());
            }
        }
    }
}

In the next part, I will show you how to create a client that will work within Unity. It’s not tough at all. And if you deep-tech readers are concerned what we have done here is far too simplistic, not to worry. We will be going much deeper. After the client, we will start talking about message formats, serialization and message envelopes.

If this topic is useful or interesting to you, shoot me a quick comment and let me know so I’ll keep going with it.

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• share via Reddit
• Share with Stumblers
• Tweet about it
• Subscribe to the comments on this post

There is a lot of discussion on whether you can use threading or asynchronous sockets with Unity3D and with the web player in particular.

I’ve created this sample project to demonstrate how this is done.  You’ll see above that when you run it, the project attempts to make several asynchronous connections to web servers and download their default page.

There are a couple of basic things you should watch out for:

1. Calls to Unity object or the UnityEngine API must be done on the main Unity application thread. You will need to martial values back to that thread. In this example, you’ll notice I don’t update the GUIText text value directly.  I update my own internal status string and only update the GUIText during an Update( ) call.
2. You need to shut down your socket and thread operations when OnApplicaitonQuit( ) is called. Exceptions may be thrown on any asychronous callback and you need to be sure to catch and handle these.

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• share via Reddit
• Share with Stumblers
• Tweet about it
• Subscribe to the comments on this post

The server culls down how many entities the game client will see so not to overload it. On the server I have masks that are used to categorize and prioritize what needs to be seen on any client. Click the video to head on over to youtube.com and watch it in HD.

As of this writing, I’ve had the server up to 400 concurrent connections @ 50% cpu but in the next build I think I can double that performance. There are many optimizations I know I can do at this point. Load has a lot to do with the number of entities that can see each other at any one time which corresponds to the number of messages I need to generate.

The chart below is with 95 connected entities that can all literally see each other.

As it is in that video, every entity can see every other entity within a vision radius. To achieve the 400 connections, I reduced the vision radius of NPCs and left the larger radius for actual players. This is where the masking comes in. NPCs don’t really care about a lot of entities. They may not care about any entities of their same race for instance. They may only care about players or perhaps even entities of a race they are at war with. The mask is simply a set of flags that determine who they care about seeing. Combine this with an appropriate vision radius. For instance, NPC’s don’t have to see as far as players. They only need to see as far as their maximum aggro radius. On the other hand, players need to see further so that characters don’t magically warp in.

World design also plays a part in controlling this. If you can see a great distance in front of you at any one time, you could potentially see a lot of entities. Have a look carefully at the design of Orgimmar or Iron Forge in World of Warcraft. Also think about how dungeon instances are designed. These areas are designed either to manage a high density of players or to keep game latency down to a minimum by carefully managing your visual distance. This will keep both the client and server snappy.

If you have other ideas for managing this, I’d love to hear them. Please post a comment!

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• share via Reddit
• Share with Stumblers
• Tweet about it
• Subscribe to the comments on this post

I also worked on projecting zodiac effects onto a plane which was suprisingly difficult. I managed to find a shader that does this [need link!].

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• share via Reddit
• Share with Stumblers
• Tweet about it
• Subscribe to the comments on this post

I wired up the foundation for server audited and filtered chat. Essentially when a player sends a chat message, it routes through the server first to be filtered. The server can modify or completely reject the text. If the text passes the server gauntlet, the server drops the text to the auditor service and then broadcasts the message to all applicable players.

Next I needed to take the World View class and create various layers for the visuals to appear on. Actually, two layers were already there (background and content layers) but I needed to add an overlay layer and made the decision to bundle them together in a unifying container. This caused some wierd offset calculation issues that I won’t bother explaining but caused me an hour or two of head scratching to figure it out. The talk bubbles show up on the overlay layer so they won’t be obscured an voila, I have chat.

I’m using the new Flex Builder 3 as my Flash development environment. There are some good bug fixes but actually not a ton of new stuff except the profiling capabilities. This is the sole reason I upgraded. I gave these features a whirl and found some nice optimizations.

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• share via Reddit
• Share with Stumblers
• Tweet about it
• Subscribe to the comments on this post