Sorry, but the link is not acting in your favor
game client processes hits on your pc and then transmits hits to the server (which then decides if the enemy lives or dies)
lets put it in the table:
(sorry for the quick coder table art)
I don't see why the developers statement is not in my favor.
the example being overwatch: The server decides if he hit something and tells the server.
that contradicts with what the dev says:
developer said:
game client processes hits on your pc
The server doesn't trust the client and verifies it
the developer explains this as the alternative (which they don't do) 'server side hit detection':
developer said:
Server side hit detection would mean that the server, registers all the hits from hundreds/thousands of players and then decides the outcome.
They explicitly say
developer said:
your PC is doing ALL the work
before deciding if the enemy lives or dies.
exactly, the server decides about life and death, based on the hit detection of the client. These are two decision makings, don't mix them. Maybe that's the source of confusion.
The client isn't controlling anything: he is submitting a "I killed this player" request and the server doesn't trust and has the final word if it really did kill a player. That's what client-side hit detection means:
That's not what the developer said. The client is _not_ submitting a kill request.
developer said:
your game client processes hits on your pc and then transmits hits to the server
in your terms: the client submits a "I hit enemy_id". The server calculates
a) "enemy_id had 150 health, client hit for 180, that means enemy_id is killed by this client"
b) "enemy_id reported a headshot to client before, this hit report does not lead to any effect"
there is no "I don't trust the player, lets check in my state if the bullet hit". In both cases you will see blood splashing out of the enemy and a hit animation.
(this is particular for Overwatch, other games do it as you've said, with 0% trust).
Server-side: Client tells the server he shot at something, the server tells him if he hit.
again, the dev says the opposite:
developer said:
game client processes hits on your pc and then transmits hits to the server ... YOUR pc does all the work.
Client-side: Client tells the server he hit something, the server overrules if something doesn't add up.
That's true, the client tells the hit.
It's also true, if there is a contradicting situation between two clients, the server has to overrule a hit. BUT not because of validation of your shots (-> no raycast), but solely to resolve a contradicting situation. e.g. two snipers shoot at each other. you might see that you hit first, but the server received the hit from the enemy's client first, your hit will be overruled. e.g.:
but if you see you hit something, and there is no contradiction of states with other clients, the server will accept your hit even if you contradict a server state (e.g. the server accepts a hit of an enemy that is behind the wall regarding the server state).
And yes, that also means, if you hacked the client or network traffic, you don't even need to pull the trigger or aim exactly at the enemy, as long as you send a 'hit' and it does not contradict other clients, the enemy will die.
Server never trusts the client. If client-side detection would be a "I trust you 100%" from the server a malicious player could very easily state "I killed that player" and the server simply go "Oh, ok, but he is on the other side of the""-NOPE, I shot him". and the server accepts.
it's not about 100% trust. you said the server never trusts the client -> 0% trust. I state that's not true. The server in Overwatch trusts the "hit" reports of the client. Overruling happens, but _not_ because of a trust issue, but purely to solve a conflict. In most cases, conflicts are resolved in favour of the shooters, they call it "favour the shooter". That's why you hit someone behind walls. They add "exceptions" to some conflicts in where they will not favour the shooter. You can watch the details here:
Again: It's not because of a lack of trust to a client as you state, it's really only to resolve conflicts (stated in the developer video).
Imagine any system where the client is trusted 100%.
ok, lets imagine this for a second on a NOT hacked/cheated game. what would happen if the client decides? lets take the developers explanation:
gamedev said:
Example: Tracer peeks through a corner, sees a sniper and blinks into safety of cover then suddenly dies. Death cam shows tracer was shot in the face by Widow and never blinked away.
Explanation: This is because of client side hit detection.
(Note, an exception was added in a newer patch, now the blink is favoured over the hit. but again, not a trust issue, solely a solution to conflict).
There would be situations, where:
client state: enemy player is visible, player attacks and hits the enemy.
server state: enemy player is hidden behind the wall, hit is impossible, yet as the server does not verifiy it, it will still accept the client's hit report (in case you don't know this game, that's the end-of-game-replay that everyone sees as the server saw it. you see the completely occluded enemy):
There will be a situation, where:
client A state: enemy B is visible due to network latency, will be hit
client B state: enemy A cannot see you for half a second, server would know that due to time stamps of pos updates etc. if it would verify hits, but if the server just believes client A, client B gets hit anyway and sees an impossible situation:
The whole post in the overwatch forum is due to the fact, that hits are handled on the shooting client. A lot of replays look weird and player think the game is buggy. But in fact, it's not a bug, it's simply due to the decision to handle this part on the client.
I agree, the Devision gone bad. Maybe because this code was rather written for consoles where you cannot hack binaries.
From the architecture, overwatch is inbetween devision and your perfect model, but with better security. From the gameplay it's a better feeling for shooter(e.g. sniper), as you don't suffer from vague prediction, you don't have to aim ahead.