@banteg@aussetg AFAICT it’s not a hybrid of anything. This is a traditional rollback architecture. All implementations I’m familiar with use some amount of input delay (lockstep), usually a fixed number of frames, often configurable by the player/client.
@ZoidCTF Harder to compute now that collision isn’t all based on plane clipping. Regardless, the technique often winds up high effort and bug prone yet minimally effective once you make it conservative enough to account for latency, leak positions for footsteps, gunfire, radar, etc.
@Biggsism@AntonHand Instead, there’s a risk/reward imbalance to AAA productions (especially live service) that are making them bad bets. There doesn’t seem to be any sign that AI is on the brink of alleviating the underlying reasons for this.
@Biggsism@AntonHand I think the point that @AntonHand is trying to make is that consumer demand in ‘83 fundamentally changed (evaporated) and that’s not the case today so comparing the two doesn’t yield much insight.
@wickerwaka Is there perhaps a distinction to be made in at least source-available vs not? That’s not a value judgment but is a limiting factor in being able to determine a core’s accuracy for oneself or improve upon it over time as more preservation work is done.
@Acerola_t Worse, they’re often the polar opposite. Longer cinematic animation transitions look a lot better than short responsive blends but feel sluggish. Similarly, with netcode, if your game is lockstep your online gameplay looks perfect and artifact free under latency but feels awful.
@_brunodeangelis@TAbrodi@SheriefFYI Happy to answer any questions you may have! Hard to get nuanced with limited character limits. I wrote this blog post which is probably a good place to start and has additional references at the bottom:
https://t.co/UAYM2uHeXs
@_brunodeangelis@TAbrodi@SheriefFYI Client sends one input for every tick. You can’t send an input for an older tick because you’ve already sent an input for that tick. The second will be discarded.
@SheriefFYI This is one reason why Unreal’s RPC-based mechanisms and lack of time sync are so problematic—it gets hard to solve this robustly.
In this case, you don’t send “I shot”, you send inputs per tick, which may trigger a shot. Old inputs will be discarded and new ones will be queued.
@DoctorGester@TAbrodi Tim Ford explicitly states they do entity interpolation and server rewind. It is shown in detail at 37:22: https://t.co/XSUWPaVwo7
Server rewind only makes sense in the context of interpolation because that’s what the server is reconciling.
Rollback is for local player only.
@DoctorGester@TAbrodi No, Overwatch uses interpolation for enemy positions the same as here and will do some extrapolation beyond the server rewind window.
@DoctorGester@TAbrodi I understand the sentiment, but for shooters full rollback is actually worse. Here you get zero input latency and perfect hit registration. Predicting remote players means enemies might not be where you’re shooting and requires input delay to keep errors manageable for most pings
@DoctorGester@TAbrodi Fixed timestep is great for eliminating a lot of traditional vulnerabilities such as speed-hacks, making gameplay/physics/performance more consistent, and reasoning about and debugging the system in general.
@DoctorGester@TAbrodi Determinism is needed for client-side prediction to resimulate inputs from the latest received state from the server. This is effectively rollback but only for your local player instead of everyone.
im studying netcode for fast multiplayer games.
got a server authoritative implementation working.
- pure deterministic sim. same shared rules on client and server.
- fixed tick loop. both sides run the game on a stable update rate.
- server authority. the server owns the real game state.
- client prediction. local movement feels instant instead of waiting on ping.
- input seq plus tick. order and timing are both explicit.
- acked input flow. server tells client which inputs were already processed.
- reconciliation. client reapplies only the inputs the server has not confirmed yet.
- remote interpolation. other players render smoothly instead of snapping.
- snapshot history buffer. server keeps recent past world states for rewind.
- lag compensation. shots are checked against the past state the shooter likely saw.
- max rewind limit. very old shots do not get honored forever.
- authoritative shooting. the server decides the real hit and damage.
- wall aware hitscan. shots stop on walls before hitting players behind cover.
- stale and duplicate input rejection. old packets do not get to corrupt state.
- forward only movement on server. late movement input does not rewind the world.
In an FPS, ideally the elevator logic would be entirely server-side yet would move with client-side prediction. Players on the elevator would sync their locations relative to the elevator rather than in world-space.