UE网络通信（四）RPC&移动通信

UFUNCTION(unreliable, server, WithValidation)
    void ServerMovePacked(const FCharacterServerMovePackedBits& PackedBits);

static FName NAME_ACharacter_ServerMovePacked = FName(TEXT("ServerMovePacked"));
    void ACharacter::ServerMovePacked(FCharacterServerMovePackedBits const& PackedBits)
    {
        Character_eventServerMovePacked_Parms Parms;
        Parms.PackedBits=PackedBits;
        ProcessEvent(FindFunctionChecked(NAME_ACharacter_ServerMovePacked),&Parms);
    }

<...>
        Connection = Actor->GetNetConnection();
        if (Connection)
        {
            InternalProcessRemoteFunction(Actor, SubObject, Connection, Function, Parameters, OutParms, Stack, bIsServer);
        }
        else
        {
            UE_LOG(LogNet, Warning, TEXT("UNetDriver::ProcessRemoteFunction: No owning connection for actor %s. Function %s will not be processed."), *Actor->GetName(), *Function->GetName());
        }
        <...>

UNetConnection* AActor::GetNetConnection() const
{
    return Owner ? Owner->GetNetConnection() : nullptr;
}
UNetConnection* APlayerController::GetNetConnection() const
{
    // A controller without a player has no "owner"
    return (Player != NULL) ? NetConnection : NULL;
}

1 They must be called from Actors.
2 The Actor must be replicated.
3 If the RPC is being called from server to be executed on a client, only the client who actually owns that Actor will execute the function.
4 If the RPC is being called from client to be executed on the server, the client must own the Actor that the RPC is being called on.
5 Multicast RPCs are an exception:

UNetDriver::ProcessRemoteFunctionForChannelPrivate
    void FRepLayout::SendPropertiesForRPC
        FRepLayout::SerializeProperties_r
            Cmd.Property->NetSerializeItem(Ar, Map, (Data + Cmd).Data))
    Ch->WriteFieldHeaderAndPayload(TempBlockWriter, ClassCache, FieldCache, NetFieldExportGroup, TempWriter);
        Bunch.WriteIntWrapped( FieldCache->FieldNetIndex, MaxFieldNetIndex );
        Bunch.SerializeIntPacked( NumPayloadBits );
        Bunch.SerializeBits( Payload.GetData(), NumPayloadBits );
    HeaderBits = Ch->WriteContentBlockPayload(TargetObj, Bunch, false, TempBlockWriter);
        WriteContentBlockHeader( Obj, Bunch, bHasRepLayout );
        Bunch.SerializeIntPacked( NumPayloadBits );
        Bunch.SerializeBits( Payload.GetData(), Payload.GetNumBits() );

APlayerController::TickActor
    APlayerController::PlayerTick
        APlayerController::TickPlayerInput
            APlayerController::ProcessPlayerInput
                UPlayerInput::ProcessInputStack
                    FInputAxisUnifiedDelegate::Execute
                        <绑定的按键响应函数>
                            APawn::AddMovementInput
                                UPawnMovementComponent::AddInputVector
                                    APawn::Internal_AddMovementInput

void APawn::Internal_AddMovementInput(FVector WorldAccel, bool bForce)
{
    if (bForce || !IsMoveInputIgnored())
    {
        ControlInputVector += WorldAccel;
    }
}

UCharacterMovementComponent::TickComponent
    UPawnMovementComponent::ConsumeInputVector()
    ControlledCharacterMove
        ScaleInputAcceleration
        ReplicateMoveToServer
            PerformMovement
                StartNewPhysics(DeltaSeconds, 0);
                    PhysWalking
                        CalcVelocity
                        MoveAlongFloor
                            ComputeGroundMovementDelta
                            SafeMoveUpdatedComponent
                                MoveUpdatedComponent
                                ResolvePenetration  // 解决穿透
                            if need: SlideAlongSurface

{
    LastControlInputVector = ControlInputVector;
    ControlInputVector = FVector::ZeroVector;
    return LastControlInputVector;
}

FVector UCharacterMovementComponent::ScaleInputAcceleration(const FVector& InputAcceleration) const
{
    return GetMaxAcceleration() * InputAcceleration.GetClampedToMaxSize(1.0f);
}

FORCEINLINE FVector FVector::GetClampedToMaxSize(float MaxSize) const
{
    if (MaxSize < KINDA_SMALL_NUMBER)
    {
        return FVector::ZeroVector;
    }

    const float VSq = SizeSquared();
    if (VSq > FMath::Square(MaxSize))
    {
        const float Scale = MaxSize * FMath::InvSqrt(VSq);
        return FVector(X*Scale, Y*Scale, Z*Scale);

瞬时速度公式 v=v0+at;
位移公式 x=v0t+½at²;
平均速度 v=x/t=(v0+v)/2
导出公式 v²-v0²=2ax
加速度 a=(v-v0)/t

FMath::Min(MaxSimulationTimeStep, RemainingTime * 0.5f);

UCharacterMovementComponent::TickComponent
    UPawnMovementComponent::ConsumeInputVector()
    ControlledCharacterMove
        ScaleInputAcceleration
        ReplicateMoveToServer
            FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
            ClientData->UpdateTimeStampAndDeltaTime
                CurrentTimeStamp += DeltaTime;

            FSavedMove_Character::SetMoveFor
                SetInitialPosition
                TimeStamp = ClientData.CurrentTimeStamp;            

            CanCombile // 加速度夹角小于5度（0加速度，和任意加速度夹角可以认为是90度）
                Combine With Pending // 二次模拟

            PerformMovement

            FSavedMove_Character::PostUpdate    

            CallServerMovePacked
                FCharacterNetworkMoveData::ClientFillNetworkMoveData //  FSavedMove_Character-->FCharacterNetworkMoveData

struct ENGINE_API FCharacterNetworkMoveData
{
    ENetworkMoveType NetworkMoveType;
    float TimeStamp;
    FVector_NetQuantize10 Acceleration;
    FVector_NetQuantize100 Location;        // Either world location or relative to MovementBase if that is set.
    FRotator ControlRotation;
    uint8 CompressedMoveFlags;

    class UPrimitiveComponent* MovementBase;
    FName MovementBaseBoneName;
    uint8 MovementMode;
};

struct ENGINE_API FCharacterNetworkMoveData
{
    <...>
    float TimeStamp;
    <...>
};

void FCharacterNetworkMoveData::ClientFillNetworkMoveData(const FSavedMove_Character&amp; ClientMove, FCharacterNetworkMoveData::ENetworkMoveType MoveType)
{
    <...>
    TimeStamp = ClientMove.TimeStamp;
    <...>
}

struct ENGINE_API FSavedMove_Character
{
    <...>
    float TimeStamp;
    <...>
};

void FSavedMove_Character::SetMoveFor(ACharacter* Character, float InDeltaTime, FVector const&amp; NewAccel, class FNetworkPredictionData_Client_Character &amp; ClientData)
{
    <...>
    TimeStamp = ClientData.CurrentTimeStamp;
}

float FNetworkPredictionData_Client_Character::UpdateTimeStampAndDeltaTime(float DeltaTime, class ACharacter & CharacterOwner, class UCharacterMovementComponent & CharacterMovementComponent)
{
    // Reset TimeStamp regularly to combat float accuracy decreasing over time.
    if( CurrentTimeStamp > CharacterMovementComponent.MinTimeBetweenTimeStampResets )
    {
        UE_LOG(LogNetPlayerMovement, Log, TEXT("Resetting Client's TimeStamp %f"), Current
        <...>
    }

    // Update Current TimeStamp.
    CurrentTimeStamp += DeltaTime;
    <...>
}

ServerMove_PerformMovement
    VerifyClientTimeStamp
        IsClientTimeStampValid
        if Valid:
            ProcessClientTimeStampForTimeDiscrepancy  // Discrepancy 差异
                if (...) ServerData.bForceClientUpdate = true

void UEngine::UpdateTimeAndHandleMaxTickRate()
{
    <...>
    static double LastRealTime = FPlatformTime::Seconds() - 0.0001;

    <...>
        // Updates logical time to real time, this may be changed by fixed frame rate below
        double CurrentRealTime = FPlatformTime::Seconds();
        FApp::SetCurrentTime(CurrentRealTime);
        <...>
        // Calculate delta time, this is in real time seconds
        float DeltaRealTime = CurrentRealTime - LastRealTime;
    <...>
}

void UWorld::Tick( ELevelTick TickType, float DeltaSeconds )
{
    <...>
    // Update time.
    RealTimeSeconds += DeltaSeconds;

    <...>
}

FORCEINLINE_DEBUGGABLE float UWorld::GetRealTimeSeconds() const
{
    checkSlow(!IsInActualRenderingThread());
    return RealTimeSeconds;
}

static FORCEINLINE double Seconds()
    {
        struct timespec ts;
        clock_gettime(ClockSource, &ts);
        return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) / 1e9;
    }

Clocks[] =
        {
            { CLOCK_REALTIME, "CLOCK_REALTIME", 0 },
            { CLOCK_MONOTONIC, "CLOCK_MONOTONIC", 0 },
            { CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW", 0 },
            { CLOCK_MONOTONIC_COARSE, "CLOCK_MONOTONIC_COARSE", 0 }
        };

ServerMove_PerformMovement
    VerifyClientTimeStamp
        IsClientTimeStampValid
        if Valid:
            ProcessClientTimeStampForTimeDiscrepancy  // Discrepancy 差异
                if (...) ServerData.bForceClientUpdate = true
    MoveAutonomous
        PerformMovement
    ServerMoveHandleClientError when NewMove
        ServerData->bForceClientUpdate || ServerCheckClientError
            ServerExceedsAllowablePositionError
        ServerShouldUseAuthoritativePosition

SendClientAdjustment
    ServerData->PendingAdjustment.bAckGoodMove 
        ServerSendMoveResponse(ServerData->PendingAdjustment);
    !ServerData->PendingAdjustment.bAckGoodMove 
        ServerSendMoveResponse
            MoveResponsePacked_ServerSend
                Character::ClientMoveResponsePacked
                    MoveResponsePacked_ClientReceive
                        ClientHandleMoveResponse
                            if good
                                ClientAckGoodMove_Implementation
                                    ClientData->AckMove
                            if bad
                                ClientAdjustPosition_Implementation
                                    ClientData->AckMove
                                    OnClientCorrectionReceived
                                        ClientData->bUpdatePosition

struct FRepMovement ReplicatedMovement;