Jump to content

  • Log In with Google      Sign In   
  • Create Account


Network Game Design / Architecture Question


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
7 replies to this topic

#1 lakedoo23   Members   -  Reputation: 127

Like
0Likes
Like

Posted 02 June 2014 - 11:11 AM

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?



Sponsor:

#2 ferrous   Members   -  Reputation: 1921

Like
1Likes
Like

Posted 02 June 2014 - 11:58 AM

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.



#3 lakedoo23   Members   -  Reputation: 127

Like
0Likes
Like

Posted 02 June 2014 - 01:30 PM

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



#4 lakedoo23   Members   -  Reputation: 127

Like
0Likes
Like

Posted 02 June 2014 - 01:43 PM

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.



#5 lakedoo23   Members   -  Reputation: 127

Like
3Likes
Like

Posted 02 June 2014 - 05:54 PM

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

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



#6 0BZEN   Crossbones+   -  Reputation: 2013

Like
2Likes
Like

Posted 05 June 2014 - 04:26 AM

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.

- Host receives the client inputs+prediction+SQN. 
- host calculate the real player position, using those inputs.
- host then compares the player location with the client prediction.
- if a difference is detected (within an arbitrary margin of error), the host sends a correction packet back to the client (containing corrected_position+SQN).
- client receives the correction packet.
- client looks up the original input+prediction packet in his buffer, using the SQN. 
- client substitutes the predicted position with the corrected position.
- client then replays his input stack from that point onwards, to adjust his current prediction with the server correction.
 
Example : Counterstrike, Quake 3, Unreal Tournament, Team Fortress...
Advantages : Nullify the input latency, by allowing the client to locally predict the effect of the player's inputs. 
Disadvantages : client will experience jitter and rubber-banding when a discrepancy between the client prediction and the server calculation is detected (i.e. two players jumping on top of each other). 
 
looksy here.

Everything is better with Metal.


#7 lakedoo23   Members   -  Reputation: 127

Like
0Likes
Like

Posted 09 June 2014 - 08:07 AM

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.


                                InputCommand iCommand = new InputCommand();
 
                                msg.ReadAllProperties(iCommand);
 
                                Entities[iCommand.ID].ApplyInputCommand(iCommand);
 
                                Clients[iCommand.ID].LastProcessedInput = iCommand.InputSequenceNumber;
 

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.

 

http://youtu.be/5VADFXXjI60

 

 

Attached Files



#8 Kylotan   Moderators   -  Reputation: 3338

Like
0Likes
Like

Posted 10 June 2014 - 05:59 AM

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.






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS