Question Change Ghost position with Predicted ghost mode

Hello Everyone,

We are making a multiplayer pong game using Unity Netcode.
The ball is synchronized across all game clients.

The expected outcome is :

• When we press the mega shoot button on the client machine, we want to change the direction of the ball instantly without any weird jumps or jitterings.

All our tests are made through localhost (so no latency from the network is involved) with powerful computers.

What we tried :
1) First Test :
We set the GhostAuthoringComponent of the ball to Interpolation
=> the ball was moving smoothly but when we pressed the mega shoot button, there was a latency before the ball changes its direction (this outcome ruins player experience).

Conclusion of the first test:
The ball belongs to the server but it needs to be predicted by all clients, in order to have a good player experience.

Basically all client needs to change the ball position without waiting for the server’s response.

2) Second test:
So we changed the GhostAuthoringComponent of the ball to Predicted
=> When we pressed the mega shoot button, the ball was changing immediately its position but during the transition, the ball was jumping back and forth before taking the correct direction. The ball is less smoother than interpolation.

Here is the observed behaviour:



And here is the code that change position of the ball inside GhostPredictionGroup:

Code (CSharp):

1. [BurstCompile]
2. [RequireComponentTag(typeof(BallTagComponent))]
3. struct ShootBallJob : IJobForEachWithEntity<Translation, PhysicsVelocity, PredictedGhostComponent>
4. {
5.     public uint currentTick;
6.     public float ball_positionX;
7.     public float ball_positionZ;
8.     public float ball_directionX;
9.     public float ball_directionZ;
10.  
11.     public void Execute(Entity entity, int index, ref Translation position, ref PhysicsVelocity velocity, [ReadOnly] ref PredictedGhostComponent prediction)
12.     {
13.         if (!GhostPredictionSystemGroup.ShouldPredict(currentTick, prediction))
14.             return;
15.  
16.         position.Value.x = ball_positionX;
17.         position.Value.z = ball_positionZ;
18.  
19.         velocity.Linear.x = ball_directionX * 2;
20.         velocity.Linear.z = ball_directionZ * 2;
21.     }
22. }

Any help on how to remove this jittering is welcome!

Thanks in advance for your help

@timjohansson @CMarastoni

 

Thanks for your quick answer!

We are setting the ball’s position and direction by running this logic in ClientSimulationSystemGroup:
We calculate the direction and the position to apply to the ball, then we fill in the input buffer with those infos associated with the tick.

Here is the corresponding code :

Code (CSharp):

1. [BurstCompile]
2. [RequireComponentTag(typeof(BallTagComponent))]
3.     struct ShockwaveJob : IJobForEachWithEntity<Translation, BallAuthoringComponent, PhysicsVelocity>
4.     {
5.         public float shockwave_maxRadius;
6.         public float3 positionPlayer;
7.         public NativeArray<ResultShockwaveDataComponent> result;
8.  
9.         public void Execute(Entity entity, int index, [ReadOnly] ref Translation position, ref BallAuthoringComponent ballAuthoringComponent, ref PhysicsVelocity velocity)
10.         {
11.             float3 positionBall = position.Value;
12.             float3 _direction = positionBall - this.positionPlayer;
13.             float sqrMagnitude = (_direction.x * _direction.x) + (_direction.z * _direction.z);
14.             float _distance = math.sqrt(sqrMagnitude);//_direction.magnitude;
15.  
16.             if (_distance <= this.shockwave_maxRadius)
17.             {
18.                 ResultShockwaveDataComponent resultShockwaveDataComponent = new ResultShockwaveDataComponent();
19.                 resultShockwaveDataComponent.ball_positionX = positionBall.x;
20.                 resultShockwaveDataComponent.ball_positionZ = positionBall.z;
21.                 resultShockwaveDataComponent.ball_directionX = _direction.x;
22.                 resultShockwaveDataComponent.ball_directionZ = _direction.z;
23.                 result[index] = resultShockwaveDataComponent;
24.             }
25.         }
26.     }

Then after we get this position and direction in a system that runs inside the GhostPredicionSystemGroup with the following code:

Code (CSharp):

1. [BurstCompile]
2.     [RequireComponentTag(typeof(PlayerTagComponent), typeof(PlayerInput))]
3.     struct GetPlayerCommandJob : IJobForEachWithEntity<Translation, PlayerAuthoringComponent, PredictedGhostComponent>
4.     {
5.         public uint currentTick;
6.         [ReadOnly] public BufferFromEntity<PlayerInput> inputFromEntity;
7.         public NativeArray<InputDataComponent> result;
8.  
9.         public void Execute(Entity entity, int index, [ReadOnly] ref Translation position, [ReadOnly] ref PlayerAuthoringComponent playerAuthoringComponent, [ReadOnly] ref PredictedGhostComponent prediction)
10.         {
11.             if (!GhostPredictionSystemGroup.ShouldPredict(currentTick, prediction))
12.                 return;
13.  
14.             var input = inputFromEntity[entity];
15.             PlayerInput inputData;
16.             input.GetDataAtTick(currentTick, out inputData);
17.            
18.             PlayerCommand playerCommand = (PlayerCommand)inputData.playerCommand;
19.             if (playerCommand != PlayerCommand.Shockwave)
20.                 return;
21.  
22.             InputDataComponent inputDataComponent = new InputDataComponent();
23.             inputDataComponent.playerCommand = inputData.playerCommand;
24.             inputDataComponent.ball_positionX = inputData.positionX;
25.             inputDataComponent.ball_positionZ = inputData.positionZ;
26.             inputDataComponent.ball_directionX = inputData.directionX;
27.             inputDataComponent.ball_directionZ = inputData.directionZ;
28.             result[index] = inputDataComponent;
29.         }
30.     }

Finally we apply the position and the direction inside the job we put in our first post.

Does it help you to better understand?
What idea can we implement to fix the glitch?

Thanks in advance.
@timjohansson @CMarastoni

 

Any help please ?
@timjohansson @CMarastoni

 

@timjohansson

1) If you have to make a pong game with the ability to deviate the ball instantanously by pressing a button, how would you implement it with the current version of Netcode ?

2) How the ball would be handled in general (Client and Server)? What part of the ball logic would be in Prediction Group ? Would you use the Unity Physics ?

 

@timjohansson

If I follow your advice,

1) How would you do the ball movement in the prediction group ?
You would write the equation of speed and use it to change ball position ?

2) How would you detect the collision ? Or trigger ? is it possible to use only Unity Physics for that ? (If Yes How ?)
Or should we use Raycast ?

3) For the ball bounces, would you use equation of refraction to change ball position?

4) What states/data should be shared between client and server regarding the ball ? How would you configure the GhostAuthoringComponent ? Untick PhysicVelocity ?

5) Finally, how would you know/test that the code in Prediction Group is perfectly rolling back ? (Any tips to debug if the rolled back is wrong, would be very helpful)

Thank you in advance for your help ! It helps us a lot

 

@timjohansson
Thank you for your detailed explanation!
Let us know when the Unity Physics will be supported by Netcode.

For the meantime, we will try to implement your suggestion.

Best