Best way to replicate destructibles

Development Programming & Scripting C++
4

Hi everyone,

I managed to set up a system which I think works pretty well. I am using a class that extends ADestructibleActor.

I created a new USTRUCT called FDestructibleReplicatedHit which looks like this:



// Shortened for brevity
struct FDestructibleReplicatedHit
{
     FVector DamageLocation;
     FVector DamageDirection;
     const class UDamageType* DamageType;
     float HitDamage;
     float HitTime;
}

The HitTime acts as a timestamp and will be referenced later. I then added a TArray of FDestructibleDamageEvent objects which is replicated, and also uses a RepNotify function called OnRep_ReplicatedHits. I also have a float called latestDamageTimestamp, which will be used by the receiving client in conjunction with a replicated hit’s HitTime to determine if it needs to be processed or not:



    UPROPERTY(Replicated, ReplicatedUsing = OnRep_ReplicatedHits)
        TArray<FDestructibleReplicatedHit> replicatedHits;

    UFUNCTION()
    void OnRep_ReplicatedHits();

    float latestDamageTimestamp = 0.0f;

Next, I added some helper functions to determine if the DestructibleMesh object accumulates damage, and to find out what the damage threshold is:



bool AWaTDestructibleActor::GetAccumulatesDamage() {
    return GetDestructibleComponent()->GetDestructibleMesh()->DefaultDestructibleParameters.Flags.bAccumulateDamage;
}

float AWaTDestructibleActor::GetDamageThreshold() {
    return GetDestructibleComponent()->GetDestructibleMesh()->DefaultDestructibleParameters.DamageParameters.DamageThreshold;
}

I then added an event to listen out for OnTakePointDamage in the constructor:



AWaTDestructibleActor::AWaTDestructibleActor()
{

    bReplicates = true;
    OnTakePointDamage.AddDynamic(this, &AWaTDestructibleActor::ReceivedPointDamage);
}

And then I wrote the ReceivedPointDamage function like so:



void AWaTDestructibleActor::ReceivedPointDamage(AActor* DamagedActor, float Damage, class AController* InstigatedBy, FVector HitLocation, class UPrimitiveComponent* FHitComponent, FName BoneName, FVector ShotFromDirection, const UDamageType* DamageType, AActor* DamageCauser) {
    if (HasAuthority()) {
        if (Damage > GetDamageThreshold() || (Damage > 0.0f && GetAccumulatesDamage())) {

            float hitTimeStamp = GetWorld()->GetRealTimeSeconds();

            FDestructibleReplicatedHit newEvent(HitLocation, ShotFromDirection, DamageType, Damage, hitTimeStamp);

            replicatedHits.Add(newEvent);
        }
    }
}

You’ll see here that it only replicates a hit if the mesh accumulates damage OR if the damage is greater than the damage threshold. We ignore hits if the mesh doesn’t accumulate damage and it’s below the threshold since it doesn’t materially affect the mesh (I handle impact effects elsewhere).

Finally, this is the onrep function:



void AWaTDestructibleActor::OnRep_ReplicatedHits() {
    float newLatestTimestamp = latestDamageTimestamp;

    for (FDestructibleReplicatedHit currEvent : replicatedHits) {
        if (currEvent.HitTime > latestDamageTimestamp) {
            GetDestructibleComponent()->ApplyDamage(currEvent.HitDamage, currEvent.DamageLocation, currEvent.DamageDirection, currEvent.DamageType->DestructibleImpulse);
            if (currEvent.HitTime > newLatestTimestamp) {
                newLatestTimestamp = currEvent.HitTime;
            }
        }
    }
    latestDamageTimestamp = newLatestTimestamp;
}

You’ll see here that it checks through the array and only picks replicated hits with a timestamp later than the last time it checked. That way, there’s no need to try and sync the server and client world times, it will just base it on the server. A new joiner to the game will have latestDamageTimestamp defaulted to 0, so all hits in the array will be process. A player who was out of replication for a bit and then comes back will just pick up the new ones since the actor was last relevant.

Haven’t tried it on the live server yet, but from what I can see this should work :slight_smile:

Some additional thoughts:

  • If you’re not fussed about the impulse applied to destructible objects, you could cut the DamageType from the struct to cut down on size
  • I also plan to netquantize the FVectors to further reduce the size
  • You could also replace the timestamp with a uint16 which increments every time a hit is registered, which would give you 65535 potential values and cuts the size down by another 2 bytes (I think floats are 4 bytes in size, aren’t they?)