Advanced
Game Engine Language
#multiplayer
#networking
Multiplayer Vocabulary
6 exercises — network models, latency vocabulary (ping, RTT, jitter), tick rate and interpolation, client-side prediction and reconciliation, and lag compensation.
0 / 23 completed
1 / 23
Which network model gives one designated machine full authority over game state, with all clients sending inputs to it and receiving the resulting state back — the standard model for competitive multiplayer games?
In the authoritative server model (a specific form of the broader client-server architecture), the server holds the single source of truth for game state — it receives player inputs, runs the simulation, resolves conflicts, and sends the resulting state to all clients. Clients never directly trust each other's claims about game state, which is the standard defence against cheating.
Contrast with peer-to-peer (P2P), where clients communicate directly with each other and jointly compute game state (common in some older RTS games using lockstep) — simpler to host, but far more exploitable and harder to keep in sync with variable network conditions.
Contrast with peer-to-peer (P2P), where clients communicate directly with each other and jointly compute game state (common in some older RTS games using lockstep) — simpler to host, but far more exploitable and harder to keep in sync with variable network conditions.
2 / 23
A player reports: "My ping is 80ms but the game still feels stuttery — I think it's jitter, not raw latency." What is the difference between ping, RTT, and jitter?
Ping (informally) and RTT (round-trip time) both refer to the time for a packet to travel from client to server and back, usually reported in milliseconds — "80ms ping" means round-trip communication takes 80ms.
Jitter is different: it measures how much that latency varies from packet to packet. A connection with a stable 80ms RTT every time feels smooth; a connection that swings between 40ms and 160ms (same average, high jitter) feels stuttery and unpredictable, because game state updates arrive irregularly.
Related term: packet loss — the percentage of packets that never arrive at all, requiring retransmission or extrapolation to cover the gap. Bandwidth is a separate concept entirely — the maximum data throughput of the connection, not related to latency or jitter.
Jitter is different: it measures how much that latency varies from packet to packet. A connection with a stable 80ms RTT every time feels smooth; a connection that swings between 40ms and 160ms (same average, high jitter) feels stuttery and unpredictable, because game state updates arrive irregularly.
Related term: packet loss — the percentage of packets that never arrive at all, requiring retransmission or extrapolation to cover the gap. Bandwidth is a separate concept entirely — the maximum data throughput of the connection, not related to latency or jitter.
3 / 23
Fill in the blank: "Our server runs at 64 ______; clients interpolate between snapshots to smooth movement."
Tick rate (measured in ticks per second, or Hz) is how often the server advances and re-simulates the authoritative game state and sends updates ("snapshots") to clients — a "64-tick server" updates 64 times per second, a common standard in competitive shooters (compare to older 20-tick or 30-tick servers, which feel noticeably less responsive).
Since clients render far more frequently than 64 times per second, and network snapshots don't arrive perfectly evenly, clients typically interpolate between the last two received snapshots — smoothly blending an entity's position between "where it was" and "where it now is" — rather than snapping abruptly, which would look jittery.
Related terms: interest management / area of interest — sending each client only updates about nearby or relevant entities (not the entire world state) to reduce bandwidth, often implemented via spatial hashing (dividing the world into a grid to quickly find nearby entities).
Since clients render far more frequently than 64 times per second, and network snapshots don't arrive perfectly evenly, clients typically interpolate between the last two received snapshots — smoothly blending an entity's position between "where it was" and "where it now is" — rather than snapping abruptly, which would look jittery.
Related terms: interest management / area of interest — sending each client only updates about nearby or relevant entities (not the entire world state) to reduce bandwidth, often implemented via spatial hashing (dividing the world into a grid to quickly find nearby entities).
4 / 23
Read: "Client-side prediction: the client simulates movement locally; the server reconciles discrepancies." What problem does this solve?
Client-side prediction exists because waiting for a full round-trip (input → server → simulated result → back to client) before showing any visual feedback would make every action feel sluggish, proportional to the player's ping. Instead, the client immediately simulates the likely outcome of its own input locally (e.g. "I pressed forward, so I'll move my character forward right now") while also sending that input to the server.
When the server's authoritative simulation result arrives, if it matches the client's local prediction, nothing visible happens. If it doesn't match (e.g. the server saw a collision the client didn't predict), the client performs reconciliation — snapping or smoothly correcting to the authoritative position, ideally applying a technique like re-simulating unacknowledged inputs from the corrected state ("replay") to minimise visible jank.
This is distinct from lag compensation (used for other players' actions, e.g. hit detection), which is described in the next question.
When the server's authoritative simulation result arrives, if it matches the client's local prediction, nothing visible happens. If it doesn't match (e.g. the server saw a collision the client didn't predict), the client performs reconciliation — snapping or smoothly correcting to the authoritative position, ideally applying a technique like re-simulating unacknowledged inputs from the corrected state ("replay") to minimise visible jank.
This is distinct from lag compensation (used for other players' actions, e.g. hit detection), which is described in the next question.
5 / 23
Which term describes the technique where a server, when checking if a player's shot hit another player, "rewinds" other players' positions to how they appeared on the shooter's screen at the moment they fired — accounting for network latency?
Lag compensation addresses a fundamental multiplayer fairness problem: due to network latency, what a shooter sees on their screen (other players' positions) is always slightly in the past relative to the server's current authoritative state. If the server only checked hits against players' current positions, shooters would consistently need to "lead" their targets to compensate for the delay — feeling unfair and unresponsive.
The standard fix, often called "rewind time" or "hit detection at time of fire," keeps a short history buffer of recent positions for every entity. When the server receives a fire event, it rewinds other players' hitboxes back to where they were at the timestamp the shooter actually saw them (accounting for that shooter's latency), then checks the hit against that historical position — so "what you see is what you get" from the shooter's perspective.
This technique relies on an interpolation buffer of recent snapshots and is a standard, if sometimes controversial, feature in competitive shooters (it can cause the "I was already behind cover!" feeling for the player being shot).
The standard fix, often called "rewind time" or "hit detection at time of fire," keeps a short history buffer of recent positions for every entity. When the server receives a fire event, it rewinds other players' hitboxes back to where they were at the timestamp the shooter actually saw them (accounting for that shooter's latency), then checks the hit against that historical position — so "what you see is what you get" from the shooter's perspective.
This technique relies on an interpolation buffer of recent snapshots and is a standard, if sometimes controversial, feature in competitive shooters (it can cause the "I was already behind cover!" feeling for the player being shot).
6 / 23
A large open-world MMO server uses "spatial hashing" for interest management. What problem does this solve?
Interest management (also called an area of interest system) is essential at scale: an MMO server cannot afford to send every client full state updates about every one of thousands of entities in the world every tick — bandwidth and client-side processing would explode. Instead, each client only receives updates about entities relevant to it, typically those within some radius.
Spatial hashing is a common data structure to make "which entities are near this player?" queries fast: the world is divided into a grid of cells (hashed by coordinate), and each entity is registered in the cell(s) it currently occupies. Finding nearby entities becomes a cheap lookup of a handful of nearby grid cells, instead of checking distance against every entity in the world (an expensive O(n) scan).
This vocabulary — "interest management," "area of interest," "spatial hashing," "relevancy" — appears throughout MMO and battle-royale networking documentation and talks.
Spatial hashing is a common data structure to make "which entities are near this player?" queries fast: the world is divided into a grid of cells (hashed by coordinate), and each entity is registered in the cell(s) it currently occupies. Finding nearby entities becomes a cheap lookup of a handful of nearby grid cells, instead of checking distance against every entity in the world (an expensive O(n) scan).
This vocabulary — "interest management," "area of interest," "spatial hashing," "relevancy" — appears throughout MMO and battle-royale networking documentation and talks.
7 / 23
Senior Dev: 'Okay team, I've reviewed the PR for the new matchmaking system. The current implementation uses a simple UDP broadcast to send player positions every frame. While it's quick to implement, we're seeing significant packet loss, especially in games with high player density. I need you to refactor this to use TCP and implement a congestion control algorithm. What is the primary reason for my request?The core issue is unreliable data delivery. UDP's lack of guaranteed delivery means packets are frequently lost during periods of high network congestion, leading to dropped updates and a poor player experience. TCP, with its acknowledgements and retransmissions, provides reliable delivery – crucial for game state synchronization. Implementing congestion control further manages network traffic to prevent overwhelming the connection.
8 / 23
During a standup meeting, the Lead Systems Engineer says: "We're experiencing issues with inconsistent player interactions – sometimes actions appear to happen instantly, while other times there's a noticeable delay. This is particularly bad when players are engaging in fast-paced combat.". Which of the following best describes the technical cause of this observed behavior?
The core issue here relates to network latency. High latency means there's a delay between when an action occurs on one client and when that information is received and processed by the server, and then propagated back to other clients. This creates inconsistent perceptions – sometimes actions appear instant because the delay is small, but other times they are delayed because the overall round-trip time is higher. Option A incorrectly blames bandwidth; while bandwidth can contribute to latency, it's not the *cause* of these perceived inconsistencies.
9 / 23
During a code review of the new player prediction system, your teammate says: 'The client is predicting movement based on the last server state, but it's not updating fast enough to react to changes. We're seeing ghosting – players appear to teleport briefly when they move.' What is the primary issue causing this 'ghosting' effect?
// Simplified Code Snippet
const predictedPosition = calculatePredictedPosition(lastServerState, playerSpeed);
const actualPosition = updatePlayerPosition(predictedPosition, deltaTime); //deltaTime is often too short
The core problem is that the client is using a stale `lastServerState` to predict the player's position. Because
deltaTime (the time since the last update) is likely too short, the prediction doesn't account for the time it takes for the server to send an updated state. This results in a discrepancy between the predicted and actual positions, leading to the 'ghosting' effect – where players briefly appear to teleport due to the client trying to move based on outdated information.10 / 23
Senior Dev: 'Okay team, I've reviewed the PR for the new matchmaking system. The current implementation uses a simple UDP broadcast to send player positions every frame. While it's quick to implement, we're seeing significant packet loss, especially in games with high player density. I need you to refactor this to use TCP and implement a congestion control algorithm. What is the primary reason for my request?The core issue is unreliable data delivery. UDP's lack of guaranteed delivery means packets are frequently lost during periods of high network congestion, leading to dropped updates and a poor player experience. TCP, with its acknowledgements and retransmissions, provides reliable delivery – crucial for game state synchronization. Implementing congestion control further manages network traffic to prevent overwhelming the connection.
11 / 23
During a standup meeting, the Lead Systems Engineer says: "We're experiencing issues with inconsistent player interactions – sometimes actions appear to happen instantly, while other times there's a noticeable delay. This is particularly bad when players are engaging in fast-paced combat.". Which of the following best describes the technical cause of this observed behavior?
The core issue here relates to network latency. High latency means there's a delay between when an action occurs on one client and when that information is received and processed by the server, and then propagated back to other clients. This creates inconsistent perceptions – sometimes actions appear instant because the delay is small, but other times they are delayed because the overall round-trip time is higher. Option A incorrectly blames bandwidth; while bandwidth can contribute to latency, it's not the *cause* of these perceived inconsistencies.
12 / 23
During a code review of the new player prediction system, your teammate says: 'The client is predicting movement based on the last server state, but it's not updating fast enough to react to changes. We're seeing ghosting – players appear to teleport briefly when they move.' What is the primary issue causing this 'ghosting' effect?
// Simplified Code Snippet
const predictedPosition = calculatePredictedPosition(lastServerState, playerSpeed);
const actualPosition = updatePlayerPosition(predictedPosition, deltaTime); //deltaTime is often too short
The core problem is that the client is using a stale `lastServerState` to predict the player's position. Because
deltaTime (the time since the last update) is likely too short, the prediction doesn't account for the time it takes for the server to send an updated state. This results in a discrepancy between the predicted and actual positions, leading to the 'ghosting' effect – where players briefly appear to teleport due to the client trying to move based on outdated information.13 / 23
Senior Dev: 'Okay team, I've reviewed the PR for the new matchmaking system. The current implementation uses a simple UDP broadcast to send player positions every frame. While it's quick to implement, we're seeing significant packet loss, especially in games with high player density. I need you to refactor this to use TCP and implement a congestion control algorithm. What is the primary reason for my request?The core issue is unreliable data delivery. UDP's lack of guaranteed delivery means packets are frequently lost during periods of high network congestion, leading to dropped updates and a poor player experience. TCP, with its acknowledgements and retransmissions, provides reliable delivery – crucial for game state synchronization. Implementing congestion control further manages network traffic to prevent overwhelming the connection.
14 / 23
During a standup meeting, the Lead Systems Engineer says: "We're experiencing issues with inconsistent player interactions – sometimes actions appear to happen instantly, while other times there's a noticeable delay. This is particularly bad when players are engaging in fast-paced combat.". Which of the following best describes the technical cause of this observed behavior?
The core issue here relates to network latency. High latency means there's a delay between when an action occurs on one client and when that information is received and processed by the server, and then propagated back to other clients. This creates inconsistent perceptions – sometimes actions appear instant because the delay is small, but other times they are delayed because the overall round-trip time is higher. Option A incorrectly blames bandwidth; while bandwidth can contribute to latency, it's not the *cause* of these perceived inconsistencies.
15 / 23
During a code review of the new player prediction system, your teammate says: 'The client is predicting movement based on the last server state, but it's not updating fast enough to react to changes. We're seeing ghosting – players appear to teleport briefly when they move.' What is the primary issue causing this 'ghosting' effect?
// Simplified Code Snippet
const predictedPosition = calculatePredictedPosition(lastServerState, playerSpeed);
const actualPosition = updatePlayerPosition(predictedPosition, deltaTime); //deltaTime is often too short
The core problem is that the client is using a stale `lastServerState` to predict the player's position. Because
deltaTime (the time since the last update) is likely too short, the prediction doesn't account for the time it takes for the server to send an updated state. This results in a discrepancy between the predicted and actual positions, leading to the 'ghosting' effect – where players briefly appear to teleport due to the client trying to move based on outdated information.16 / 23
Senior Dev: 'Okay team, I've reviewed the PR for the new matchmaking system. The current implementation uses a simple UDP broadcast to send player positions every frame. While it's quick to implement, we're seeing significant packet loss, especially in games with high player density. I need you to refactor this to use TCP and implement a congestion control algorithm. What is the primary reason for my request?The core issue is unreliable data delivery. UDP's lack of guaranteed delivery means packets are frequently lost during periods of high network congestion, leading to dropped updates and a poor player experience. TCP, with its acknowledgements and retransmissions, provides reliable delivery – crucial for game state synchronization. Implementing congestion control further manages network traffic to prevent overwhelming the connection.
17 / 23
During a standup meeting, the Lead Systems Engineer says: "We're experiencing issues with inconsistent player interactions – sometimes actions appear to happen instantly, while other times there's a noticeable delay. This is particularly bad when players are engaging in fast-paced combat.". Which of the following best describes the technical cause of this observed behavior?
The core issue here relates to network latency. High latency means there's a delay between when an action occurs on one client and when that information is received and processed by the server, and then propagated back to other clients. This creates inconsistent perceptions – sometimes actions appear instant because the delay is small, but other times they are delayed because the overall round-trip time is higher. Option A incorrectly blames bandwidth; while bandwidth can contribute to latency, it's not the *cause* of these perceived inconsistencies.
18 / 23
During a code review of the new player prediction system, your teammate says: 'The client is predicting movement based on the last server state, but it's not updating fast enough to react to changes. We're seeing ghosting – players appear to teleport briefly when they move.' What is the primary issue causing this 'ghosting' effect?
// Simplified Code Snippet
const predictedPosition = calculatePredictedPosition(lastServerState, playerSpeed);
const actualPosition = updatePlayerPosition(predictedPosition, deltaTime); //deltaTime is often too short
The core problem is that the client is using a stale `lastServerState` to predict the player's position. Because
deltaTime (the time since the last update) is likely too short, the prediction doesn't account for the time it takes for the server to send an updated state. This results in a discrepancy between the predicted and actual positions, leading to the 'ghosting' effect – where players briefly appear to teleport due to the client trying to move based on outdated information.19 / 23
Reviewer: 'This PR sends player updates every 30 milliseconds. It's simple, but I'm seeing jitter in movement, especially with players moving quickly. What's the primary reason for this observed behavior?',
Which of the following best explains the reviewer's concern?
The core issue here is the update frequency. Sending updates too infrequently (30ms) means the client isn't receiving data quickly enough to accurately predict player movement, leading to jitter when players change direction rapidly. The reviewer is highlighting a classic problem with low-frequency updates in real-time systems – they don't capture fast changes.
20 / 23
You receive the following Slack message from a junior developer: 'I'm getting a lot of 'ghosting' when players are moving. The client is predicting their position based on the last server state, but it seems to be lagging behind. Is there anything I should do about this?' What does this message primarily indicate?
This Slack message describes a fundamental problem in multiplayer games: 'ghosting.' This happens when the client's prediction of a player's location is out of sync with the server's actual position. The junior developer correctly identified this discrepancy as the root cause; the lagging behind suggests an issue with network latency or processing time, not necessarily an algorithm problem.
21 / 23
You're drafting a PR description for implementing client-side prediction. Which of the following sentences best reflects the purpose of this change?
'This commit introduces client-side prediction to reduce server load by allowing the client to estimate player positions locally, minimizing the amount of data sent over the network.'
Client-side prediction's primary goal is load reduction – it offloads computation from the server to the client. By letting the client estimate positions, fewer updates need to be sent over the network, dramatically decreasing bandwidth usage and server processing. The description accurately captures this core objective.
22 / 23
During a stand-up meeting, a team member says: 'We're seeing occasional 'rubber banding' – players are suddenly pulled back to their previous position after attempting to move forward. This seems related to our player prediction system.' What is the MOST likely cause of this behavior?
'Rubber banding' is a common symptom of over-correction in prediction systems. When the client's prediction lags behind due to network issues or processing delays, the server attempts to 'fix' the discrepancy by aggressively pulling the player back towards their previous location – this creates the unstable, jerky movement known as rubber banding. The core issue isn't just latency; it's a consequence of attempting to correct an inaccurate prediction.
23 / 23
Reviewer: 'I noticed the new system is using a simple UDP broadcast to send player positions. It's very efficient, but I'm worried about scalability. What potential issue does this approach present as the number of connected players increases?'.
Which option best describes the reviewer's concern?
This UDP broadcast approach creates a scalability bottleneck. As more players connect, the volume of position updates increases dramatically. Without rate limiting or other mechanisms to control this flow, the server can quickly become overwhelmed, leading to performance degradation – this is exactly what the reviewer is highlighting.
Frequently Asked Questions
What does the "Multiplayer Vocabulary — Game Engine Language Exercises" exercise cover?
Practise multiplayer networking vocabulary in English: client-server vs peer-to-peer, tick rate, latency/jitter/packet loss, client-side prediction, lag compensation, and interest management.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
How many questions are in "Multiplayer Vocabulary — Game Engine Language Exercises"?
This exercise has 23 questions. Each one gives instant feedback with an explanation, so you can see exactly why an answer is right or wrong.
Do I need to create an account to save my progress?
No account is required. The progress bar and score are tracked in your browser for the current session -- the exercise is designed to be a quick, repeatable drill rather than something you resume later.
What happens if I get an answer wrong?
You'll see the correct answer highlighted immediately, along with a short explanation of why it's correct. Wrong answers aren't penalized beyond your score, and you can keep going through every question.
How is this exercise different from reading an article?
Articles explain vocabulary and concepts through prose, while exercises like this one are interactive drills -- multiple-choice questions -- that test and reinforce your recall of specific terms and phrasing.
Can I retry this exercise?
Yes -- use the "Try again" button on the results screen to reset your score and go through all the questions again from the start.
Where can I find more Game Engine Language exercises?
Browse the full Game Engine Language hub for related drills, or check the site-wide exercises index for other IT English topics.
Is this exercise suitable for beginners?
This exercise assumes basic familiarity with IT terminology. If a term feels unfamiliar, check the site Glossary for a plain-English definition before attempting the questions.
How often is new content like this published?
New exercises are added regularly across all categories, alongside new vocabulary sets and articles. Check back on the exercises hub to see what's new.