CharacterMovementReplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "Engine/NetSerialization.h"
#include "Serialization/BitWriter.h"
#include "Containers/BitArray.h"
#include "Net/Core/NetToken/NetTokenExportContext.h"
#include "Components/PrimitiveComponent.h"
#include "Iris/Serialization/IrisObjectReferencePackageMap.h"
 
#include "CharacterMovementReplication.generated.h"
 
class UPackageMap;
class FSavedMove_Character;
class UCharacterMovementComponent;
struct FRootMotionSourceGroup;
 
// If defined and not zero, deprecated RPCs on UCharacterMovementComponent will not be marked deprecated at compile time, to aid in migration of older projects. New projects should prefer the new API.
#ifndef SUPPORT_DEPRECATED_CHARACTER_MOVEMENT_RPCS
#define SUPPORT_DEPRECATED_CHARACTER_MOVEMENT_RPCS 0
#endif
 
#if SUPPORT_DEPRECATED_CHARACTER_MOVEMENT_RPCS
#define DEPRECATED_CHARACTER_MOVEMENT_RPC(...)
#else
#define DEPRECATED_CHARACTER_MOVEMENT_RPC(DeprecatedFunction, NewFunction) UE_DEPRECATED_FORGAME(4.26, #DeprecatedFunction "() is deprecated, use " #NewFunction "() instead, or define SUPPORT_DEPRECATED_CHARACTER_MOVEMENT_RPCS=1 in the project and set CVar p.NetUsePackedMovementRPCs=0 to use the old code path.")
#endif
 
// Number of bits to reserve in serialization container. Make this large enough to try to avoid re-allocation during the worst case RPC calls (dual move + unacknowledged "old important" move).
#ifndef CHARACTER_SERIALIZATION_PACKEDBITS_RESERVED_SIZE
#define CHARACTER_SERIALIZATION_PACKEDBITS_RESERVED_SIZE 1024
#endif
 
 
USTRUCT()
struct FCharacterNetworkSerializationPackedBits
{
    GENERATED_USTRUCT_BODY()
 
    FCharacterNetworkSerializationPackedBits()
        : SavedPackageMap(nullptr)
    {
    }
 
    ENGINE_API bool NetSerialize(FArchive& Ar, UPackageMap* PackageMap, bool& bOutSuccess);
    UPackageMap* GetPackageMap() const { return SavedPackageMap; }
 
    //------------------------------------------------------------------------
    // Data
 
    // TInlineAllocator used with TBitArray takes the number of 32-bit dwords, but the define is in number of bits, so convert here by dividing by 32.
    TBitArray<TInlineAllocator<CHARACTER_SERIALIZATION_PACKEDBITS_RESERVED_SIZE / NumBitsPerDWORD>> DataBits;
 
    // Since this struct uses custom serialization path we need to explicitly capture exports in order to forward them to iris
    // This is managed by the use of a custom packagemap.
    UE::Net::FIrisPackageMapExports PackageMapExports;
 
    // Since we capturing data outside of the normal serialization path we also need to store exports to inject when actually sending the data.
    UE::Net::FNetTokenExportContext::FNetTokenExports NetTokensPendingExport;
 
private:
    UPackageMap* SavedPackageMap;
};
 
template<>
struct TStructOpsTypeTraits<FCharacterNetworkSerializationPackedBits> : public TStructOpsTypeTraitsBase2<FCharacterNetworkSerializationPackedBits>
{
    enum
    {
        WithNetSerializer = true,
    };
};
 
 
// Client to Server movement data
 
struct FCharacterNetworkMoveData
{
public:
 
    enum class ENetworkMoveType
    {
        NewMove,
        PendingMove,
        OldMove
    };
 
    FCharacterNetworkMoveData()
        : NetworkMoveType(ENetworkMoveType::NewMove)
        , TimeStamp(0.f)
        , Acceleration(ForceInitToZero)
        , Location(ForceInitToZero)
        , ControlRotation(ForceInitToZero)
        , CompressedMoveFlags(0)
        , MovementMode(0)
        , MovementBase(nullptr)
        , MovementBaseBoneName(NAME_None)
    {
    }
    
    virtual ~FCharacterNetworkMoveData()
    {
    }
 
    ENGINE_API virtual void ClientFillNetworkMoveData(const FSavedMove_Character& ClientMove, ENetworkMoveType MoveType);
 
    ENGINE_API virtual bool Serialize(UCharacterMovementComponent& CharacterMovement, FArchive& Ar, UPackageMap* PackageMap, ENetworkMoveType MoveType);
 
    // Indicates whether this was the latest new move, a pending/dual move, or old important move.
    ENetworkMoveType NetworkMoveType;
 
    //------------------------------------------------------------------------
    // Basic movement data.
 
    float TimeStamp;
    FVector_NetQuantize10 Acceleration;
    FVector_NetQuantize100 Location;        // Either world location or relative to MovementBase if that is set.
    FRotator ControlRotation;
    uint8 CompressedMoveFlags;
 
    uint8 MovementMode;
    class UPrimitiveComponent* MovementBase;
    FName MovementBaseBoneName;
};
 
 
 
struct FCharacterNetworkMoveDataContainer
{
public:
 
    FCharacterNetworkMoveDataContainer()
        : bHasPendingMove(false)
        , bIsDualHybridRootMotionMove(false)
        , bHasOldMove(false)
        , bDisableCombinedScopedMove(false)
    {
        NewMoveData     = &BaseDefaultMoveData[0];
        PendingMoveData = &BaseDefaultMoveData[1];
        OldMoveData     = &BaseDefaultMoveData[2];
    }
 
    virtual ~FCharacterNetworkMoveDataContainer()
    {
    }
 
    ENGINE_API virtual void ClientFillNetworkMoveData(const FSavedMove_Character* ClientNewMove, const FSavedMove_Character* ClientPendingMove, const FSavedMove_Character* ClientOldMove);
 
    ENGINE_API virtual bool Serialize(UCharacterMovementComponent& CharacterMovement, FArchive& Ar, UPackageMap* PackageMap);
 
    //------------------------------------------------------------------------
    // Basic movement data. NewMoveData is the most recent move, PendingMoveData is a move right before it (dual move). OldMoveData is an "important" move not yet acknowledged.
 
    inline FCharacterNetworkMoveData* GetNewMoveData() const        { return NewMoveData; }
    inline FCharacterNetworkMoveData* GetPendingMoveData() const    { return PendingMoveData; }
    inline FCharacterNetworkMoveData* GetOldMoveData() const        { return OldMoveData; }
 
    //------------------------------------------------------------------------
    // Optional pending data used in "dual moves".
    bool bHasPendingMove;
    bool bIsDualHybridRootMotionMove;
    
    // Optional "old move" data, for redundant important old moves not yet ack'd.
    bool bHasOldMove;
 
    // True if we want to disable a scoped move around both dual moves (optional from bEnableServerDualMoveScopedMovementUpdates), typically set if bForceNoCombine was true which can indicate an important change in moves.
    bool bDisableCombinedScopedMove;
    
protected:
 
    FCharacterNetworkMoveData* NewMoveData;
    FCharacterNetworkMoveData* PendingMoveData; // Only valid if bHasPendingMove is true
    FCharacterNetworkMoveData* OldMoveData;     // Only valid if bHasOldMove is true
 
private:
 
    FCharacterNetworkMoveData BaseDefaultMoveData[3];
};
 
 
 
USTRUCT()
struct FCharacterServerMovePackedBits : public FCharacterNetworkSerializationPackedBits
{
    GENERATED_USTRUCT_BODY()
    FCharacterServerMovePackedBits() {}
};
 
template<>
struct TStructOpsTypeTraits<FCharacterServerMovePackedBits> : public TStructOpsTypeTraitsBase2<FCharacterServerMovePackedBits>
{
    enum
    {
        WithNetSerializer = true,
    };
};
 
 
// Server to Client response
 
// ClientAdjustPosition replication (event called at end of frame by server)
struct FClientAdjustment
{
public:
 
    FClientAdjustment()
        : TimeStamp(0.f)
        , DeltaTime(0.f)
        , NewLoc(ForceInitToZero)
        , NewVel(ForceInitToZero)
        , NewRot(ForceInitToZero)
        , GravityDirection(FVector::DownVector)
        , NewBase(NULL)
        , NewBaseBoneName(NAME_None)
        , bAckGoodMove(false)
        , bBaseRelativePosition(false)
        , bBaseRelativeVelocity(false)
        , MovementMode(0)
    {
    }
 
    float TimeStamp;
    float DeltaTime;
    FVector NewLoc; // Note: if bBaseRelativePosition is set, this is a relative location to the Movement base.
    FVector NewVel; // Note: if bBaseRelativeVelocity is set, this is a relative velocity to the Movement base.
    FRotator NewRot;
    FVector GravityDirection;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    TObjectPtr<UPrimitiveComponent> NewBase;
#else
    UPrimitiveComponent* NewBase;
#endif
    FName NewBaseBoneName;
    bool bAckGoodMove;
    bool bBaseRelativePosition;
    bool bBaseRelativeVelocity;
    uint8 MovementMode;
 
    void Serialize(FArchive& Archive)
    {
        if (Archive.IsMigratingRemoteObjects())
        {
            Archive << TimeStamp;
            Archive << DeltaTime;
            Archive << NewLoc;
            Archive << NewVel;
            Archive << NewRot;
            Archive << GravityDirection;
            Archive << NewBase;
            Archive << NewBaseBoneName;
            Archive.SerializeBits(&bAckGoodMove, 1);
            Archive.SerializeBits(&bBaseRelativePosition, 1);
            Archive.SerializeBits(&bBaseRelativeVelocity, 1);
            Archive << MovementMode;
        }
    }
};
 
 
 
struct FCharacterMoveResponseDataContainer
{
public:
 
    FCharacterMoveResponseDataContainer()
        : bHasBase(false)
        , bHasRotation(false)
        , bRootMotionMontageCorrection(false)
        , bRootMotionSourceCorrection(false)
        , RootMotionTrackPosition(-1.0f)
        , RootMotionRotation(ForceInitToZero)
    {
    }
 
    virtual ~FCharacterMoveResponseDataContainer()
    {
    }
 
    ENGINE_API virtual void ServerFillResponseData(const UCharacterMovementComponent& CharacterMovement, const FClientAdjustment& PendingAdjustment);
 
    ENGINE_API virtual bool Serialize(UCharacterMovementComponent& CharacterMovement, FArchive& Ar, UPackageMap* PackageMap);
 
    bool IsGoodMove() const     { return ClientAdjustment.bAckGoodMove;}
    bool IsCorrection() const   { return !IsGoodMove(); }
 
    ENGINE_API FRootMotionSourceGroup* GetRootMotionSourceGroup(UCharacterMovementComponent& CharacterMovement) const;
 
    bool bHasBase;
    bool bHasRotation; // By default ClientAdjustment.NewRot is not serialized. Set this to true after base ServerFillResponseData if you want Rotation to be serialized.
    bool bRootMotionMontageCorrection;
    bool bRootMotionSourceCorrection;
 
    // Client adjustment. All data other than bAckGoodMove and TimeStamp is only valid if this is a correction (not an ack).
    FClientAdjustment ClientAdjustment;
 
    float RootMotionTrackPosition;
    FVector_NetQuantizeNormal RootMotionRotation;
};
 
 
USTRUCT()
struct FCharacterMoveResponsePackedBits : public FCharacterNetworkSerializationPackedBits
{
    GENERATED_USTRUCT_BODY()
    FCharacterMoveResponsePackedBits() {}
};
 
template<>
struct TStructOpsTypeTraits<FCharacterMoveResponsePackedBits> : public TStructOpsTypeTraitsBase2<FCharacterMoveResponsePackedBits>
{
    enum
    {
        WithNetSerializer = true,
    };
};