Hello All,

Currently I am developing a 2D multiplayer game and have an authoritative server setup, where the client is for the most part pretty dumb, the client will take inputs from the player and will display what the server tells it too. The server sends out world state data every 20 msec and this seems to work well, but I have seen alot of postings about smoothing out movement using interpolation algorithms and I am wondering if this type of setup will be needed, since I am just taking in pretty simple keyboard commands (up, down, left, right) from the player and moving their character accordingly based on velocity I am not sure how / why you would smooth something like that out?

Hello All,

Currently I am developing a 2D multiplayer game and have an authoritative server setup, where the client is for the most part pretty dumb, the client will take inputs from the player and will display what the server tells it too. The server sends out world state data every 20 msec and this seems to work well, but I have seen alot of postings about smoothing out movement using interpolation algorithms and I am wondering if this type of setup will be needed, since I am just taking in pretty simple keyboard commands (up, down, left, right) from the player and moving their character accordingly based on velocity I am not sure how / why you would smooth something like that out?

Try a test where you have higher latency, due to the internet being what it is, one would be pretty lucky to get 20 ms all the time. If Guy A hits Left, it might take 100 ms for it to reach the server, and have the server process it and then send the position back to the player might take another 100 ms. Now you probably sent a timestamp to the server as to when they hit left, so you might move him on the server as if he hit left 100 ms ago. Then Guy A recieves where his position was on the server, but it's timestamped from 100 ms ago. So what's happening on Guy A's screen? Are you just not moving him at all until he receives the server updates? In which case, for 200 ms nothing happened on his screen, and then when got the message, he jumps to where he would be at 100ms. Which is of course also 100 ms out of date.

Hmm very good point, I am kind of working in a vacuum right now and definitely need to take this into consideration. Thanks!

Any suggestions on 2D networked game examples out there, I have only found a hand full and they didnt really have any code to deal with lag between server / client.

So I found a pretty good article on this subject incase anyone else is interested.

http://www.gabrielgambetta.com/fpm1.html

The simple way :

- Client sends inputs to the host.

- host processes inputs.

- host calculates the game state (positions of objects).

- host sends game state to clients.

Example : The original Quake networking (for LAN games).

Advantages : simple.

Disadvantages : lag becomes a serious issue. Round-trip latencies will make the client input laggy.

The way it is corrected :

- client reads his inputs, and calculates a local prediction of the player position.

- client sends inputs to the host, as well as his local prediction calculation. The input+prediction packet is marked with a unique number (aka Sequence Number, aka SQN).

- client also stores the input+prediction packet in a buffer.

Ok so I "tried" to implement a way to do the client side predicition and server reconciliation, I found on Gabriel Gambetta's site (http://www.gabrielgambetta.com/fast_paced_multiplayer.html). For the most part this works the only issue I see is a little jitter at the beginning of moving the character, but according to the explanation of the algorithm the movement should always be smooth no matter how much latency, I have attached the code I am using in hopes someone could point out an obvious mistake of my implementation. I'll highlight the important parts here, I am using a 1 second simulated latency with the Lidgren network library.

Server Side:

Receive the command from the client and apply the command to the target entity in this case the player. Then set the last processed input sequence number received from the client.

Shared Files (Client / Server)

In the Entity class I apply the command.

        public void ApplyInputCommand(InputCommand command)
        {

            switch (command.Heading)
            {
                case 0:
                    Y -= Velocity;
                    break;
                case 1:
                    X += Velocity;
                    break;
                case 2:
                    Y += Velocity;
                    break;
                case 3:
                    X -= Velocity;
                    break;
            }
        }

Client Side:

When the player hits the left or the right key I create a new input command and store it on the client and send a copy to the server.

        public void ProcessInput(Keys key)
        {
       
            InputCommand command = new InputCommand();
            NetOutgoingMessage msgOut = Connection.CreateMessage();
            
            if (key == Keys.Left)
            {
                command.Heading = 3;
            }

            if (key == Keys.Right)
            {
                command.Heading = 1;
            }

            command.InputSequenceNumber = _sequenceNumber++;

            command.ID = ID;
            


            msgOut.Write((byte)0x27);
            msgOut.WriteAllProperties(command);

            Connection.SendMessage(msgOut, NetDeliveryMethod.Unreliable);


            Entities[ID].ApplyInputCommand(command);


            commands.Add(command);


        } 

On the client side when the world state object comes in I do the prediction processing:

        Entities[worldStates[i].ID].X = worldStates[i].X;


        for (int j = 0; j < commands.Count; )
        {
            InputCommand pendingCommand = commands[j];

            if (pendingCommand.InputSequenceNumber <= worldStates[i].LastProcessedInput)
            {
                commands.Remove(commands[j]);
            }
            else
            {
                Entities[worldStates[i].ID].ApplyInputCommand(pendingCommand);
                j++;
            }

        }
        if (commands.Count > 0)
        {
            commands.Clear();
        }

Here is a demo, you can see the jitter is pretty bad at the beginning.

What's not clear from your code that is posted (sorry, not going to read the .zips) is exactly what data is sent from each side, and to who. If the client sends a move to the server and the server sends it back, then your code appears to apply that movement twice, which is not what you want. On the other hand, if the server doesn't send anything back, how would it correct anything?

But watching your video, it appears that the server is correcting something - but I can't see how that's possible given the code you've shown, which deals in input directions and not positions. If I just press the right movement button, there's no way, given the code you've shown, that it should ever be moving the object back to the left. So you've obviously got something else going on.

In theory, with one object, this should be easy to debug - log every local input you apply and also log every server input you apply, and see how they are clashing.