For technical reasons this is infeasible for most modern games, especially action games like FPSs. In general, the way a networked FPS works is by using the se

For technical reasons this is infeasible for most modern games, especially action games like FPSs. In general, the way a networked FPS works is by using the server as an authoritative source for information, but doing extrapolation on the client-side. This means that enemies which are not visible to a player must still be known by the client, since the camera and enemy may move into a position where the enemy is visible more quickly than the server can respond. So the client must know the location and velocity of some opponents which are otherwise not visible to the player (because they might become visible). But, let’s suppose we solve latency problems, and don’t use client-side prediction. You would need some perfect visibility algorithm for determining which opponents should be transmitted to each client. Those visibility algorithms make a tradeoff between accuracy and computational expense. They are conservative, because it is always an error to fail to draw something which is visible, but it is never an error to draw something which is occluded. But, let’s suppose we solve visibility perfectly, and only transmit to clients the locations of models which are actually visible, and only the parts of those models which have pixels on-screen. Consider an opponent hiding behind a wall, but with a small part of the opponent poking out. The game is going to need to draw that part poking out, but if you look inside the game’s memory, you can find that those textures and vertices belong to a model used by an opponent. Beyond that—we are transmitting a video stream to the client. Basically, we can solve cheating if everyone uses Stadia.