Replicated Physics Plugin

My implementation of replicated physics objects in Unreal Engine for multiplayer games. Please check out the attached repository with the source code for more details!

GitHub

Creating a Robust Replicated Physics Plugin in Unreal Engine

Developing a robust replicated physics plugin for Unreal Engine has been an awesome journey filled with both achievements and challenges. I want to share my experiences and insights, along with some demonstration videos showcasing the plugin in action.

What Does the Replicated Physics Plugin Achieve?

The main goal of the replicated physics plugin is to ensure that physics interactions are accurately and efficiently synchronized across the network in a multiplayer environment. Here's a breakdown of what it accomplishes:

  • Efficient Replication: The plugin ensures that physics-based actors replicate their movements and interactions smoothly across all connected clients.
  • Custom Replication System: Instead of relying on Unreal Engine's default replication system, this plugin uses a custom replication system tailored for better performance and precision.
  • High-Frequency Updates: It supports a minimum replication update frequency of 30 Hz to avoid the massive slowdowns that occur with lower update rates.

Key Features

1. Custom Replication Logic

The core of this plugin lies in its custom replication logic. By overriding Unreal Engine's default behavior, we can better control what and how data is replicated. This approach helps maintain performance while ensuring that all physics interactions are accurately represented on all clients.

void AReplicatedPhysicsActor::GatherCurrentMovement()
{
    
	if (IsReplicatingMovement() || (RootComponent && RootComponent->GetAttachParent()))
	{
		bool bWasAttachmentModified = false;
		bool bWasRepMovementModified = false;
 
		AActor* OldAttachParent = AttachmentWeldReplication.AttachParent;
		USceneComponent* OldAttachComponent = AttachmentWeldReplication.AttachComponent;
 
		AttachmentWeldReplication.AttachParent = nullptr;
		AttachmentWeldReplication.AttachComponent = nullptr;
 
		FRepMovement& RepMovement = GetReplicatedMovement_Mutable();
 
		UPrimitiveComponent* RootPrimComp = Cast<UPrimitiveComponent>(GetRootComponent());
		if (RootPrimComp && RootPrimComp->IsSimulatingPhysics())
		{
#if UE_WITH_IRIS
			const bool bPrevRepPhysics = GetReplicatedMovement_Mutable().bRepPhysics;
#endif // UE_WITH_IRIS
 
			bool bFoundInCache = false;
 
			UWorld* World = GetWorld();
			int ServerFrame = 0;
			if (FPhysScene_Chaos* Scene = static_cast<FPhysScene_Chaos*>(World->GetPhysicsScene()))
			{
				if (const FRigidBodyState* FoundState = Scene->GetStateFromReplicationCache(RootPrimComp, ServerFrame))
				{
					RepMovement.FillFrom(*FoundState, this, Scene->ReplicationCache.ServerFrame);
					bFoundInCache = true;
				}
			}
 
			if (!bFoundInCache)
			{
				// fallback to GT data
				FRigidBodyState RBState;
				RootPrimComp->GetRigidBodyState(RBState);
				RepMovement.FillFrom(RBState, this, 0);
			}
 
			// Don't replicate movement if we're welded to another parent actor.
			// Their replication will affect our position indirectly since we are attached.
			RepMovement.bRepPhysics = !RootPrimComp->IsWelded();
 
			if (!RepMovement.bRepPhysics)
			{
				if (RootComponent->GetAttachParent() != nullptr)
				{
					// Networking for attachments assumes the RootComponent of the AttachParent actor. 
					// If that's not the case, we can't update this, as the client wouldn't be able to resolve the Component and would detach as a result.
					AttachmentWeldReplication.AttachParent = RootComponent->GetAttachParent()->GetAttachmentRootActor();
					if (AttachmentWeldReplication.AttachParent != nullptr)
					{
						AttachmentWeldReplication.LocationOffset = RootComponent->GetRelativeLocation();
						AttachmentWeldReplication.RotationOffset = RootComponent->GetRelativeRotation();
						AttachmentWeldReplication.RelativeScale3D = RootComponent->GetRelativeScale3D();
						AttachmentWeldReplication.AttachComponent = RootComponent->GetAttachParent();
						AttachmentWeldReplication.AttachSocket = RootComponent->GetAttachSocketName();
						AttachmentWeldReplication.bIsWelded = RootPrimComp ? RootPrimComp->IsWelded() : false;
 
						// Technically, the values might have stayed the same, but we'll just assume they've changed.
						bWasAttachmentModified = true;
					}
				}
			}
 
			// Technically, the values might have stayed the same, but we'll just assume they've changed.
			bWasRepMovementModified = true;
 
#if UE_WITH_IRIS
			// If RepPhysics has changed value then notify the ReplicationSystem
			if (bPrevRepPhysics != GetReplicatedMovement_Mutable().bRepPhysics)
			{
				UpdateReplicatePhysicsCondition();
			}
#endif // UE_WITH_IRIS
		}
		else if (RootComponent != nullptr)
		{
			// If we are attached, don't replicate absolute position, use AttachmentReplication instead.
			if (RootComponent->GetAttachParent() != nullptr)
			{
				// Networking for attachments assumes the RootComponent of the AttachParent actor. 
				// If that's not the case, we can't update this, as the client wouldn't be able to resolve the Component and would detach as a result.
				AttachmentWeldReplication.AttachParent = RootComponent->GetAttachParentActor();
				if (AttachmentWeldReplication.AttachParent != nullptr)
				{
					AttachmentWeldReplication.LocationOffset = RootComponent->GetRelativeLocation();
					AttachmentWeldReplication.RotationOffset = RootComponent->GetRelativeRotation();
					AttachmentWeldReplication.RelativeScale3D = RootComponent->GetRelativeScale3D();
					AttachmentWeldReplication.AttachComponent = RootComponent->GetAttachParent();
					AttachmentWeldReplication.AttachSocket = RootComponent->GetAttachSocketName();
					AttachmentWeldReplication.bIsWelded = RootPrimComp ? RootPrimComp->IsWelded() : false;
 
					// Technically, the values might have stayed the same, but we'll just assume they've changed.
					bWasAttachmentModified = true;
				}
			}
			else
			{
				RepMovement.Location = FRepMovement::RebaseOntoZeroOrigin(RootComponent->GetComponentLocation(), this);
				RepMovement.Rotation = RootComponent->GetComponentRotation();
				RepMovement.LinearVelocity = GetVelocity();
				RepMovement.AngularVelocity = FVector::ZeroVector;
 
				// Technically, the values might have stayed the same, but we'll just assume they've changed.
				bWasRepMovementModified = true;
			}
 
			bWasRepMovementModified = (bWasRepMovementModified || RepMovement.bRepPhysics);
			RepMovement.bRepPhysics = false;
		}
#if WITH_PUSH_MODEL
		if (bWasRepMovementModified)
		{
			MARK_PROPERTY_DIRTY_FROM_NAME(AActor, ReplicatedMovement, this);
		}
 
		if (bWasAttachmentModified ||
			OldAttachParent != AttachmentWeldReplication.AttachParent ||
			OldAttachComponent != AttachmentWeldReplication.AttachComponent)
		{
			MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, AttachmentWeldReplication, this);
		}
#endif
	}
}

2. Push Model for Property Replication

Using the push model for property replication ensures that only the changes in properties are sent over the network, reducing unnecessary data transmission and improving efficiency.

void AReplicatedPhysicsActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
    FDoRepLifetimeParams PushModelParams{COND_None, REPNOTIFY_OnChanged, /*bIsPushBased=*/true};
    DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, bAllowIgnoringAttachOnOwner, PushModelParams);
    DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, ClientAuthReplicationData, PushModelParams);
}

3. Physics Bucket Update Subsystem

The plugin includes a subsystem that manages the update of physics objects in buckets, ensuring that high-frequency updates are handled efficiently.

bool UPhysicsBucketUpdateSubsystem::AddObjectToBucket(int32 UpdateHTZ, UObject* InObject, FName FunctionName)
{
    if (!InObject || UpdateHTZ < 1)
        return false;
    return BucketContainer.AddBucketObject(UpdateHTZ, InObject, FunctionName);
}

Challenges Faced

Network Latency and Precision

One of the significant challenges was handling network latency and ensuring precision in physics calculations across all clients. Achieving a balance between performance and accuracy required fine-tuning the update rates and replication intervals.

Attachment Replication

Another challenge was correctly replicating the attachment and detachment of physics actors. Ensuring that the state of attached objects remained consistent across the network involved meticulous handling of attachment replication.

void AReplicatedPhysicsActor::OnRep_AttachmentReplication()
{
    if (AttachmentWeldReplication.AttachParent)
    {
        if (RootComponent)
        {
            // Handle attachment replication...
        }
    }
    else
    {
        DetachFromActor(FDetachmentTransformRules::KeepWorldTransform);
        // Additional logic for handling detachment...
    }
}

Demonstration Videos

Late Join Object Replication

This video demonstrates a late join scenario where a physics object is replicated across all clients, maintaining synchronization even after joining the game.

Late Join MANY OBJECTS Replicated

This video demonstrates the same thing, but with an excessive number of replicated physics objects to showcase the plugin's efficiency.