Question Networking the Platformer sample - Player Character can't stand on moving platforms correctly

In editor, the character jitters. In build, the character "glides" against the platform's movement instead of keeping its position still. The difference is probably due to much better performance in build than in editor. But the expected behaviour is that the character stays still relative to the platform. When I inspect it, it seems to work well in the Server, but the Client is "jittering" and setting-unsetting the character's parent.

I grabbed the Platformer sample, simplified it (removed a bunch of states, I only need GroundMove, AirMove, Dashing, LedgeGrab and LedgeStanding), and networked it following the instructions in the manual.

This is the moving platform:

The TestMovingPlatformSystem updates in BeforePhysicsSystemGroup in both Client and Server.

This is the Player Character:



And here are the ghost variants:

Code (CSharp):

1.     [GhostComponentVariation(typeof(CharacterControlComponent))]
2.     [GhostComponent]
3.     public struct CharacterControlComponentGhostVariant
4.     {
5.         [GhostField] public float3 MoveVector;
6.     }

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(CharacterInterpolation))]
3. [GhostComponent(PrefabType = GhostPrefabType.PredictedClient)]
4. public struct CharacterInterpolationGhostVariant
5. {
6.    
7. }
8.  

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(CustomGravityComponent), "Custom Gravity")]
3. [GhostComponent]
4. public struct CustomGravityGhostVariant
5. {
6.     [GhostField] public float3 Direction;
7.     [GhostField] public float Strength;
8.  
9.     [GhostField] public bool AffectedByGravityZone;
10.     [GhostField] public Entity CurrentZone;
11.     [GhostField] public Entity PreviousZone;
12. }
13.  

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(KinematicCharacterBody), "Velocity, Grounded, Parenting")]
3. [GhostComponent]
4. public struct KinematicCharacterBodyGhostVariant
5. {
6.     [GhostField] public float3 RelativeVelocity;
7.     [GhostField] public bool IsGrounded;
8.     [GhostField] public Entity ParentEntity;
9.     [GhostField] public float3 ParentLocalAnchorPoint;
10.     [GhostField] public float3 ParentVelocity;
11. }
12.  

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(PlayerCharacterComponent))]
3. [GhostComponent]
4. public struct PlayerCharacterComponentGhostVariant
5. {
6.     [GhostField] public bool IsSprinting;
7.     [GhostField] public byte CurrentUngroundedJumps;
8. }
9.  

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(PlayerCharacterStateMachine))]
3. [GhostComponent]
4. public struct PlayerCharacterStateMachineGhostVariant
5. {
6.     [GhostField] public PlayerCharacterStates CurrentState;
7. }
8.  

(I use PlayerCharacterComponentGhostVariant and PlayerCharacterStateMachineGhostVariant for animating non-local players)

Code (CSharp):

1.  
2. [GhostComponentVariation(typeof(TrackedTransform), "PreviousFixedRateTransform")]
3. [GhostComponent]
4. public struct TrackedTransformGhostVariant
5. {
6.     [GhostField] public RigidTransform PreviousFixedRateTransform;
7. }
8.  

Code (CSharp):

1.  
2. public partial class DefaultVariantSystem : DefaultVariantSystemBase
3. {
4.     protected override void RegisterDefaultVariants(Dictionary<ComponentType, Rule> defaultVariants)
5.     {
6.         defaultVariants.Add(typeof(CustomGravityComponent), Rule.ForAll(typeof(CustomGravityGhostVariant)));
7.         defaultVariants.Add(typeof(KinematicCharacterBody), Rule.ForAll(typeof(KinematicCharacterBodyGhostVariant)));
8.         defaultVariants.Add(typeof(LocalTransform), Rule.ForAll(typeof(TransformDefaultVariant)));
9.     }
10. }
11.  

And these are the character controller systems and when they update:

Code (CSharp):

1.  
2. //[UpdateInGroup(typeof(KinematicCharacterVariableUpdateGroup))]
3. [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
4. [UpdateAfter(typeof(PredictedFixedStepSimulationSystemGroup))]
5. [BurstCompile]
6. public partial struct PlayerCharacterVariableUpdateSystem : ISystem
7.  

Code (CSharp):

1.  
2. //[UpdateInGroup(typeof(SimulationSystemGroup), OrderFirst = true)]
3. //[UpdateBefore(typeof(FixedStepSimulationSystemGroup))]
4. [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
5. [UpdateBefore(typeof(PlayerCharacterVariableUpdateSystem))]
6. [BurstCompile]
7. public partial struct PlayerCharacterVariableStepControlSystem : ISystem
8.  

Code (CSharp):

1.  
2. //[UpdateInGroup(typeof(FixedStepSimulationSystemGroup), OrderFirst = true)]
3. [UpdateInGroup(typeof(PredictedFixedStepSimulationSystemGroup), OrderFirst = true)]
4. [BurstCompile]
5. public partial struct PlayerCharacterFixedStepControlSystem : ISystem
6.  

Code (CSharp):

1.  
2. [UpdateInGroup(typeof(KinematicCharacterPhysicsUpdateGroup))]
3. [BurstCompile]
4. public partial struct PlayerCharacterPhysicsUpdateSystem : ISystem
5.  

Code (CSharp):

1.  
2. [UpdateInGroup(typeof(SimulationSystemGroup))] // update in variable update because the camera can use gravity to adjust its up direction
3. [UpdateBefore(typeof(KinematicCharacterVariableUpdateGroup))]
4. public partial class CustomGravitySystem : SystemBase
5.  

In the case of CustomGravitySystem, which updates in KinematicCharacterVariableUpdateGroup, this is not in a "predicted" loop. Is that a problem? I'm only testing with global gravity (constant toward down vector), I haven't tried with spherical gravity yet.

So... Is there anything else I might have missed?

Are there any plans of adding moving platofms to the FPS sample so that we can have an example on how to network them?

 

Great to hear phil. I am in the process of setting up the third person character and orbit camera to work with netcode, but I believe the camera has a slight jitter whereas the character looks smooth (it looks smooth in the editor window).
I'll be eagerly waiting for the updated examples/guide if I can't figure it out.
-On a side note, the guide says you only need to serialize/ghost-field the camera rotation, and that doesn't work unless I am doing something wrong. Serializing the transform seems to work, except for the jitter ofc.

 

Thank you so much!

This fixed it!*

Also:

• I deleted the CharacterControlComponentGhostVariant, you're right, I don't need it.
• I can live without ledge grabbing mechanics, so I deleted those states too.
• Regarding the custom gravity: I'm okay with only vertical gravity. I did modify the gravity/jump mechanics too to have the character "move downwards slower than it moves upwards" to get that "platformer feel", and it seems to work fine. Also, I forgot to mention that I moved the CustomGravitySystem to PredictedSimulationSystemGroup.
• I also forgot to mention that I changed the camera as well, I'm using a top-down camera that follows the player. For now, it doesn't rotate. I don't want the player to "control" the camera. The camera is not a ghost, nothing is synched, each client moves their own camera. It seems to work well.

*As long as the platform doesn't move too fast, but I can live with it until you release that sample