How to make Game Server and Client Configuration in Sync

In multiplayer games, one of the most complex issues is to keep all player’s states in sync with the server state. While there are a few good articles on this topic on the internet, some details are missing here and there, which may be confusing for beginners in the field of game programming.

Here I highlight how to do game server and client configuration in sync, as well as discuss what game server and client configuration is. We will also provide some tips on how to keep the game server and client configuration in sync.

A multiplayer game is no exception, however, the complexity is higher due to the interaction between multipler players.

Let’s use the classic Snake Game as an example:

Assume we use server-client settings. The core game logic works like this

• Read user inputs which can be one of [←, ↑, →, ↓], to change the direction of the snake.
• Apply user input if any; this changes the direction of the snake.
• Move the snake by 1 unit space
• Check if any snakes bump into the enemy/wall/self, then proceed to remove them from the game.
• Repeat!

This logic will be ran at a fixed interval on the server side. As demonstrated below, each loop is a called a frame or a tick

The most simple client will listen to the server update and render every frame received to player.

Lockstep State Update

The Concept

To make sure all clients are in sync, the simplest way is to let client send update to server in a fixed interval, and for the purpose of explaining this to you in a way that makes sense, let’s say make that every 30ms. The update would contains user input, which can also represent no user input.

Once the server gathers input from ‘all user’ it can then proceed with next tick using those inputs.

The image above demonstrates how one client interacts with the server. I hope this problem is obvious to you as it is to me, as the client will remain idle from T0 to T1, waiting for server update to proceed. The latency can range from 50ms to 500ms, depending on network quality, and human’s in today’s day and age will notice any delay over 100ms, so freezing the user interface for 200ms can be a big problem for some games.

This is not the only issue with the lockstep approach.

This image is slightly more complicated, showing multi-client interaction with server. You can see that client B has a slower network connection, and although both A and B send input to the server at T0, the update from B reaches the server at T2 instead of T1, so the server only proceeds once it has receiveed all of the updates which is T2.

What does this mean?

the latency of the game is now the latency of the most lagged player

We’re punishing all players because one of them is lagging. So eventually all players will leave your game ….

Now, this isn’t to say that there’s a possibility that client B might be disconnected, thus blocking the server until the connection timeout.

Discussion

There are some problems including 2 of which we just mentioned :

• Client will not be responding until it has received a state update from the server (horrible user experience).
• Game responsiveness depends on the most lagged players. Playing with a friend with DSL connection? Have Fun!
• The connection would be really chatty: clients need to send some useless heartbeat data regularly so that server can confirm it has all of the information needed to step forward, which is not efficient.

First of all, certain kind of games are immune to these problems, most Turn-based game actually use some variant of such model, as client are supposed to wait.

For slow-paced game, small amount of delay is acceptable too. Farm Ville makes for a good example.

Another great example is Chess, where 2 players take their own turn, assuming each turn takes 10 secs

• Users are expected to wait for each other for 10 secs. They wait.
• 2 players take turns alternatively, so one lagged player does not affect the other player
• Each turn takes on average 5 secs (1 request every 5 secs is fine).

But for fast-paced games? Like all FPS, all of these problems make lockstep approaches not suitable for them. We will see how we can solve these problems in the rest of articles.

Client Predictions

Let’s first solve the problem of user-responsiveness. The Game responds after 500 millis after a user presses a key, destroying the gaming experience.

How to solve this problem?

The Concept

Some of you might have already have the answer; instead of waiting on a server update, the client can actually emulate the game by running game logic locally (ie. on the client’s machine).

Let’s assume to produce game state at Tn, we need state at Tn-1 and all user input at Tn-1.

The idea is simple; let’s have a fixed update rate, which in this example is 1 unit of time

The client sends input to the server at T0 to emulate the game state at T1, so the client can then render the game without having to wait for the state update from the server, which only arrives at T3.

This approach only works if the following takes place:

• The game state updates logic are deterministic, ie. no randomness, or in some way, referentially transparent, so that the server and the client produce the same game state given the same input.
• The client has all of the information required to run gaming logic
• Note: 1 is not always true, but we can try to make it as similar as possible, and ignore the small differences, ie. floating points computation of different platform, use the same seed for pseudo-random algorithm.

2 is also not always true. I’ll explain…

In the image above, Client A still tries to emulate the game state at T1 using the information it has from T0, but Client B has also submitted input at T0, which Client A is not aware of.

This means that client A’s prediction of T1 will be wrong. Luckily, since Client A still receives the state of T1 from server, the client has the chance to correct it’s mistake at T3.

Client’s side needs to figure out if the previous emulation is correct, and how to resolve the conflicts.

The resolution of conflicts is normally called Reconcilation.

Implementation of Reconcilation varies depending on use case, I’ll show a simple one, which we just throw away our prediction and replace it with the correct state from server.

• The client needs to maintain 2 buffers; one for predictions and one for user input. This can then be used to compute predictions. Remember, State Tn is computed using State Tn-1 and Input Tn-1 which will be empty at first.

• When the player presses an arrow key, the input in stored in the InputBuffer, and the client will also produce predictions, which is then used to render the view. The prediction is stored in PredictionBuffer.

• When the server State0 is received and doesn’t match with the client’s Prediction0, we can replace Prediction0 with State0, and recompute Prediction1 using Input0 and State0.

• After reconcilation, we can safely removed State0 and Input0 from the buffer. Only then can we confirm it’s correct.

Note: this reconcilaton comes with a drawback. There might be glitches in view if the server state and the client prediction differ too much.

How I Do the Game Server and Client Configuration in Sync

Keeping game files in sync is critical for the smooth running of your game. By keeping them on your own computer, you eliminate the risk of corruption or loss. I also use a program called Team Viewer to make the game server and client configuration in sync.

This free and easy-to-use program has many great features, like the ability to share screens and files between computers. Team Viewer makes the task of game server and client configuration in sync a breeze, so you can focus on the game itself and not on paperwork.

How do multiplayer games sync their state?

Multiplayer games require players to connect to each other and share states. This process is often done through the use of game servers. Game servers are responsible for retrieving the current state of all player entities and broadcasting it to all connected clients. This ensures that games always maintain sync between players, no matter where they are in the world or what time it is.

Synchronizing game state between game server and clients

Game state synchronization is a crucial part of making your games run smoothly. Without it, players might experience game-related issues. The game state needs to be synchronized whenever the game is started or restarted, and there are various synchronization methods that can be used. For example, game servers and clients may use different configuration files, so it’s important to sync them properly. Make sure to keep your game state synchronized between game server and clients to avoid any issues.

What is game server and client configuration in sync?

Maintaining game server and client configuration in sync is important for ensuring a smooth gaming experience for all players. This synchronization process can be done in a variety of ways, such as synchronizing game files or using a dedicated server for gaming purposes. It’s also vital to keep track of game server and client latency so that the experience on different machines remains the same.

If you’re not sure how to configure game server and client configuration in sync, don’t worry – there are numerous resources available online that can help you out. In the meantime, make sure to check in on your game server and client latency regularly to make sure everything is running smoothly.

How can we keep game server and client configuration in sync?

Keeping game server and client configuration in sync can be a challenging task. There are a few methods that you can choose from, but it’s important to decide on the right one for your needs.

One way is to use a plugin or script, which can be installed on both the game server and client. Make sure you test it first to avoid any surprises. Another option is to use a game lobby service. These services keep game server and client configuration in sync for you, making it easier to manage.

Keeping your game servers and clients running smoothly all season long is vital. By following these simple steps, you’ll be on your way to achieving this goal. First and foremost, we strongly recommend using a GameSync solution for optimal performance and reliability.

Implementing game synchronization between clients and server

I have seen a lot of games that allow players to customize their settings for their clients. This is usually done through an in-game menu or by accessing a configuration file.

The problem with this approach is that the server and clients will not always be in sync. When setting up your game, you should consider making sure all of your settings are identical on both the server and the clients. If they aren’t, there could be serious problems when trying to play together (in which case it would probably be better if you didn’t have multiplayer at all).

The problem with multiplayer games

It is a common problem for multiplayer games to have the clients and the server out of sync with each other. In such case, it becomes impossible to play or run any game as both clients and servers are not in sync. The issue also causes issues with respect to networking and data synchronization.

The solutions available are not very satisfying either because they require significant time to configure, code changes or changes in client libraries/SDKs etc. But there are some solutions that we can use which don’t require significant time to configure or change anything (examples mentioned below). They work by having an additional copy of the same state on both sides so that all clients get an identical copy of the game state.

The solutions available are:

1) Using a dedicated game server for multiplayer games. This option is more expensive and requires more resources, but it does provide an extra layer of security and reduces the chances of the clients and server going out of sync.

2) Synchronizing state using a synchronization solution like Game Sync. This solution is free to use, but you will need to have a subscription plan or pay for services.

3) Configuring your client software to use local servers instead of connecting to the global servers operated by the game publisher/developer (or some other third party). While this solution is not always possible or desirable, it can be a useful workaround in some cases.

4) Configuring your client software to use an external proxy server that will act as an intermediary between the game publisher/developer’s servers and your client. This approach has the advantage of being relatively easy to set up, but it does require some extra configuration on the part of the user.