6 exercises — network models, latency vocabulary (ping, RTT, jitter), tick rate and interpolation, client-side prediction and reconciliation, and lag compensation.
0 / 6 completed
1 / 6
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.
2 / 6
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.
3 / 6
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).
4 / 6
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.
5 / 6
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).
6 / 6
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.
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 6 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.