So I’m currently having a problem with my rocket league type system and simulating the ball correctly for all players, I have used a couple of methods and the most smooth one so far was when I switched network ownership of the ball between players but with this method, when players would hit the ball at the same time or they switched network ownerships really fast the ball would freeze in place and teleport.
Switching Network Ownership Between Players Method
Another method I’ve tried is making the server control and have authority over the ball and then the clients report when the player hit the ball, but with this method a player with higher ping isn’t even close to the ball when it gets “Hit”.
Server Authority Over The Ball And Karts Send Client Reports When Hitting Ball Method
Any ideas that would work best for my game would be very appreciated, or a way to fix the current methods problems would also be great.
I think you could try the second option, letting the server own the ball. To fix the desync, you could try to figure out how to implement a ping compensation system although the details will have to be tailored to your specific game’s need
There’s inevitably going to be some desync between the server and client due to latency. I’m a bit curious about your exact implementation of server-authority in this case as I rarely see rollbacks that choppy.
If this were purely visual and not functional I would suggest storing the ball’s actual position as a invisible part or value and then smoothly lerping to it on clients to avoid any choppy visuals, but this won’t feel great with players being able to actually hit the ball around.
The real issue with your second method is the round trip: the ball doesn’t react until the client’s hit report reaches the server, so at 200 ping your friend is always about a fifth of a second late from his own point of view. You need to flip it: predict locally, validate on the server, reconcile everyone else.
When a player hits the ball, apply the impulse on their client immediately. The hitter gets instant feedback — that’s the thing your current setup can never give them.
Send the hit to the server (ball position, velocity, timestamp). The server validates it — was the kart actually within hitting range at that moment (rewind the ball by the reporter’s ping when you check, capped at ~250 ms so high ping can’t be abused), is the impulse magnitude within legal bounds — then simulates the authoritative result and broadcasts it.
Everyone else lerps toward the server’s corrected ball state. The hitter rarely sees a correction because their prediction usually matches. Remote players see a small adjustment, which is much less jarring than watching their own swing land late.
Keep the ball server-owned the whole time (ball:SetNetworkOwner(nil)) and treat the prediction as client-side visual only — that also kills the freeze/teleport from your first method, because there’s no ownership handoff left to race when two players hit at once. The server just resolves both reports in whatever order they arrive.
The validation step doubles as your anti-cheat: a hit report that fails the distance/impulse check is dropped, and the client’s prediction gets corrected back. You won’t eliminate desync — Rocket League itself shows corrections at 200 ping — but this moves it onto the players who aren’t touching the ball, where it’s least noticeable.