Networked Physics with PhysX

LiquidJoy · April 7, 2018, 9:11pm

BoBosan:

@Nonlin

It’s depend on your game design and gameplay.

About the pick up, you can use lag compensation.

A roughly lag compensation implementation.

Server keeps history buffer.

Client send pickup RPC with sync server timestamp and its position on client.

Server use timestamp to search history buffer and start validating pickup on client. If validating is correct, let that client pick the object regardless of its current state.

Server can use round trip time instead of sync server timestamp from RPC but it’s still prone to hacking as much as sync server timestamp.

This technique prop and cons

prop: picker almost doesn’t experience lag. If they pick and doesn’t cheat, they always pick the object.

cons: For the case with high latency picker,The picked object may move back in the past position or high latency picker steal it from other picker.

To illustrate problem, see Rocket League video above around 29.00min.

For sync server timestamp.

Client send client timestamp to server.

Server reply back with server timestamp and received client timestamp.

Client filter duplicate and late reply using client timestamp.

Client use client timestamp from replay and its current timestamp to calculate round trip time. Offset this round trip time to server timestamp.

For smoothing physic visual.

Separate visual and rigidbody. Rigidbody simulate physic. Visual doesn’t simulate physics.

My current set up is that rigidbody is root component and visual is its child You can try other setup too. It’s up to you.

When receive replication.

Snap rigidbody but don’t snap visual.

There are many approaches how you smooth visual to rigidbody.

First approach, Decay the different by percentage between visual and rigidbody. You may need different decay value depending on situation. See State Synchronization | Gaffer On Games for more information.

Second approach, Use velocity blending. Visual simulates as if it’s old rigidbody before getting update. The result will be blend with rigidbody. Visual blend two thing, its current velocity and current position. See Dead reckoning - Wikipedia for more information. This technique is published by Murphy, Curtiss. Believable Dead Reckoning for Networked Games. Published in Game Engine Gems 2

Third approach, Use beizer curve. I haven’t looked into this yet.

On other note, I’m testing with sleep rigidbody with non-zero velocity. PhysX still wakes rigidbody anyway.
Need to modify PhysX code. It’s just changing the flag.
The problem it’s that I’m not sure how Unreal compile PhysX and integrate to engine. It seem to manage third party party using CMake.

I’m not sure if we can approximate this and ignore restitution which use to resolve both rigidbody’s velocity in collision.

I’ve been trawling the internet for days regarding replicating ball physics for a multiplayer golf game I’m trying to put together and this is the first thread that is helping me to progress. Thanx for sharing your knowledge guys, it is extremely valuable. Do you think this lag compensation with server buffer is the way to go for a golf game which will result in the ball transform being identical across clients when the ball comes to a rest?

I need accuracy but it doesn’t have to be immediate as only one client triggers the shot and then everyone else can view the shot even after a small delay.

I’m pretty new to networking and this is the biggest hurdle I’ve come up against + I’m solely using blueprints

Any links to examples or feedback regarding how to approach this would be GREATLY appreciated. Thanks in advance.