Sunday Drop

How a modern FPS starves wallhacks and radar cheats

Wallhacks work because your game snitches. A modern FPS doesn't have to. Here's how the Dead Drop server decides, many times a second, which players your PC gets to know about.

Dead Drop is a 100-player, first-person battle royale for PC, built for competitive play. The introduction covers what the game is and what we’re trying to do. This is the first of the long technical posts. It’s about the system the rest of the game is built around, including what it costs and where it falls short.

The client knows too much

In most online shooters, your game client knows where the enemies are, including the ones you can’t see. The player waiting in the next room and the team crossing the field behind the hill are both in your PC’s memory, updated many times a second. They just aren’t drawn.

The same moment drawn twice, from above. In most shooters, an enemy in the open, one behind a building and one behind you are all sent to your PC, though only the first is drawn. In Dead Drop, only the enemy in the open is sent.
The same moment, twice. Most shooters send all three enemies and draw one. Dead Drop sends only the one you could see.

There are good reasons to do it that way. It’s simple. The server sends everyone nearby, and the renderer works out what’s on screen. It also hides latency, because a player the client already knows about can be drawn the instant they step out from cover.

Every wallhack, ESP overlay and radar cheat lives in that gap between what the client knows and what it shows. None of them needs to talk to the server. They read data the game already handed over.

The usual answer is client-side anti-cheat, which is software on your machine that looks for programs touching the game’s memory. It stops a lot of cheats, and we will run one. But the most valuable cheats have moved out of its reach. A card in an expansion slot can read the game’s memory directly, and a second computer can draw the radar on its own screen. Nothing running on the gaming PC sees either one.

One defense doesn’t care where the cheat runs. The server simply doesn’t send the data. A position the client never received can’t be read out of memory, drawn through a wall or shown on a second screen. That is the fog of war in Dead Drop. For every player, many times a second, the server decides which other players that client could plausibly see right now, and sends only those.

The idea isn’t new. Other shooters cull by visibility on the server, some from the start and some added later. What we’re doing is treating it as a foundation rather than a patch. The rendering rules, the smoke, the doors, spectating, sound and the network protocol were all designed around the fact that a client is only told what it could see.

Here is how the server decides.

How far: the base band

The first filter is distance. Enemies beyond a certain range aren’t sent at all.

Top-down sketch of one player's relevance. Rings around them show the update rate falling with distance. An enemy in the open ahead is sent, while one behind them, one behind a building and one beyond the band are not. A scope cone along their aim reaches a distant enemy.
One player's view of the match, from above. Filled dots are sent to their client, hollow ones are not.

Most of the hundred players on a map several kilometers across are nowhere near you, so a cutoff has to exist. Where to put it is a question about the screen. A person a few hundred meters away is a handful of pixels tall at 1080p. Farther out, they shrink to a pixel or two, and then to nothing.

So the band ends where a standing person is about a pixel or two tall at the match’s resolution. Resolution is locked per match, so everyone in a match gets the same range. A match rendered at 4K sends players farther than one at 1080p.

Inside the band, the update rate falls with distance. Up close, an enemy is in every update, because at that range fights are decided by fine movement. In the middle distances, they’re updated a few times a second, and the client interpolates between updates. That is enough, because someone walking across your view a couple of hundred meters away moves only a pixel or two from one update to the next. Near the edge, updates come only now and then. That keeps distant players cheap.

Not behind your back

Distance isn’t the only thing that tells the server you can’t see someone. If a player stands a few meters behind you in the open, you can’t see them, and neither should a radar.

So a player on foot who is outside your view, with some room to spare, isn’t sent. The spare room keeps a quick turn from outrunning the server. Someone just off the edge of your screen is already sent before you turn toward them. You still hear them, though (more on sound below).

Two exceptions keep fights from waiting on a turn. First, anyone close enough to bump into you is sent in every direction, as long as there’s a line of sight. That way you never walk into a body your client didn’t know about. Second, a player who shoots at you, or whose rounds pass near you, is sent for a short while whichever way you face, as long as they’re in range and in sight.

Players in vehicles or in the air, and anyone inside your scope cone, are sent by the other rules alone, whichever way you face. The same goes for everyone around you while you ride or fall.

Through a scope

The band is sized for the naked eye. A scope changes what an eye can see. Through an 8x optic, a person 400 meters away looks like one at 50. If the server stopped at the band, a sniper would glass a distant hillside and find it empty.

A scope cone seen from above. It reaches well past the edge of the base band and is wider than the scope's own view, padded for a quick turn. A far enemy inside it is sent and updated as if it stood much closer.
The cone reaches past the band. A far player inside it is updated by how big they look through the glass.

So while you aim down sights with a magnified optic, the server adds a cone along your aim. Inside the cone, players are sent farther out. How much farther grows with the optic’s magnification and the match’s resolution, up to a hard limit. Their update rate comes from their effective distance, the real distance divided by the magnification. Through an 8x scope, someone 800 meters away is updated as if they stood at 100, because that’s how big they look. Our renderer uses the same rule to choose detail levels, so a scoped view of a far hillside gets the detail a nearer view would.

The server knows which optic you have from your inventory. A client can’t claim a stronger scope than the one it carries.

It starts on the input, not the animation. Raising a scope takes a moment. If the server waited until the glass was fully up, your first look through it would show an empty landscape that filled in a beat later. Instead, the cone starts as soon as the server receives your aiming input. On a typical connection, the input’s trip to the server, the answer’s trip back and the client’s interpolation delay add up to well under the length of the raise animation. So the data is there before the glass is up.

Couldn’t a cheat send the aiming input all the time? It could, but the server decides who is aiming. So that client moves at aiming speed, like anyone else who aims. It gets what any sniper gets in the direction it’s looking, and it has to move like a sniper to get it.

The cone is wider than the scope’s view. Your aim reaches the server half a round trip after you move the mouse. The answer takes the other half to come back, plus the interpolation delay before it shows up. If you turn while scoped, the edge of your screen sweeps into ground the server hasn’t sent yet.

So the cone is padded by how far you could plausibly turn in that time. The padding is the fastest realistic turn rate for that optic, times your own measured round trip and interpolation delay, plus a little extra. Stronger optics are harder to swing, so their turn rate is lower. A player on a worse connection gets a wider cone, because they need one to see the same thing. While the scope comes up or goes down, the cone covers the widest view your screen might be showing.

It lingers. The cone stays for a moment after you lower the scope, so dropping it to reposition and raising it again doesn’t empty and refill the hillside.

Walls on the server

Distance, facing and the cone produce candidates. For each one, the server then checks for a line of sight and drops the ones hidden behind terrain, buildings or forest. This is the step that makes the fog of war worth having.

Collision shapes, not render meshes

The server doesn’t test against the meshes you see. It tests sight lines against the terrain’s height field and against the simplified shapes the simulation already uses for movement and bullets. Those are boxes and simple solids for walls, roofs, rocks and tree trunks. That keeps the test cheap. Those shapes are also the least detail your client ever draws, so a wall that blocks a sight line on the server is never missing from your screen.

The shapes also know what isn’t a wall:

  • Glass hides nobody. A window doesn’t block a sight line.
  • Destruction shows through. Buildings can be blown apart, and a wall section that is gone hides nothing. A hole knocked through a wall is a hole in the fog too, within moments.
  • Tree crowns hide partly. A sight line through foliage loses a little at every crown it crosses, and the losses add up. One crown never hides anyone, but a deep belt of crowns and young trees does. The crown shapes are measured from the drawn trees and given to the server a little smaller than drawn. That way, thin foliage alone never hides a player at the edge of a wood.

Grass and bushes don’t count at all. We come back to that in the limits.

Seeing someone before they round the corner

Picture someone sprinting toward the corner of a building. On the direct line between you, they’re still hidden. If the server waited for that line to clear, it would only start sending them once they were already visible. They would reach your screen when that update arrived, a beat too late. You would see a player pop into existence already halfway around the corner.

A corner peek seen from above. The direct line from the viewer to a player behind a wall is blocked. A ray shifted sideways and a ray to where the player will be a moment later both pass the corner, so the player is sent before they step out.
The direct sight line is blocked, but the shifted and predicted rays clear the corner. So the runner is sent a moment before they come into view.

So the server doesn’t test a single line, because a person isn’t a point. It casts several rays for each pair of players. Each ray starts at a player’s real eye, so leaning around a corner moves the rays with the head. The rays are:

  • eye to eye
  • eye to the middle of the body, both ways, for a body showing under an overhang when the line between the heads is blocked
  • eye to eye with both players moved a short way along their current movement, a guess at where they’re about to be
  • eye to eye, shifted a little to either side

At shorter range, it adds rays from each player’s current position to the other’s predicted one. If any ray is clear, the pair is visible. Far out, where a shoulder past an edge is less than a pixel, only the first two remain.

The shifted and predicted rays are the ones that look around the edge. How far the sideways shift reaches depends on speed. For a player standing still, it’s half a body’s width. It grows with how far either player could move before the pair is tested again.

So a body whose shoulder shows past a trunk or a wall is sent. A player about to step out is sent shortly before they do. By the time they’re in view, your client already has them and draws them smoothly.

That is a deliberate trade. A patched client may see someone a step before an honest player would. That’s a much smaller gift than players appearing out of thin air mid-fight.

The sight test is also symmetric. If there’s a clear line from me to you, there’s one from you to me, so one result serves both players.

A cache, a budget, and nearest first

A hundred players make nearly five thousand pairs. Testing each with several rays on every update would be wasteful. So each pair’s result is cached and retested on an interval that grows with distance. The retests are staggered, so the work spreads evenly over time.

The pairs due for a sight test on one update, listed nearest first. The nearer ones, including a close call, are tested. A cap on rays cuts off the farthest, which keep their last answer, and one never tested is sent.
The due pairs are tested nearest first. Whatever doesn't fit under the cap is far away, and keeps its last answer until there's room.

One kind of pair skips the wait. Some hidden pairs are close to being visible. If the widest sideways shift would see past the edge between them, the pair is a close call, and the server retests it on every update. A player standing still behind a big pine stays hidden. As soon as they move enough to show, they’re sent.

On each update, the due pairs are tested nearest first, under a cap on how many rays the server will cast. Pairs that don’t fit keep their previous answer until there’s room.

A leak through a wall at, say, twenty meters wins fights. A leak across open ground at five hundred is worth far less. So the budget goes where a mistake costs the most. When the server is behind, it errs toward sending, which means a pair it has never tested is sent rather than hidden. In the benchmark below, the cap was never reached.

Holding against flicker

A player walking past a row of trunks can be visible on one test and hidden on the next. If the server dropped them every time, they would blink in and out on your screen, and every reappearance would arrive late. So a visible result is held for a fraction of a second after the last clear test. The cost is that a patched client keeps someone for that moment after they duck out of sight.

Finally, a body pressed against yours, within arm’s reach, is always sent, through walls, floors and smoke. The radius is deliberately tiny, because walking up to a house shouldn’t reveal who is in the room on the other side of the wall.

Smoke and closed doors are walls too

A smoke grenade is easy to build as a purely visual effect. Each client draws its own particles. The server neither knows nor cares where the smoke is, so the players behind it are sent as usual. A cheat that hides the particles, or just reads positions, sees straight through.

In Dead Drop, the throw runs in the shared simulation, which the server and every client execute identically. So the server knows exactly where the smoke landed and how big it has grown. Each smoke has an opaque core, a sphere that blocks every ray of the sight test like a wall. Every client draws that core solid, the same on every machine, and no setting thins it. The soft edge around the core is only cosmetic. A player hidden behind the core isn’t sent, and a patched client gets nothing through it.

Three sight lines seen from above. One is blocked by the opaque core of a smoke, one by a fully closed door, and the third passes through a door left ajar.
To the server, a smoke's opaque core and a fully closed door are walls. A door left ajar hides nothing.

A smoke takes a moment to grow after it pops. It acts through the same cache as walls, so it takes effect at the pair’s next retest plus the hold. That is a fraction of a second up close and a little longer at range.

Doors work the same way. A fully closed door blocks every ray, so a player hidden behind a shut door isn’t sent to anyone outside. When the door opens, the fog lifts at the pair’s next retest. For players near each other, that takes a small fraction of a second.

A door left ajar hides nothing, by choice. A crack is enough to see through. If the server treated a door open a few degrees as a wall, it would hide the player inside. Someone watching through the gap would see an empty room until that player popped in. A door on its hinges isn’t cover worth that, so only a fully shut door counts.

The doors themselves are sent without a sight test, both the ones around you and the ones inside your scope cone. A door swinging open across a valley is information you earned by looking. Which parts of which buildings have been destroyed goes to everyone, because a house that comes down is part of the map.

What you hear

Sound is the one big exception, and it’s a deliberate leak. When a gun fires, everyone within earshot has to hear it. For a rifle, that is often farther than anyone could spot the shooter by eye. A suppressor shrinks it, and walls, closed doors and ridges between you and the gun muffle it.

Two gunshots seen from above. A shot from a player you are sent arrives exactly, with tracer and muzzle flash. A shooter you aren't sent is inside a building. You hear the weapon muffled, with no name, from a heard spot near the real one, and the blur stays in the same room.
A shot from a player you're sent arrives exactly. From one you aren't sent, you get a muffled sound from a blurred spot in the same room.

What a sound tells you depends on whether you’re being sent the player who made it:

  • If you’re being sent them, you get the shot exactly, with who fired, from where and which way, plus the tracer and the muzzle flash. Their footsteps aren’t sent at all, because your client plays them from the body it’s already drawing.
  • If you aren’t, you get a heard sound. It carries the weapon, how muffled it is and a heard position, with no word on who made it. Footsteps work the same way. The heard position is nearly exact up close, so a camper’s steps come from their own room. It gets blurrier with distance, but it never leaves the building, floor or room the sound came from. A gunshot’s timing is shifted to match, so the report still arrives when it should without giving away the real range.
  • The blur is steady rather than random. A player standing still is heard at one slightly wrong spot, so listening longer doesn’t average it away. Teammates who hear it from a similar distance hear the same spot.
  • A round from a shooter you aren’t sent that passes close to you cracks at its real miss distance. Its direction and timing are jittered, though, so the crack can’t be traced back along the round’s line. Being shot at also lifts the facing rule from earlier, so the shooter is sent to you for a short while, as long as they’re in range and in sight.

That’s how you find a sniper you were never sent. You hear the report, turn toward roughly where it came from and raise your scope. If they’re in the open, they’re now in your cone, and the server sends them. Finding a shooter by ear is a skill we want in the game.

The cost is that a patched client can mark every sound it hears on a map. The heard positions limit what that’s worth. They’re blurred at range and held to the room they came from, and they only exist when the player chose to make a sound. It’s still a real leak, and we chose it.

The other exceptions, on purpose

A few more things are sent outside the sight rules, by design.

Teammates are always sent, at any distance, through walls and smoke, with no rays spent on them and often enough that their markers move smoothly. The fog of war hides enemies, never your own team, whose positions your interface shows anyway.

A spectator gets exactly the spectated player’s view, and nothing more. Everything above is computed from that player’s position and aim. The view from the spectator’s own body is never added, wherever that body lies. That way, a dead player watching a living teammate can’t act as a radar for their team. Spectating costs no extra rays. The spectator’s stream also runs a short delay behind the live match, which blunts real-time call-outs.

Vehicles are sent by distance alone. A running engine can be heard from far away, and a parked car is part of the landscape. A vehicle is sent out to the distance where it looks as big on screen as a player at the edge of the band, up to a hard limit. So a large vehicle is sent farther than a small one. The people inside go through the sight test like anyone else.

Skydivers are sent without a sight test. During the drop, a player in freefall or under a canopy is sent to everyone within range. We skip the test on purpose, because a body in the air is mostly seen against open sky. Players still in the plane aren’t sent at all, since every client already knows the plane’s flight path.

Loot is held back too. A box emptying behind a hill would tell you exactly where a looter stands. So changes to loot far from you and out of your line of sight are held back and sent in batches. A batch says only that someone looted there lately.

What it costs

We measure the server with a benchmark in which 100 bot clients play one match against it over real UDP. The bots roam, stop to scan the horizon through their scopes, and fight what they find. To keep the load high, the bots have ten times the normal health. That keeps the population near 100 for the whole measured two minutes, which no real match does. A bot knows only what the server sent it, so every run is also a test of the fog of war.

A bar chart of the average data sent to each player, about 21 kbps in all. UDP and IP headers 6.7 kbps, your own state and the update header 6.2, events that are almost all gunshot reports 4.7, other players' movement 2.9, and footsteps and impacts 0.1.
From an earlier round of the benchmark. Other players' movement costs less than the gunshot reports.

The figures below come from a 16-core desktop CPU, an AMD Ryzen 9 9950X3D2. The match ran on one thread and the bots on four more. The map was our earlier hand-made 2 km test map, with 27 houses, about 4,900 trees and 480 rocks. These numbers come from an earlier build and will keep changing as the game develops.

The latest round has six runs. It covers three combinations of simulation and update rate (30 and 30 Hz, 60 and 60 Hz, 60 and 30 Hz). Each combination ran once on a clean loopback link and once on a simulated internet link. That link had 80 ms round trips, ±20 ms of jitter, 2% packet loss each way, and 0.5% duplication and reordering.

  • Server tick: a median of 1.3 to 2.0 ms for everything the server does in a tick. The fog of war’s share, for all 100 players, averages 0.4 to 0.7 ms.
  • Bandwidth, per player on average, with the outgoing data for a whole 40-minute match in brackets.
    • 30 Hz simulation, 30 Hz updates. 19.5 kbps clean (0.58 GB), 21.5 kbps on the simulated internet link (0.65 GB).
    • 60 Hz simulation, 30 Hz updates. 19.5 kbps clean (0.59 GB), 20.5 kbps on the simulated link (0.62 GB).
    • 60 Hz simulation, 60 Hz updates. 33.1 kbps clean (0.99 GB), 35.0 kbps on the simulated link (1.05 GB).

An earlier round of measurements, at 30 Hz on the clean link, shows what the fog of war does to the stream:

  • What each client knew: about 11 of the other 99 players on average. About 35 were candidates by distance or a scope cone, and the sight test dropped two thirds of them. On that map, terrain and trees hid most of the band.
  • Rays: about 500 to 590 sight rays per update for the whole match, never reaching the cap.
  • Where the bytes went, at about 21 kbps per player: UDP and IP headers 6.7 kbps, your own player’s state and the update header 6.2, reliable events (almost all gunshot reports) 4.7, other players’ movement 2.9, and footsteps and impacts 0.1.

In that breakdown, gunshots cost more than all the other players put together, because on a 2 km map nearly every shot is in earshot of everyone. Once the server stops sending what you can’t see, other players become one of the cheaper things in your stream. Shots from players you aren’t sent now travel as the smaller heard sounds described above.

The limits

Here is what this doesn’t do.

A fast flick can outrun it. The cone’s padding covers realistic turns. Flick a scope faster than that, and a far player outside the cone isn’t sent right away. They arrive only after your new aim reaches the server and an update comes back.

Far players are also updated less often than near ones. The same goes for spinning around. After a very fast turn, a player behind you can appear a beat late. We think that’s the right trade, but you can run into it.

The edges and the sounds leak by design. The corner rays, the close calls, the hold, the shrunk tree crowns and the arm’s-reach radius all lean toward sending a player slightly early or keeping them slightly late. Sounds tell a patched client roughly where they came from, the same as they tell your ears.

Grass and bushes don’t hide you from the server. Sight is tested against terrain, solid shapes and tree crowns, not grass or bushes. So a player lying in long grass in plain line of sight is sent. An honest client draws the same grass over them on every machine, but a client modified to skip the grass doesn’t. That case is left to client integrity checks and anti-cheat.

The engine is open source. That makes a patched client easier to build than on a closed engine. Client anti-cheat and integrity checks, which we will run, should stop the common case. The fog of war sets a ceiling on what a patched client can learn, but it isn’t a complete anti-cheat. It does nothing against an aimbot aiming at a player you can legitimately see. Other layers, like the server deciding recoil and when a shot happened, will get their own posts.

One more consequence, briefly. Because the server decides what each client is sent, it also knows exactly what each client was sent, and when. That record is useful. How we use it is the one part of this system we won’t describe.

Why it matters

Competitive play rests on a simple rule. What you know about your opponent should be what you earned by looking and listening. A wallhack breaks it. So does a radar on a second screen, and so does a settings menu that lets one player turn off the grass another is hiding in. Client-side detection catches some of these some of the time. Not sending the information closes the most damaging ones for good.

When the fog of war works, you don’t notice it. Players appear as they come around corners, smoke hides the people behind it, a shut door hides you from everyone outside, and a gunshot across the valley tells you where to look. The difference is that a cheater’s client receives nothing more than yours does.