Player rotation not correctly replicated in a gravity field

[Metalbob]

Hi everyone !

I’m working on a host/client multiplayer game using gravity fields on small planets and I’m encountering some issues with the character rotation replication. I followed this tutorial to get the gravity to work locally and slightly adpated it to my needs. On the host everything is fine, player rotation is correct for all player characters but for the client only the local client is correctly rotated, all non-local clients are rotated in world space. Also, something strange is when the character jumps, it is correctly replicated while in air, even when I make the character rotate, but suddenly rotate when it lands. Here are some videos to be clearer:

From Host:

From Client:

The character is set like this:

I might be missing something but the host characters rotation should be replicted to not owning client, is it a correct assumption? I feel like it’s a Controller problem since it works only on characters which have a controller locally.

I’m working in UE5.5. I gathered all the gravity management in a UActorComponent child component:

The header file:

#pragma once

#include "Components/ActorComponent.h"
#include "Gameplay/Gravity/GravityInfluencedInterface.h"

#include "GravityInfluencedComponent.generated.h"

class ADeliveryShipCharacter;
class ADeliveryShipPlayerController;

UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class DELIVERYSHIP_API UGravityInfluencedComponent : public UActorComponent, public IGravityInfluencedInterface
{
	GENERATED_BODY()

public:	
	
	UGravityInfluencedComponent();

protected:
	
	virtual void BeginPlay() override;

	/** Sets the current gravity field */
	virtual void SetCurrentGravityField(UPrimitiveComponent* NewCurrentGravityField) override;

	/** Gets the current gravity field */
	virtual UPrimitiveComponent* GetCurrentGravityField() override;

	/** Gets the list of all the currently overlapped gravity fields */
	virtual TArray<UPrimitiveComponent*>* GetOverlappingGravityFields() override;

public:	
	
	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

	UFUNCTION()
	void UpdateRotation(float DeltaTime);

	// Converts a rotation from world space to gravity relative space.
	UFUNCTION(BlueprintPure)
	static FRotator GetGravityRelativeRotation(FRotator Rotation, FVector GravityDirection);

	// Converts a rotation from gravity relative space to world space.
	UFUNCTION(BlueprintPure)
	static FRotator GetGravityWorldRotation(FRotator Rotation, FVector GravityDirection);

private:

	UFUNCTION(Server, Reliable)
	void Server_SetUseGravity(bool bNewUseGravity);

	UFUNCTION(Server, Unreliable)
	void Server_SetCurrentGravityDirection(FVector NewCurrentGravityDirection);

	UFUNCTION()
	void OnRep_UseGravity();

	UFUNCTION()
	void OnRep_CurrentGravityDirection();

	ADeliveryShipCharacter* PlayerCharacter = nullptr;

	ADeliveryShipPlayerController* PlayerController = nullptr;

	FVector LastFrameGravity = FVector::ZeroVector;


	UPrimitiveComponent* CurrentGravityField;

	bool bUpdateGravityFieldInTick = false;

	TArray<UPrimitiveComponent*> OverlappingGravityFields;

	UPROPERTY(ReplicatedUsing(OnRep_CurrentGravityDirection))
	FVector CurrentGravityDirection = FVector::DownVector;

	UPROPERTY(ReplicatedUsing(OnRep_UseGravity))
	bool bUseGravity = true;
};

The cpp file:

#include "Gameplay/Gravity/GravityInfluencedComponent.h"
#include "Player/DeliveryShipCharacter.h"
#include "Player/DeliveryShipPlayerController.h"
#include "Gameplay/Gravity/GravityInterface.h"

#include "Components/CapsuleComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Net/UnrealNetwork.h"

// Sets default values for this component's properties
UGravityInfluencedComponent::UGravityInfluencedComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	PrimaryComponentTick.bCanEverTick = true;

	SetIsReplicatedByDefault(true);
}

void UGravityInfluencedComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	DOREPLIFETIME(UGravityInfluencedComponent, CurrentGravityDirection);
	DOREPLIFETIME(UGravityInfluencedComponent, bUseGravity);
}

// Called when the game starts
void UGravityInfluencedComponent::BeginPlay()
{
	Super::BeginPlay();
	
	PlayerCharacter = Cast<ADeliveryShipCharacter>(GetOwner());
	check(PlayerCharacter);

	if (PlayerCharacter->IsLocallyControlled())
	{
		PlayerCharacter->GetCapsuleComponent()->OnComponentBeginOverlap.AddDynamic(this, &UGravityInfluencedComponent::OnBeginOverlap);
		PlayerCharacter->GetCapsuleComponent()->OnComponentEndOverlap.AddDynamic(this, &UGravityInfluencedComponent::OnEndOverlap);
	}
}


// Called every frame
void UGravityInfluencedComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	if (!PlayerController && (PlayerCharacter->IsLocallyControlled() || PlayerCharacter->HasAuthority()))
	{
		PlayerController = Cast<ADeliveryShipPlayerController>(PlayerCharacter->GetController());
		if (!PlayerController)
		{
			return;
		}
		PlayerController->OnUpdateRotation.AddDynamic(this, &UGravityInfluencedComponent::UpdateRotation);
	}

	if (PlayerCharacter->IsLocallyControlled())
	{
		if (CurrentGravityField && bUpdateGravityFieldInTick)
		{
			CurrentGravityDirection = IGravityInterface::Execute_GetGravityDirection(CurrentGravityField, PlayerCharacter->GetRootComponent());
			PlayerCharacter->GetCharacterMovement()->SetGravityDirection(CurrentGravityDirection);

			if (GetNetMode() != ENetMode::NM_ListenServer)
			{
				Server_SetCurrentGravityDirection(CurrentGravityDirection);
			}
		}
	}
}

void UGravityInfluencedComponent::UpdateRotation(float DeltaTime)
{
	FVector GravityDirection = FVector::DownVector;
	if (PlayerCharacter)
	{
		UCharacterMovementComponent* MoveComp = PlayerCharacter->GetCharacterMovement();
		if (MoveComp)
		{
			GravityDirection = MoveComp->GetGravityDirection();
		}
	}

	// Get the current control rotation in world space
	FRotator ViewRotation = PlayerController->GetControlRotation();

	// Add any rotation from the gravity changes, if any happened.
	// Delete this code block if you don't want the camera to automatically compensate for gravity rotation.
	if (!LastFrameGravity.Equals(FVector::ZeroVector))
	{
		const FQuat DeltaGravityRotation = FQuat::FindBetweenNormals(LastFrameGravity, GravityDirection);
		const FQuat WarpedCameraRotation = DeltaGravityRotation * FQuat(ViewRotation);

		ViewRotation = WarpedCameraRotation.Rotator();
	}
	LastFrameGravity = GravityDirection;

	// Convert the view rotation from world space to gravity relative space.
	// Now we can work with the rotation as if no custom gravity was affecting it.
	ViewRotation = GetGravityRelativeRotation(ViewRotation, GravityDirection);

	// Calculate Delta to be applied on ViewRotation
	FRotator DeltaRot(PlayerController->RotationInput);

	if (PlayerController->PlayerCameraManager)
	{
		PlayerController->PlayerCameraManager->ProcessViewRotation(DeltaTime, ViewRotation, DeltaRot);

		// Zero the roll of the camera as we always want it horizontal in relation to the gravity.
		ViewRotation.Roll = 0;

		// Convert the rotation back to world space, and set it as the current control rotation.
		PlayerController->SetControlRotation(GetGravityWorldRotation(ViewRotation, GravityDirection));
	}
}

FRotator UGravityInfluencedComponent::GetGravityRelativeRotation(FRotator Rotation, FVector GravityDirection)
{
	if (!GravityDirection.Equals(FVector::DownVector))
	{
		FQuat GravityRotation = FQuat::FindBetweenNormals(GravityDirection, FVector::DownVector);
		return (GravityRotation * Rotation.Quaternion()).Rotator();
	}

	return Rotation;
}

FRotator UGravityInfluencedComponent::GetGravityWorldRotation(FRotator Rotation, FVector GravityDirection)
{
	if (!GravityDirection.Equals(FVector::DownVector))
	{
		FQuat GravityRotation = FQuat::FindBetweenNormals(FVector::DownVector, GravityDirection);
		return (GravityRotation * Rotation.Quaternion()).Rotator();
	}

	return Rotation;
}

void UGravityInfluencedComponent::SetCurrentGravityField(UPrimitiveComponent* NewCurrentGravityField)
{
	if (!CurrentGravityField)
	{
		PlayerCharacter->GetCapsuleComponent()->SetEnableGravity(true);
		bUseGravity = true;
	}

	CurrentGravityField = NewCurrentGravityField;

	if (CurrentGravityField)
	{
		bUpdateGravityFieldInTick = IGravityInterface::Execute_ShouldBeUpdatedInTick(CurrentGravityField);
	}
	else
	{
		PlayerCharacter->GetCapsuleComponent()->SetEnableGravity(false);
		bUseGravity = false;
		bUpdateGravityFieldInTick = false;
	}

	Server_SetUseGravity(bUseGravity);
}

UPrimitiveComponent* UGravityInfluencedComponent::GetCurrentGravityField()
{
	return CurrentGravityField;
}

TArray<UPrimitiveComponent*>* UGravityInfluencedComponent::GetOverlappingGravityFields()
{
	return &OverlappingGravityFields;
}

void UGravityInfluencedComponent::Server_SetUseGravity_Implementation(bool bNewUseGravity)
{
	bUseGravity = bNewUseGravity;
}

void UGravityInfluencedComponent::Server_SetCurrentGravityDirection_Implementation(FVector NewCurrentGravityDirection)
{
	CurrentGravityDirection = NewCurrentGravityDirection;
	PlayerCharacter->GetCharacterMovement()->SetGravityDirection(CurrentGravityDirection);
}

void UGravityInfluencedComponent::OnRep_UseGravity()
{
	if (!PlayerCharacter->IsLocallyControlled())
	{
		PlayerCharacter->GetCapsuleComponent()->SetEnableGravity(bUseGravity);
	}
}

void UGravityInfluencedComponent::OnRep_CurrentGravityDirection()
{
	if (!PlayerCharacter->IsLocallyControlled())
	{
		PlayerCharacter->GetCharacterMovement()->SetGravityDirection(CurrentGravityDirection);
	}
}

Any idea about what I’m doing wrong or missing ?

[Metalbob]

I found what is the issue but it leads to some new problems.

I chose to follow the tutorial on a new fresh project based on the UE First Person template. I had to set up the Character as I did on my project (see the screen on the previous message). I played in the FirstPersonMap of the template and it worked only on some surfaces, the boxes in the map led me to the same behaviour as in my project, but it worked perfectly on the walls. I found out that it works on the boxes by setting their mobility to “static” or “stationary”.

But giving these values to the objects I want my character to walk on is a problem since it should be applied on orbiting objects that will need to move.

I’m thinking about setting my characters rotations manually. Or did someone knows a way to change the behaviour of the characters on movable objects ?

[Metalbob]

I found a fix to the problem on Movable surfaces, I overrid the OnRep_ReplicatedBasedMovement method on my character to be like this:

void ADeliveryShipCharacter::OnRep_ReplicatedBasedMovement()
{
	// Following the same pattern in AActor::OnRep_ReplicatedMovement() just in case...
	if (!IsReplicatingMovement())
	{
		return;
	}

	if (GetLocalRole() != ROLE_SimulatedProxy)
	{
		return;
	}

	// Skip base updates while playing root motion, it is handled inside of OnRep_RootMotion
	if (IsPlayingNetworkedRootMotionMontage())
	{
		return;
	}

	GetCharacterMovement()->bNetworkUpdateReceived = true;
	FGuardValue_Bitfield(bInBaseReplication, true);

	const bool bBaseChanged = (BasedMovement.MovementBase != ReplicatedBasedMovement.MovementBase || BasedMovement.BoneName != ReplicatedBasedMovement.BoneName);
	if (bBaseChanged)
	{
		// Even though we will copy the replicated based movement info, we need to use SetBase() to set up tick dependencies and trigger notifications.
		SetBase(ReplicatedBasedMovement.MovementBase, ReplicatedBasedMovement.BoneName);
	}

	// Make sure to use the values of relative location/rotation etc from the server.
	BasedMovement = ReplicatedBasedMovement;

	if (ReplicatedBasedMovement.HasRelativeLocation())
	{
		// Update transform relative to movement base
		const FVector OldLocation = GetActorLocation();
		const FQuat OldRotation = GetActorQuat();
		MovementBaseUtility::GetMovementBaseTransform(ReplicatedBasedMovement.MovementBase, ReplicatedBasedMovement.BoneName, GetCharacterMovement()->OldBaseLocation, GetCharacterMovement()->OldBaseQuat);
		const FTransform BaseTransform(GetCharacterMovement()->OldBaseQuat, GetCharacterMovement()->OldBaseLocation);
		const FVector NewLocation = BaseTransform.TransformPositionNoScale(ReplicatedBasedMovement.Location);
		FRotator NewRotation;

		if (ReplicatedBasedMovement.HasRelativeRotation())
		{
			// Relative location, relative rotation
			NewRotation = (FRotationMatrix(ReplicatedBasedMovement.Rotation) * FQuatRotationMatrix(GetCharacterMovement()->OldBaseQuat)).Rotator();
		}
		else
		{
			// Relative location, absolute rotation
			NewRotation = ReplicatedBasedMovement.Rotation;
		}

		// When position or base changes, movement mode will need to be updated. This assumes rotation changes don't affect that.
		GetCharacterMovement()->bJustTeleported |= (bBaseChanged || NewLocation != OldLocation);
		GetCharacterMovement()->bNetworkSmoothingComplete = false;
		GetCharacterMovement()->SmoothCorrection(OldLocation, OldRotation, NewLocation, NewRotation.Quaternion());
		OnUpdateSimulatedPosition(OldLocation, OldRotation);
	}
}

The content of this method is the same as the ACharacter version but I removed the part about keeping the Character vertical, and that’s it !