ue5.4.4 Mover
官方意识到charactermovement复杂性，所以想从根本层面上去解决，于是就有了mover这个新架构
首先mover的网络同步功能依赖的就是choas的网络同步功能，
mover把input带进物理引擎中计算速度位移等，然后把计算出的位移等信息通过物理引擎的同步，同步给每个端。
同时mover也把各种运动方式，抽象出来，像搭积木的方式配置给actor，比如游泳模式，飞行模式，spline模式，每个模式都是单独的。
这种全新的架构，确实清晰简化了不少，确实是颠覆性的，但是稳定性和架构的完善性还有待考验。
---------------------------------------------------------------------------------
关于RootMotionSource
1 RootMotionSource和动画的RootMotion是互斥的
RootMotionSource作用是能持续一段时间影响updatecom的速度和旋转
如上图FRootMotionSourceGroup作为管理多个RootMotionSource的容器
具体
当通过CharacerMovement组件的ApplyRootMotionSource添加一个Source的时候，这个Source是添加到CurrentRootMotion里面的。
在PerformMovement每帧更新中 先运行CurrentRootMotion.PrepareRootMotion
计算出这一帧所有source的RootMotionParams
然后在下面的StartNewPhysics 中各种physxxxxx中调用
ApplyRootMotionToVelocity
然后通过
CurrentRootMotion.AccumulateOverrideRootMotionVelocity
CurrentRootMotion.AccumulateAdditiveRootMotionVelocity
影响速度
然后通过
CurrentRootMotion.GetOverrideRootMotionRotation
影响旋转
以上没有提及到网络同步的情况
rootmotionsource的同步和其他同步流程一样，也是跟随savedmove一起发送给server
但是server矫正client的时候用packed的方式的时候并不传送rootmotion信息给client
FRootMotionSourceGroup里面Source的生命周期管理
每帧都会调用PrepareRootMotion
有一个settime方法，里面根据时间设置此source是否finished
然后每帧都会去掉finished的source
详细的源码分析
uint16 UCharacterMovementComponent::ApplyRootMotionSource(TSharedPtr<FRootMotionSource> SourcePtr)
{
//如果开始时间不对，就更新开始时间
if (ensure(SourcePtr.IsValid()))
{
// Set default StartTime if it hasn't been set manually
if (!SourcePtr->IsStartTimeValid())
{
if (CharacterOwner)
{
if (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy)
{
// Autonomous defaults to local timestamp
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (ClientData)
{
SourcePtr->StartTime = ClientData->CurrentTimeStamp;
}
}
else if (CharacterOwner->GetLocalRole() == ROLE_Authority && !IsNetMode(NM_Client))
{
// Authority defaults to current client time stamp, meaning it'll start next tick if not corrected
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
if (ServerData)
{
SourcePtr->StartTime = ServerData->CurrentClientTimeStamp;
}
}
}
}
OnRootMotionSourceBeingApplied(SourcePtr.Get());
//加到CurrentRootMotion中
return CurrentRootMotion.ApplyRootMotionSource(SourcePtr);
}
return (uint16)ERootMotionSourceID::Invalid;
}
uint16 FRootMotionSourceGroup::ApplyRootMotionSource(TSharedPtr<FRootMotionSource> SourcePtr)
{
if (ensure(SourcePtr.IsValid()))
{
// Get valid localID
// Note: Current ID method could produce duplicate IDs "in flight" at one time
// if you have one root motion source applied while 2^16-1 other root motion sources
// get applied and it's still applied and it happens that the 2^16-1th root motion
// source is applied on this character movement component.
// This was preferred over the complexity of ensuring unique IDs.
static uint16 LocalIDGenerator = 0;
uint16 LocalID = ++LocalIDGenerator;
if (LocalID == (uint16)ERootMotionSourceID::Invalid)
{
LocalID = ++LocalIDGenerator;
}
SourcePtr->LocalID = LocalID;
//先添加到pending容器中，等下一帧 会把pending合并到正式的Source容器中，然后清空pengding
// Apply to pending so that next Prepare it gets added to "active"
PendingAddRootMotionSources.Add(SourcePtr);
UE_LOG(LogRootMotion, VeryVerbose, TEXT("RootMotionSource added to Pending: [%u] %s"), LocalID, *SourcePtr->ToSimpleString());
return LocalID;
}
return (uint16)ERootMotionSourceID::Invalid;
}
//不管是author还是主控端 每帧都会执行PerformMovement
void UCharacterMovementComponent::PerformMovement(float DeltaSeconds)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementPerformMovement);
const UWorld* MyWorld = GetWorld();
if (!HasValidData() || MyWorld == nullptr)
{
return;
}
bTeleportedSinceLastUpdate = UpdatedComponent->GetComponentLocation() != LastUpdateLocation;
// no movement if we can't move, or if currently doing physical simulation on UpdatedComponent
if (MovementMode == MOVE_None || UpdatedComponent->Mobility != EComponentMobility::Movable || UpdatedComponent->IsSimulatingPhysics())
{
if (!CharacterOwner->bClientUpdating && !CharacterOwner->bServerMoveIgnoreRootMotion)
{
// Consume root motion
if (CharacterOwner->IsPlayingRootMotion() && CharacterOwner->GetMesh())
{
TickCharacterPose(DeltaSeconds);
RootMotionParams.Clear();
}
if (CurrentRootMotion.HasActiveRootMotionSources())
{
CurrentRootMotion.Clear();
}
}
// Clear pending physics forces
ClearAccumulatedForces();
return;
}
// Force floor update if we've moved outside of CharacterMovement since last update.
bForceNextFloorCheck |= (IsMovingOnGround() && bTeleportedSinceLastUpdate);
// Update saved LastPreAdditiveVelocity with any external changes to character Velocity that happened since last update.
if( CurrentRootMotion.HasAdditiveVelocity() )
{
const FVector Adjustment = (Velocity - LastUpdateVelocity);
CurrentRootMotion.LastPreAdditiveVelocity += Adjustment;//更新
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
if (!Adjustment.IsNearlyZero())
{
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement HasAdditiveVelocity LastUpdateVelocityAdjustment LastPreAdditiveVelocity(%s) Adjustment(%s)"),
*CurrentRootMotion.LastPreAdditiveVelocity.ToCompactString(), *Adjustment.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
}
#endif
}
FVector OldVelocity;
FVector OldLocation;
// Scoped updates can improve performance of multiple MoveComponent calls.
{
FScopedCapsuleMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates);
MaybeUpdateBasedMovement(DeltaSeconds);
// Clean up invalid RootMotion Sources.
// This includes RootMotion sources that ended naturally.
// They might want to perform a clamp on velocity or an override,
// so we want this to happen before ApplyAccumulatedForces and HandlePendingLaunch as to not clobber these.
const bool bHasRootMotionSources = HasRootMotionSources();
if (bHasRootMotionSources && !CharacterOwner->bClientUpdating && !CharacterOwner->bServerMoveIgnoreRootMotion)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementRootMotionSourceCalculate);
const FVector VelocityBeforeCleanup = Velocity;
CurrentRootMotion.CleanUpInvalidRootMotion(DeltaSeconds, *CharacterOwner, *this);//先清除已经结束的无用的source
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
if (Velocity != VelocityBeforeCleanup)
{
const FVector Adjustment = Velocity - VelocityBeforeCleanup;
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement CleanUpInvalidRootMotion Velocity(%s) VelocityBeforeCleanup(%s) Adjustment(%s)"),
*Velocity.ToCompactString(), *VelocityBeforeCleanup.ToCompactString(), *Adjustment.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
}
#endif
}
OldVelocity = Velocity;
OldLocation = UpdatedComponent->GetComponentLocation();
ApplyAccumulatedForces(DeltaSeconds);
// Update the character state before we do our movement
UpdateCharacterStateBeforeMovement(DeltaSeconds);
if (MovementMode == MOVE_NavWalking && bWantsToLeaveNavWalking)
{
TryToLeaveNavWalking();
}
// Character::LaunchCharacter() has been deferred until now.
HandlePendingLaunch();
ClearAccumulatedForces();
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
if (OldVelocity != Velocity)
{
const FVector Adjustment = Velocity - OldVelocity;
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement ApplyAccumulatedForces+HandlePendingLaunch Velocity(%s) OldVelocity(%s) Adjustment(%s)"),
*Velocity.ToCompactString(), *OldVelocity.ToCompactString(), *Adjustment.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
}
#endif
// Update saved LastPreAdditiveVelocity with any external changes to character Velocity that happened due to ApplyAccumulatedForces/HandlePendingLaunch
if( CurrentRootMotion.HasAdditiveVelocity() )
{
const FVector Adjustment = (Velocity - OldVelocity);
CurrentRootMotion.LastPreAdditiveVelocity += Adjustment;
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
if (!Adjustment.IsNearlyZero())
{
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement HasAdditiveVelocity AccumulatedForces LastPreAdditiveVelocity(%s) Adjustment(%s)"),
*CurrentRootMotion.LastPreAdditiveVelocity.ToCompactString(), *Adjustment.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
}
#endif
}
// Prepare Root Motion (generate/accumulate from root motion sources to be used later)
if (bHasRootMotionSources && !CharacterOwner->bClientUpdating && !CharacterOwner->bServerMoveIgnoreRootMotion)
{
// Animation root motion - If using animation RootMotion, tick animations before running physics.
if( CharacterOwner->IsPlayingRootMotion() && CharacterOwner->GetMesh() )
{
TickCharacterPose(DeltaSeconds);
// Make sure animation didn't trigger an event that destroyed us
if (!HasValidData())
{
return;
}
// For local human clients, save off root motion data so it can be used by movement networking code.
if( CharacterOwner->IsLocallyControlled() && (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy) && CharacterOwner->IsPlayingNetworkedRootMotionMontage() )
{
CharacterOwner->ClientRootMotionParams = RootMotionParams;
}
}
// Generates root motion to be used this frame from sources other than animation
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementRootMotionSourceCalculate);
CurrentRootMotion.PrepareRootMotion(DeltaSeconds, *CharacterOwner, *this, true);//重要的每帧更新
}
// For local human clients, save off root motion data so it can be used by movement networking code.
if( CharacterOwner->IsLocallyControlled() && (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy) )
{
CharacterOwner->SavedRootMotion = CurrentRootMotion;
}
}
// Apply Root Motion to Velocity
if( CurrentRootMotion.HasOverrideVelocity() || HasAnimRootMotion() )
{
// Animation root motion overrides Velocity and currently doesn't allow any other root motion sources
if( HasAnimRootMotion() )
{
// Convert to world space (animation root motion is always local)
USkeletalMeshComponent * SkelMeshComp = CharacterOwner->GetMesh();
if( SkelMeshComp )
{
// Convert Local Space Root Motion to world space. Do it right before used by physics to make sure we use up to date transforms, as translation is relative to rotation.
RootMotionParams.Set( ConvertLocalRootMotionToWorld(RootMotionParams.GetRootMotionTransform(), DeltaSeconds) );
}
// Then turn root motion to velocity to be used by various physics modes.
if( DeltaSeconds > 0.f )
{
AnimRootMotionVelocity = CalcAnimRootMotionVelocity(RootMotionParams.GetRootMotionTransform().GetTranslation(), DeltaSeconds, Velocity);
Velocity = ConstrainAnimRootMotionVelocity(AnimRootMotionVelocity, Velocity);
if (IsFalling())
{
Velocity += FVector(DecayingFormerBaseVelocity.X, DecayingFormerBaseVelocity.Y, 0.f);
}
}
UE_LOG(LogRootMotion, Log, TEXT("PerformMovement WorldSpaceRootMotion Translation: %s, Rotation: %s, Actor Facing: %s, Velocity: %s")
, *RootMotionParams.GetRootMotionTransform().GetTranslation().ToCompactString()
, *RootMotionParams.GetRootMotionTransform().GetRotation().Rotator().ToCompactString()
, *CharacterOwner->GetActorForwardVector().ToCompactString()
, *Velocity.ToCompactString()
);
}
else
{
// We don't have animation root motion so we apply other sources
if( DeltaSeconds > 0.f )
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementRootMotionSourceApply);
const FVector VelocityBeforeOverride = Velocity;
FVector NewVelocity = Velocity;
CurrentRootMotion.AccumulateOverrideRootMotionVelocity(DeltaSeconds, *CharacterOwner, *this, NewVelocity);//有override模式的，先处理覆盖速度逻辑
if (IsFalling())
{
NewVelocity += CurrentRootMotion.HasOverrideVelocityWithIgnoreZAccumulate() ? FVector(DecayingFormerBaseVelocity.X, DecayingFormerBaseVelocity.Y, 0.f) : DecayingFormerBaseVelocity;
}
Velocity = NewVelocity;
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
if (VelocityBeforeOverride != Velocity)
{
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement AccumulateOverrideRootMotionVelocity Velocity(%s) VelocityBeforeOverride(%s)"),
*Velocity.ToCompactString(), *VelocityBeforeOverride.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
}
#endif
}
}
}
#if ROOT_MOTION_DEBUG
if (RootMotionSourceDebug::CVarDebugRootMotionSources.GetValueOnGameThread() == 1)
{
FString AdjustedDebugString = FString::Printf(TEXT("PerformMovement Velocity(%s) OldVelocity(%s)"),
*Velocity.ToCompactString(), *OldVelocity.ToCompactString());
RootMotionSourceDebug::PrintOnScreen(*CharacterOwner, AdjustedDebugString);
}
#endif
// NaN tracking
devCode(ensureMsgf(!Velocity.ContainsNaN(), TEXT("UCharacterMovementComponent::PerformMovement: Velocity contains NaN (%s)\n%s"), *GetPathNameSafe(this), *Velocity.ToString()));
// Clear jump input now, to allow movement events to trigger it for next update.
CharacterOwner->ClearJumpInput(DeltaSeconds);
NumJumpApexAttempts = 0;
// change position
StartNewPhysics(DeltaSeconds, 0);//在这里面还有处理rootmotionsource对速度的影响
if (!HasValidData())
{
return;
}
// Update character state based on change from movement
UpdateCharacterStateAfterMovement(DeltaSeconds);
if (bAllowPhysicsRotationDuringAnimRootMotion || !HasAnimRootMotion())
{
PhysicsRotation(DeltaSeconds);
}
// Apply Root Motion rotation after movement is complete.
if( HasAnimRootMotion() )
{
const FQuat OldActorRotationQuat = UpdatedComponent->GetComponentQuat();
const FQuat RootMotionRotationQuat = RootMotionParams.GetRootMotionTransform().GetRotation();
if( !RootMotionRotationQuat.IsIdentity() )
{
const FQuat NewActorRotationQuat = RootMotionRotationQuat * OldActorRotationQuat;
MoveUpdatedComponent(FVector::ZeroVector, NewActorRotationQuat, true);
}
#if !(UE_BUILD_SHIPPING)
// debug
if (false)
{
const FRotator OldActorRotation = OldActorRotationQuat.Rotator();
const FVector ResultingLocation = UpdatedComponent->GetComponentLocation();
const FRotator ResultingRotation = UpdatedComponent->GetComponentRotation();
// Show current position
DrawDebugCoordinateSystem(MyWorld, CharacterOwner->GetMesh()->GetComponentLocation() + FVector(0,0,1), ResultingRotation, 50.f, false);
// Show resulting delta move.
DrawDebugLine(MyWorld, OldLocation, ResultingLocation, FColor::Red, false, 10.f);
// Log details.
UE_LOG(LogRootMotion, Warning, TEXT("PerformMovement Resulting DeltaMove Translation: %s, Rotation: %s, MovementBase: %s"), //-V595
*(ResultingLocation - OldLocation).ToCompactString(), *(ResultingRotation - OldActorRotation).GetNormalized().ToCompactString(), *GetNameSafe(CharacterOwner->GetMovementBase()) );
const FVector RMTranslation = RootMotionParams.GetRootMotionTransform().GetTranslation();
const FRotator RMRotation = RootMotionParams.GetRootMotionTransform().GetRotation().Rotator();
UE_LOG(LogRootMotion, Warning, TEXT("PerformMovement Resulting DeltaError Translation: %s, Rotation: %s"),
*(ResultingLocation - OldLocation - RMTranslation).ToCompactString(), *(ResultingRotation - OldActorRotation - RMRotation).GetNormalized().ToCompactString() );
}
#endif // !(UE_BUILD_SHIPPING)
// Root Motion has been used, clear
RootMotionParams.Clear();
}
else if (CurrentRootMotion.HasActiveRootMotionSources())
{
FQuat RootMotionRotationQuat;//上面都是处理对速度的影响，这里处理对旋转的影响
if (CharacterOwner && UpdatedComponent && CurrentRootMotion.GetOverrideRootMotionRotation(DeltaSeconds, *CharacterOwner, *this, RootMotionRotationQuat))
{
const FQuat OldActorRotationQuat = UpdatedComponent->GetComponentQuat();
const FQuat NewActorRotationQuat = RootMotionRotationQuat * OldActorRotationQuat;
MoveUpdatedComponent(FVector::ZeroVector, NewActorRotationQuat, true);
}
}
// consume path following requested velocity
LastUpdateRequestedVelocity = bHasRequestedVelocity ? RequestedVelocity : FVector::ZeroVector;
bHasRequestedVelocity = false;
OnMovementUpdated(DeltaSeconds, OldLocation, OldVelocity);
} // End scoped movement update
// Call external post-movement events. These happen after the scoped movement completes in case the events want to use the current state of overlaps etc.
CallMovementUpdateDelegate(DeltaSeconds, OldLocation, OldVelocity);
if (CharacterMovementCVars::BasedMovementMode == 0)
{
SaveBaseLocation(); // behaviour before implementing this fix
}
else
{
MaybeSaveBaseLocation();
}
UpdateComponentVelocity();
const bool bHasAuthority = CharacterOwner && CharacterOwner->HasAuthority();
// If we move we want to avoid a long delay before replication catches up to notice this change, especially if it's throttling our rate.
if (bHasAuthority && UNetDriver::IsAdaptiveNetUpdateFrequencyEnabled() && UpdatedComponent)
{
UNetDriver* NetDriver = MyWorld->GetNetDriver();
if (NetDriver && NetDriver->IsServer())
{
if (!NetDriver->IsPendingNetUpdate(CharacterOwner) && NetDriver->IsNetworkActorUpdateFrequencyThrottled(CharacterOwner))
{
if (ShouldCancelAdaptiveReplication())
{
NetDriver->CancelAdaptiveReplication(CharacterOwner);
}
}
}
}
const FVector NewLocation = UpdatedComponent ? UpdatedComponent->GetComponentLocation() : FVector::ZeroVector;
const FQuat NewRotation = UpdatedComponent ? UpdatedComponent->GetComponentQuat() : FQuat::Identity;
if (bHasAuthority && UpdatedComponent && !IsNetMode(NM_Client))
{
const bool bLocationChanged = (NewLocation != LastUpdateLocation);
const bool bRotationChanged = (NewRotation != LastUpdateRotation);
if (bLocationChanged || bRotationChanged)
{
// Update ServerLastTransformUpdateTimeStamp. This is used by Linear smoothing on clients to interpolate positions with the correct delta time,
// so the timestamp should be based on the client's move delta (ServerAccumulatedClientTimeStamp), not the server time when receiving the RPC.
const bool bIsRemotePlayer = (CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy);
const FNetworkPredictionData_Server_Character* ServerData = bIsRemotePlayer ? GetPredictionData_Server_Character() : nullptr;
if (bIsRemotePlayer && ServerData && CharacterMovementCVars::NetUseClientTimestampForReplicatedTransform)
{
ServerLastTransformUpdateTimeStamp = float(ServerData->ServerAccumulatedClientTimeStamp);
}
else
{
ServerLastTransformUpdateTimeStamp = MyWorld->GetTimeSeconds();
}
}
}
LastUpdateLocation = NewLocation;
LastUpdateRotation = NewRotation;
LastUpdateVelocity = Velocity;
}
---------------------------------------------------------------------------
charactermovement的数据网络同步流程 引擎版本5.4.4
大致的流程是 是主控端挑起的，因为玩家用键盘或者手柄输入操纵的是主控端，然后主控端处理数据class FNetworkPredictionData_Client_Character* ClientPredictionData
主控端的数据都保存在ClientPredictionData这里面，然后发送给server
流程
主控端
if (ShouldUsePackedMovementRPCs())
{
CallServerMovePacked(NewMove, ClientData->PendingMove.Get(), OldMove.Get());
}
else
{
CallServerMove(NewMove, OldMove.Get());
}
ServerMovePacked_ClientSend(PackedBits);
CharacterOwner->ServerMovePacked(PackedBits);rpc方法server端
GetCharacterMovement()->ServerMovePacked_ServerReceive(PackedBits);
ServerMove_HandleMoveData(MoveDataContainer);
ServerMove_PerformMovement();
ServerMoveHandleClientError();server处理完后同步给主控端，在UNetDriver::TickFlush调用
//在netdrive中调用
Connection->PlayerController->SendClientAdjustment();
void APlayerController::SendClientAdjustment()
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
if (ServerFrameInfo_DEPRECATED.LastProcessedInputFrame != INDEX_NONE && ServerFrameInfo_DEPRECATED.LastProcessedInputFrame != ServerFrameInfo_DEPRECATED.LastSentLocalFrame)
{
ServerFrameInfo_DEPRECATED.LastSentLocalFrame = ServerFrameInfo_DEPRECATED.LastProcessedInputFrame;
ClientRecvServerAckFrame(ServerFrameInfo_DEPRECATED.LastProcessedInputFrame, ServerFrameInfo_DEPRECATED.LastLocalFrame, ServerFrameInfo_DEPRECATED.QuantizedTimeDilation);
if (NetworkPhysicsCvars::EnableDebugRPC)
{
ClientRecvServerAckFrameDebug(InputBuffer_DEPRECATED.HeadFrame() - ServerFrameInfo_DEPRECATED.LastProcessedInputFrame, ServerFrameInfo_DEPRECATED.TargetNumBufferedCmds);
}
}
if (UPhysicsSettings::Get()->PhysicsPrediction.bEnablePhysicsPrediction)
{
if (ServerLatestTimestampToCorrect_DEPRECATED.ServerFrame != INDEX_NONE)
{
ClientCorrectionAsyncPhysicsTimestamp(ServerLatestTimestampToCorrect_DEPRECATED);
ServerLatestTimestampToCorrect_DEPRECATED.ServerFrame = INDEX_NONE;
}
if (AcknowledgedPawn != GetPawn() && !GetSpectatorPawn())
{
return;
}
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
// Server sends updates.
// Note: we do this for both the pawn and spectator in case an implementation has a networked spectator.
APawn* RemotePawn = GetPawnOrSpectator();
if (RemotePawn && (RemotePawn->GetRemoteRole() == ROLE_AutonomousProxy) && !IsNetMode(NM_Client))
{
INetworkPredictionInterface* NetworkPredictionInterface = Cast<INetworkPredictionInterface>(RemotePawn->GetMovementComponent());
if (NetworkPredictionInterface)
{
NetworkPredictionInterface->SendClientAdjustment();//主控端的movement执行
}
}
}
//主控端上执行 矫正
void UCharacterMovementComponent::SendClientAdjustment()
{
if (!HasValidData())
{
return;
}
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
if (ServerData->PendingAdjustment.TimeStamp <= 0.f)
{
return;
}
const float CurrentTime = GetWorld()->GetTimeSeconds();
if (ServerData->PendingAdjustment.bAckGoodMove)
{
// just notify client this move was received
if (CurrentTime - ServerLastClientGoodMoveAckTime > NetworkMinTimeBetweenClientAckGoodMoves)
{
ServerLastClientGoodMoveAckTime = CurrentTime;
if (ShouldUsePackedMovementRPCs())
{
ServerSendMoveResponse(ServerData->PendingAdjustment);
}
else
{
ClientAckGoodMove(ServerData->PendingAdjustment.TimeStamp);
}
}
}
else
{
// We won't be back in here until the next client move and potential correction is received, so use the correct time now.
// Protect against bad data by taking appropriate min/max of editable values.
const float AdjustmentTimeThreshold = bNetworkLargeClientCorrection ?
FMath::Min(NetworkMinTimeBetweenClientAdjustmentsLargeCorrection, NetworkMinTimeBetweenClientAdjustments) :
FMath::Max(NetworkMinTimeBetweenClientAdjustmentsLargeCorrection, NetworkMinTimeBetweenClientAdjustments);
// Check if correction is throttled based on time limit between updates.
if (CurrentTime - ServerLastClientAdjustmentTime > AdjustmentTimeThreshold)
{
ServerLastClientAdjustmentTime = CurrentTime;
if (ShouldUsePackedMovementRPCs())
{
ServerSendMoveResponse(ServerData->PendingAdjustment);
}
else
{
const bool bIsPlayingNetworkedRootMotionMontage = CharacterOwner->IsPlayingNetworkedRootMotionMontage();
if (CurrentRootMotion.HasActiveRootMotionSources())
{
FRotator Rotation = ServerData->PendingAdjustment.NewRot.GetNormalized();
FVector_NetQuantizeNormal CompressedRotation(Rotation.Pitch / 180.f, Rotation.Yaw / 180.f, Rotation.Roll / 180.f);
ClientAdjustRootMotionSourcePosition
(
ServerData->PendingAdjustment.TimeStamp,
CurrentRootMotion,
bIsPlayingNetworkedRootMotionMontage,
bIsPlayingNetworkedRootMotionMontage ? CharacterOwner->GetRootMotionAnimMontageInstance()->GetPosition() : -1.f,
ServerData->PendingAdjustment.NewLoc,
CompressedRotation,
ServerData->PendingAdjustment.NewVel.Z,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
ServerData->PendingAdjustment.MovementMode
);
}
else if (bIsPlayingNetworkedRootMotionMontage)
{
FRotator Rotation = ServerData->PendingAdjustment.NewRot.GetNormalized();
FVector_NetQuantizeNormal CompressedRotation(Rotation.Pitch / 180.f, Rotation.Yaw / 180.f, Rotation.Roll / 180.f);
ClientAdjustRootMotionPosition
(
ServerData->PendingAdjustment.TimeStamp,
CharacterOwner->GetRootMotionAnimMontageInstance()->GetPosition(),
ServerData->PendingAdjustment.NewLoc,
CompressedRotation,
ServerData->PendingAdjustment.NewVel.Z,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
ServerData->PendingAdjustment.MovementMode
);
}
else if (ServerData->PendingAdjustment.NewVel.IsZero())
{
ClientVeryShortAdjustPosition
(
ServerData->PendingAdjustment.TimeStamp,
ServerData->PendingAdjustment.NewLoc,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
ServerData->PendingAdjustment.MovementMode
);
}
else
{
ClientAdjustPosition
(
ServerData->PendingAdjustment.TimeStamp,
ServerData->PendingAdjustment.NewLoc,
ServerData->PendingAdjustment.NewVel,
ServerData->PendingAdjustment.NewBase,
ServerData->PendingAdjustment.NewBaseBoneName,
ServerData->PendingAdjustment.NewBase != NULL,
ServerData->PendingAdjustment.bBaseRelativePosition,
ServerData->PendingAdjustment.MovementMode
);
}
}
}
}
ServerData->PendingAdjustment.TimeStamp = 0;
ServerData->PendingAdjustment.bAckGoodMove = false;
ServerData->bForceClientUpdate = false;
}
server处理完后同步给 simulate端
依赖的是character的属性同步
server上执行PerformMovement之后就改变了 character的这些属性，通过属性同步传给simu
void ACharacter::GetLifetimeReplicatedProps( TArray< FLifetimeProperty > & OutLifetimeProps ) const
{
Super::GetLifetimeReplicatedProps( OutLifetimeProps );
DISABLE_REPLICATED_PROPERTY(ACharacter, JumpMaxHoldTime);
DISABLE_REPLICATED_PROPERTY(ACharacter, JumpMaxCount);
DOREPLIFETIME_CONDITION( ACharacter, RepRootMotion, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, ReplicatedBasedMovement, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, ReplicatedServerLastTransformUpdateTimeStamp, COND_SimulatedOnlyNoReplay );
DOREPLIFETIME_CONDITION( ACharacter, ReplicatedMovementMode, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, bIsCrouched, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, bProxyIsJumpForceApplied, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, AnimRootMotionTranslationScale, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, ReplicatedGravityDirection, COND_SimulatedOnly );
DOREPLIFETIME_CONDITION( ACharacter, ReplayLastTransformUpdateTimeStamp, COND_ReplayOnly );
}
//在TickComponment中调用
void UCharacterMovementComponent::SimulatedTick(float DeltaSeconds)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementSimulated);
checkSlow(CharacterOwner != nullptr);
// If we are playing a RootMotion AnimMontage.
if (CharacterOwner->IsPlayingNetworkedRootMotionMontage())
{
bWasSimulatingRootMotion = true;
UE_LOG(LogRootMotion, Verbose, TEXT("UCharacterMovementComponent::SimulatedTick"));
// Tick animations before physics.
if( CharacterOwner && CharacterOwner->GetMesh() )
{
TickCharacterPose(DeltaSeconds);
// Make sure animation didn't trigger an event that destroyed us
if (!HasValidData())
{
return;
}
}
const FQuat OldRotationQuat = UpdatedComponent->GetComponentQuat();
const FVector OldLocation = UpdatedComponent->GetComponentLocation();
USkeletalMeshComponent* Mesh = CharacterOwner->GetMesh();
const FVector SavedMeshRelativeLocation = Mesh ? Mesh->GetRelativeLocation() : FVector::ZeroVector;
if( RootMotionParams.bHasRootMotion )
{
SimulateRootMotion(DeltaSeconds, RootMotionParams.GetRootMotionTransform());
#if !(UE_BUILD_SHIPPING)
// debug
if (CharacterOwner && false)
{
const FRotator OldRotation = OldRotationQuat.Rotator();
const FRotator NewRotation = UpdatedComponent->GetComponentRotation();
const FVector NewLocation = UpdatedComponent->GetComponentLocation();
DrawDebugCoordinateSystem(GetWorld(), CharacterOwner->GetMesh()->GetComponentLocation() + FVector(0,0,1), NewRotation, 50.f, false);
DrawDebugLine(GetWorld(), OldLocation, NewLocation, FColor::Red, false, 10.f);
UE_LOG(LogRootMotion, Log, TEXT("UCharacterMovementComponent::SimulatedTick DeltaMovement Translation: %s, Rotation: %s, MovementBase: %s"),
*(NewLocation - OldLocation).ToCompactString(), *(NewRotation - OldRotation).GetNormalized().ToCompactString(), *GetNameSafe(CharacterOwner->GetMovementBase()) );
}
#endif // !(UE_BUILD_SHIPPING)
}
// then, once our position is up to date with our animation,
// handle position correction if we have any pending updates received from the server.
if( CharacterOwner && (CharacterOwner->RootMotionRepMoves.Num() > 0) )
{
CharacterOwner->SimulatedRootMotionPositionFixup(DeltaSeconds);
}
if (!bNetworkSmoothingComplete && (NetworkSmoothingMode == ENetworkSmoothingMode::Linear))
{
// Same mesh with different rotation?
const FQuat NewCapsuleRotation = UpdatedComponent->GetComponentQuat();
if (Mesh == CharacterOwner->GetMesh() && !NewCapsuleRotation.Equals(OldRotationQuat, 1e-6f) && ClientPredictionData)
{
// Smoothing should lerp toward this new rotation target, otherwise it will just try to go back toward the old rotation.
ClientPredictionData->MeshRotationTarget = NewCapsuleRotation;
Mesh->SetRelativeLocationAndRotation(SavedMeshRelativeLocation, CharacterOwner->GetBaseRotationOffset());
}
}
}
else if (CurrentRootMotion.HasActiveRootMotionSources())
{
// We have root motion sources and possibly animated root motion
bWasSimulatingRootMotion = true;
UE_LOG(LogRootMotion, Verbose, TEXT("UCharacterMovementComponent::SimulatedTick"));
// If we have RootMotionRepMoves, find the most recent important one and set position/rotation to it
bool bCorrectedToServer = false;
const FVector OldLocation = UpdatedComponent->GetComponentLocation();
const FQuat OldRotation = UpdatedComponent->GetComponentQuat();
if( CharacterOwner->RootMotionRepMoves.Num() > 0 )
{
// Move Actor back to position of that buffered move. (server replicated position).
FSimulatedRootMotionReplicatedMove& RootMotionRepMove = CharacterOwner->RootMotionRepMoves.Last();
if( CharacterOwner->RestoreReplicatedMove(RootMotionRepMove) )
{
bCorrectedToServer = true;
}
Acceleration = RootMotionRepMove.RootMotion.Acceleration;
CharacterOwner->PostNetReceiveVelocity(RootMotionRepMove.RootMotion.LinearVelocity);
LastUpdateVelocity = RootMotionRepMove.RootMotion.LinearVelocity;
// Convert RootMotionSource Server IDs -> Local IDs in AuthoritativeRootMotion and cull invalid
// so that when we use this root motion it has the correct IDs
ConvertRootMotionServerIDsToLocalIDs(CurrentRootMotion, RootMotionRepMove.RootMotion.AuthoritativeRootMotion, RootMotionRepMove.Time);
RootMotionRepMove.RootMotion.AuthoritativeRootMotion.CullInvalidSources();
// Set root motion states to that of repped in state
CurrentRootMotion.UpdateStateFrom(RootMotionRepMove.RootMotion.AuthoritativeRootMotion, true);
// Clear out existing RootMotionRepMoves since we've consumed the most recent
UE_LOG(LogRootMotion, Log, TEXT("\tClearing old moves in SimulatedTick (%d)"), CharacterOwner->RootMotionRepMoves.Num());
CharacterOwner->RootMotionRepMoves.Reset();
}
// Update replicated gravity direction
if (bNetworkGravityDirectionChanged)
{
SetGravityDirection(CharacterOwner->GetReplicatedGravityDirection());
bNetworkGravityDirectionChanged = false;
}
// Update replicated movement mode.
if (bNetworkMovementModeChanged)
{
ApplyNetworkMovementMode(CharacterOwner->GetReplicatedMovementMode());
bNetworkMovementModeChanged = false;
}
// Perform movement
PerformMovement(DeltaSeconds);
// After movement correction, smooth out error in position if any.
if( bCorrectedToServer || CurrentRootMotion.NeedsSimulatedSmoothing() )
{
SmoothCorrection(OldLocation, OldRotation, UpdatedComponent->GetComponentLocation(), UpdatedComponent->GetComponentQuat());
}
}
// Not playing RootMotion AnimMontage
else
{
// if we were simulating root motion, we've been ignoring regular ReplicatedMovement updates.
// If we're not simulating root motion anymore, force us to sync our movement properties.
// (Root Motion could leave Velocity out of sync w/ ReplicatedMovement)
if( bWasSimulatingRootMotion )
{
CharacterOwner->RootMotionRepMoves.Empty();
CharacterOwner->OnRep_ReplicatedMovement();
CharacterOwner->OnRep_ReplicatedBasedMovement();
SetGravityDirection(CharacterOwner->GetReplicatedGravityDirection());
ApplyNetworkMovementMode(GetCharacterOwner()->GetReplicatedMovementMode());
}
if (CharacterOwner->IsReplicatingMovement() && UpdatedComponent)
{
USkeletalMeshComponent* Mesh = CharacterOwner->GetMesh();
const FVector SavedMeshRelativeLocation = Mesh ? Mesh->GetRelativeLocation() : FVector::ZeroVector;
const FQuat SavedCapsuleRotation = UpdatedComponent->GetComponentQuat();
const bool bPreventMeshMovement = !bNetworkSmoothingComplete;
// Avoid moving the mesh during movement if SmoothClientPosition will take care of it.
{
const FScopedPreventAttachedComponentMove PreventMeshMovement(bPreventMeshMovement ? Mesh : nullptr);
if (CharacterOwner->IsPlayingRootMotion())
{
// Update replicated gravity direction
if (bNetworkGravityDirectionChanged)
{
SetGravityDirection(CharacterOwner->GetReplicatedGravityDirection());
bNetworkGravityDirectionChanged = false;
}
// Update replicated movement mode.
if (bNetworkMovementModeChanged)
{
ApplyNetworkMovementMode(CharacterOwner->GetReplicatedMovementMode());
bNetworkMovementModeChanged = false;
}
PerformMovement(DeltaSeconds);
}
else
{
SimulateMovement(DeltaSeconds);
}
}
// With Linear smoothing we need to know if the rotation changes, since the mesh should follow along with that (if it was prevented above).
// This should be rare that rotation changes during simulation, but it can happen when ShouldRemainVertical() changes, or standing on a moving base.
const bool bValidateRotation = bPreventMeshMovement && (NetworkSmoothingMode == ENetworkSmoothingMode::Linear);
if (bValidateRotation && UpdatedComponent)
{
// Same mesh with different rotation?
const FQuat NewCapsuleRotation = UpdatedComponent->GetComponentQuat();
if (Mesh == CharacterOwner->GetMesh() && !NewCapsuleRotation.Equals(SavedCapsuleRotation, 1e-6f) && ClientPredictionData)
{
// Smoothing should lerp toward this new rotation target, otherwise it will just try to go back toward the old rotation.
ClientPredictionData->MeshRotationTarget = NewCapsuleRotation;
Mesh->SetRelativeLocationAndRotation(SavedMeshRelativeLocation, CharacterOwner->GetBaseRotationOffset());
}
}
}
if (bWasSimulatingRootMotion)
{
bWasSimulatingRootMotion = false;
}
}
// Smooth mesh location after moving the capsule above.
if (!bNetworkSmoothingComplete)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementSmoothClientPosition);
SmoothClientPosition(DeltaSeconds);
}
else
{
UE_LOG(LogCharacterNetSmoothing, Verbose, TEXT("Skipping network smoothing for %s."), *GetNameSafe(CharacterOwner));
}
}源码详解 一切从TickComponent开始，并且分叉
void UCharacterMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
SCOPED_NAMED_EVENT(UCharacterMovementComponent_TickComponent, FColor::Yellow);
SCOPE_CYCLE_COUNTER(STAT_CharacterMovement);
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementTick);
CSV_SCOPED_TIMING_STAT_EXCLUSIVE(CharacterMovement);
FVector InputVector = FVector::ZeroVector;
bool bUsingAsyncTick = (CharacterMovementCVars::AsyncCharacterMovement == 1) && IsAsyncCallbackRegistered();
if (!bUsingAsyncTick)
{
// Do not consume input if simulating asynchronously, we will consume input when filling out async inputs.
InputVector = ConsumeInputVector();//从pawn上获得input输入
}
if (!HasValidData() || ShouldSkipUpdate(DeltaTime))
{
return;
}
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
// Super tick may destroy/invalidate CharacterOwner or UpdatedComponent, so we need to re-check.
if (!HasValidData())
{
return;
}
if (bUsingAsyncTick)//跟物理模拟有关
{
check(CharacterOwner && CharacterOwner->GetMesh());
USkeletalMeshComponent* CharacterMesh = CharacterOwner->GetMesh();
if (CharacterMesh->ShouldTickPose())
{
const bool bWasPlayingRootMotion = CharacterOwner->IsPlayingRootMotion();
CharacterMesh->TickPose(DeltaTime, true);
// We are simulating character movement on physics thread, do not tick movement.
const bool bIsPlayingRootMotion = CharacterOwner->IsPlayingRootMotion();
if (bIsPlayingRootMotion || bWasPlayingRootMotion)
{
FRootMotionMovementParams RootMotion = CharacterMesh->ConsumeRootMotion();
if (RootMotion.bHasRootMotion)
{
RootMotion.ScaleRootMotionTranslation(CharacterOwner->GetAnimRootMotionTranslationScale());
RootMotionParams.Accumulate(RootMotion);
}
}
}
AccumulateRootMotionForAsync(DeltaTime, AsyncRootMotion);
return;
}
// See if we fell out of the world.
const bool bIsSimulatingPhysics = UpdatedComponent->IsSimulatingPhysics();
if (CharacterOwner->GetLocalRole() == ROLE_Authority && (!bCheatFlying || bIsSimulatingPhysics) && !CharacterOwner->CheckStillInWorld())
{
return;
}
// We don't update if simulating physics (eg ragdolls).
if (bIsSimulatingPhysics)
{
// Update camera to ensure client gets updates even when physics move it far away from point where simulation started
if (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy && IsNetMode(NM_Client))
{
MarkForClientCameraUpdate();
}
ClearAccumulatedForces();
return;
}
AvoidanceLockTimer -= DeltaTime;
if (CharacterOwner->GetLocalRole() > ROLE_SimulatedProxy)//逻辑开始，当不是模拟端
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementNonSimulated);
// If we are a client we might have received an update from the server.
const bool bIsClient = (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy && IsNetMode(NM_Client));
if (bIsClient)//如果是主控端，先处理server返回的纠正，bUpdatePosition只有在ClientAdjustPosition里面设置为true
{
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (ClientData && ClientData->bUpdatePosition)
{
ClientUpdatePositionAfterServerUpdate();
}
}
// Defer all mesh child updates until all movement completes. Avoiding combining this with the corrections above, as those may cause a lot of significant movement.
FScopedMeshMovementUpdate ScopedMeshUpdate(CharacterOwner->GetMesh());
// Perform input-driven move for any locally-controlled character, and also
// allow animation root motion or physics to move characters even if they have no controller
const bool bShouldPerformControlledCharMove = CharacterOwner->IsLocallyControlled()
|| (!CharacterOwner->Controller && bRunPhysicsWithNoController)
|| (!CharacterOwner->Controller && CharacterOwner->IsPlayingRootMotion());
if (bShouldPerformControlledCharMove)//如果是手柄控制的
{
ControlledCharacterMove(InputVector, DeltaTime);//开始了，主控端处理数据和发送数据的逻辑
const bool bIsaListenServerAutonomousProxy = CharacterOwner->IsLocallyControlled()
&& (CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy);
if (bIsaListenServerAutonomousProxy)//如果是listen server的主控端
{
ServerAutonomousProxyTick(DeltaTime);//空函数
}
}
else if (CharacterOwner->GetRemoteRole() == ROLE_AutonomousProxy)//如果是server端上对应主控端的那个角色
{
// Server ticking for remote client.
// Between net updates from the client we need to update position if based on another object,
// otherwise the object will move on intermediate frames and we won't follow it.
MaybeUpdateBasedMovement(DeltaTime);//简单的处理，貌似沿着当前速度滑行一段，跟input没有任何关系
MaybeSaveBaseLocation();
ServerAutonomousProxyTick(DeltaTime);
// Smooth on listen server for local view of remote clients. We may receive updates at a rate different than our own tick rate.
if (CharacterMovementCVars::NetEnableListenServerSmoothing && !bNetworkSmoothingComplete && IsNetMode(NM_ListenServer))
{
SmoothClientPosition(DeltaTime);
}
}
}
else if (CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy)//模拟端的处理
{
// Defer all mesh child updates until all movement completes.
FScopedMeshMovementUpdate ScopedMeshUpdate(CharacterOwner->GetMesh());
if (bShrinkProxyCapsule)
{
AdjustProxyCapsuleSize();
}
SimulatedTick(DeltaTime);//模拟端的tick
}
if (bUseRVOAvoidance)
{
UpdateDefaultAvoidance();
}
if (bEnablePhysicsInteraction)
{
SCOPE_CYCLE_COUNTER(STAT_CharPhysicsInteraction);
ApplyDownwardForce(DeltaTime);
ApplyRepulsionForce(DeltaTime);
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
const bool bVisualizeMovement = CharacterMovementCVars::VisualizeMovement > 0;
if (bVisualizeMovement)
{
VisualizeMovement();
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
void UCharacterMovementComponent::ControlledCharacterMove(const FVector& InputVector, float DeltaSeconds)
{
{
SCOPE_CYCLE_COUNTER(STAT_CharUpdateAcceleration);
// We need to check the jump state before adjusting input acceleration, to minimize latency
// and to make sure acceleration respects our potentially new falling state.
CharacterOwner->CheckJumpInput(DeltaSeconds);
// apply input to acceleration
Acceleration = ScaleInputAcceleration(ConstrainInputAcceleration(InputVector));//用input计算出加速度，跟mass无关
AnalogInputModifier = ComputeAnalogInputModifier();
}
if (CharacterOwner->GetLocalRole() == ROLE_Authority)
{
PerformMovement(DeltaSeconds);//liston server 直接处理
}
else if (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy && IsNetMode(NM_Client))
{
ReplicateMoveToServer(DeltaSeconds, Acceleration);//主控端
}
}主控端源码分析
void UCharacterMovementComponent::ReplicateMoveToServer(float DeltaTime, const FVector& NewAcceleration)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementReplicateMoveToServer);
check(CharacterOwner != NULL);
// Can only start sending moves if our controllers are synced up over the network, otherwise we flood the reliable buffer.
APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
if (PC && PC->AcknowledgedPawn != CharacterOwner)
{
return;
}
// Bail out if our character's controller doesn't have a Player. This may be the case when the local player
// has switched to another controller, such as a debug camera controller.
if (PC && PC->Player == nullptr)
{
return;
}
FNetworkPredictionData_Client_Character* ClientData = GetPredictionData_Client_Character();
if (!ClientData)
{
return;
}
// Update our delta time for physics simulation.更新CurrentTimeStamp 和 DeltaTime，有可能是CurrentTimeStamp减去最后一个save的时间戳
DeltaTime = ClientData->UpdateTimeStampAndDeltaTime(DeltaTime, *CharacterOwner, *this);
// Find the oldest (unacknowledged) important move (OldMove).
// Don't include the last move because it may be combined with the next new move.
// A saved move is interesting if it differs significantly from the last acknowledged move
FSavedMovePtr OldMove = NULL;//寻找最老的一个，同时这个跟已经确认的不是同一个，同时也不是数组的最后一个
if( ClientData->LastAckedMove.IsValid() )
{
const int32 NumSavedMoves = ClientData->SavedMoves.Num();
for (int32 i=0; i < NumSavedMoves-1; i++)
{
const FSavedMovePtr& CurrentMove = ClientData->SavedMoves[i];
if (CurrentMove->IsImportantMove(ClientData->LastAckedMove))
{
OldMove = CurrentMove;
break;
}
}
}
// Get a SavedMove object to store the movement in.
FSavedMovePtr NewMovePtr = ClientData->CreateSavedMove();
FSavedMove_Character* const NewMove = NewMovePtr.Get();
if (NewMove == nullptr)
{
return;
}
//拿出一个空闲的 填充值
NewMove->SetMoveFor(CharacterOwner, DeltaTime, NewAcceleration, *ClientData);//主控端移动前 数据填充
const UWorld* MyWorld = GetWorld();
// see if the two moves could be combined
// do not combine moves which have different TimeStamps (before and after reset).
if (const FSavedMove_Character* PendingMove = ClientData->PendingMove.Get())
{
if (PendingMove->CanCombineWith(NewMovePtr, CharacterOwner, ClientData->MaxMoveDeltaTime * CharacterOwner->GetActorTimeDilation(*MyWorld)))//看合并函数，两个savemove具有严苛的条件才会combin
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCombineNetMove);
// Only combine and move back to the start location if we don't move back in to a spot that would make us collide with something new.
const FVector OldStartLocation = PendingMove->GetRevertedLocation();
const bool bAttachedToObject = (NewMovePtr->StartAttachParent != nullptr);
if (bAttachedToObject || !OverlapTest(OldStartLocation, PendingMove->StartRotation.Quaternion(), UpdatedComponent->GetCollisionObjectType(), GetPawnCapsuleCollisionShape(SHRINK_None), CharacterOwner))
{
// Avoid updating Mesh bones to physics during the teleport back, since PerformMovement() will update it right away anyway below.
// Note: this must be before the FScopedMovementUpdate below, since that scope is what actually moves the character and mesh.
FScopedMeshBoneUpdateOverride ScopedNoMeshBoneUpdate(CharacterOwner->GetMesh(), EKinematicBonesUpdateToPhysics::SkipAllBones);
// Accumulate multiple transform updates until scope ends.
FScopedCapsuleMovementUpdate ScopedMovementUpdate(UpdatedComponent, true);
UE_LOG(LogNetPlayerMovement, VeryVerbose, TEXT("CombineMove: add delta %f + %f and revert from %f %f to %f %f"), DeltaTime, PendingMove->DeltaTime, UpdatedComponent->GetComponentLocation().X, UpdatedComponent->GetComponentLocation().Y, OldStartLocation.X, OldStartLocation.Y);
NewMove->CombineWith(PendingMove, CharacterOwner, PC, OldStartLocation);
if (PC)
{
// We reverted position to that at the start of the pending move (above), however some code paths expect rotation to be set correctly
// before character movement occurs (via FaceRotation), so try that now. The bOrientRotationToMovement path happens later as part of PerformMovement() and PhysicsRotation().
CharacterOwner->FaceRotation(PC->GetControlRotation(), NewMove->DeltaTime);
}
SaveBaseLocation();
NewMove->SetInitialPosition(CharacterOwner);
// Remove pending move from move list. It would have to be the last move on the list.
if (ClientData->SavedMoves.Num() > 0 && ClientData->SavedMoves.Last() == ClientData->PendingMove)
{
ClientData->SavedMoves.Pop(EAllowShrinking::No);
}
ClientData->FreeMove(ClientData->PendingMove);
ClientData->PendingMove = nullptr;
PendingMove = nullptr; // Avoid dangling reference, it's deleted above.
}
else
{
UE_LOG(LogNetPlayerMovement, Verbose, TEXT("Not combining move [would collide at start location]"));
}
}
else
{
UE_LOG(LogNetPlayerMovement, Verbose, TEXT("Not combining move [not allowed by CanCombineWith()]"));
}
}
// Acceleration should match what we send to the server, plus any other restrictions the server also enforces (see MoveAutonomous).
Acceleration = NewMove->Acceleration.GetClampedToMaxSize(GetMaxAcceleration());
AnalogInputModifier = ComputeAnalogInputModifier(); // recompute since acceleration may have changed.
// Perform the move locally
CharacterOwner->ClientRootMotionParams.Clear();
CharacterOwner->SavedRootMotion.Clear();
PerformMovement(NewMove->DeltaTime);//主控端执行移动
NewMove->PostUpdate(CharacterOwner, FSavedMove_Character::PostUpdate_Record);//主控端移动后 newmove数据更新
// Add NewMove to the list
if (CharacterOwner->IsReplicatingMovement())
{
check(NewMove == NewMovePtr.Get());
ClientData->SavedMoves.Push(NewMovePtr);//把new move 放到 savemoves 列表中
const bool bCanDelayMove = (CharacterMovementCVars::NetEnableMoveCombining != 0) && CanDelaySendingMove(NewMovePtr);
if (bCanDelayMove && ClientData->PendingMove.IsValid() == false)
{
// Decide whether to hold off on move
const float NetMoveDeltaSeconds = FMath::Clamp(GetClientNetSendDeltaTime(PC, ClientData, NewMovePtr), 1.f/120.f, 1.f/5.f);
const float SecondsSinceLastMoveSent = MyWorld->GetRealTimeSeconds() - ClientData->ClientUpdateRealTime;
if (SecondsSinceLastMoveSent < NetMoveDeltaSeconds)
{
// Delay sending this move.
ClientData->PendingMove = NewMovePtr;
return;
}
}
ClientData->ClientUpdateRealTime = MyWorld->GetRealTimeSeconds();//设置最后一次发送给server数据的时间戳
UE_CLOG(CharacterOwner && UpdatedComponent, LogNetPlayerMovement, VeryVerbose, TEXT("ClientMove Time %f Acceleration %s Velocity %s Position %s Rotation %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d) DualMove? %d"),
NewMove->TimeStamp, *NewMove->Acceleration.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), NewMove->DeltaTime, *GetMovementName(),
*GetNameSafe(NewMove->EndBase.Get()), *NewMove->EndBoneName.ToString(), MovementBaseUtility::IsDynamicBase(NewMove->EndBase.Get()) ? 1 : 0, ClientData->PendingMove.IsValid() ? 1 : 0);
bool bSendServerMove = true;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
// Testing options: Simulated packet loss to server
const float TimeSinceLossStart = (MyWorld->RealTimeSeconds - ClientData->DebugForcedPacketLossTimerStart);
if (ClientData->DebugForcedPacketLossTimerStart > 0.f && (TimeSinceLossStart < CharacterMovementCVars::NetForceClientServerMoveLossDuration))
{
bSendServerMove = false;
UE_LOG(LogNetPlayerMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CharacterMovementCVars::NetForceClientServerMoveLossDuration - TimeSinceLossStart);
}
else if (CharacterMovementCVars::NetForceClientServerMoveLossPercent != 0.f && (RandomStream.FRand() < CharacterMovementCVars::NetForceClientServerMoveLossPercent))
{
bSendServerMove = false;
ClientData->DebugForcedPacketLossTimerStart = (CharacterMovementCVars::NetForceClientServerMoveLossDuration > 0) ? MyWorld->RealTimeSeconds : 0.0f;
UE_LOG(LogNetPlayerMovement, Log, TEXT("Drop ServerMove, %.2f time remains"), CharacterMovementCVars::NetForceClientServerMoveLossDuration);
}
else
{
ClientData->DebugForcedPacketLossTimerStart = 0.f;
}
#endif
// Send move to server if this character is replicating movement
if (bSendServerMove)//发送数据给server
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementCallServerMove);
if (ShouldUsePackedMovementRPCs())
{
CallServerMovePacked(NewMove, ClientData->PendingMove.Get(), OldMove.Get());//虚幻主推的方法，如果上面能合并，那么PendingMove就为空
}
else
{
CallServerMove(NewMove, OldMove.Get());//虚幻要淘汰的方法
}
}
}
ClientData->PendingMove = NULL;
}
//把CurrentTimeStamp控制在0------MinTimeBetweenTimeStampResets区间，相当于mod 这个值，CurrentTimeStamp+DeltaTime不断的增加，然后再控制在这个区间
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 )//超过这个区间就减去MinTimeBetweenTimeStampResets
{
UE_LOG(LogNetPlayerMovement, Log, TEXT("Resetting Client's TimeStamp %f"), CurrentTimeStamp);
CurrentTimeStamp -= CharacterMovementComponent.MinTimeBetweenTimeStampResets;
// Mark all buffered moves as having old time stamps, so we make sure to not resend them.
// That would confuse the server.
for(int32 MoveIndex=0; MoveIndex<SavedMoves.Num(); MoveIndex++)
{
const FSavedMovePtr& CurrentMove = SavedMoves[MoveIndex];
SavedMoves[MoveIndex]->bOldTimeStampBeforeReset = true;//更新时间戳重置标识
}
// Do LastAckedMove as well. No need to do PendingMove as that move is part of the SavedMoves array.
if( LastAckedMove.IsValid() )
{
LastAckedMove->bOldTimeStampBeforeReset = true;
}
// Also apply the reset to any active root motions.
CharacterMovementComponent.CurrentRootMotion.ApplyTimeStampReset(CharacterMovementComponent.MinTimeBetweenTimeStampResets);
}
// Update Current TimeStamp.
CurrentTimeStamp += DeltaTime;//更新时间戳
float ClientDeltaTime = DeltaTime;
// Server uses TimeStamps to derive DeltaTime which introduces some rounding errors.
// Make sure we do the same, so MoveAutonomous uses the same inputs and is deterministic!!
if( SavedMoves.Num() > 0 )
{
const FSavedMovePtr& PreviousMove = SavedMoves.Last();
if( !PreviousMove->bOldTimeStampBeforeReset )//如果最后一个也是最新的一个没有跨过一个时间区域就是说当前的时间戳和这个save处于同一个时间段内 就求出当前的时间戳和最后一个时间戳的差值作为delta time
{
// How server will calculate its deltatime to update physics.
const float ServerDeltaTime = CurrentTimeStamp - PreviousMove->TimeStamp;
// Have client always use the Server's DeltaTime. Otherwise our physics simulation will differ and we'll trigger too many position corrections and increase our network traffic.
ClientDeltaTime = ServerDeltaTime;
}
}
return FMath::Min(ClientDeltaTime, MaxMoveDeltaTime * CharacterOwner.GetActorTimeDilation());
}//不理解为啥一次要处理三个移动
void UCharacterMovementComponent::CallServerMovePacked(const FSavedMove_Character* NewMove, const FSavedMove_Character* PendingMove, const FSavedMove_Character* OldMove)
{
// Get storage container we'll be using and fill it with movement data
FCharacterNetworkMoveDataContainer& MoveDataContainer = GetNetworkMoveDataContainer();
MoveDataContainer.ClientFillNetworkMoveData(NewMove, PendingMove, OldMove);
// Reset bit writer without affecting allocations
FBitWriterMark BitWriterReset;
BitWriterReset.Pop(ServerMoveBitWriter);
// 'static' to avoid reallocation each invocation
static FCharacterServerMovePackedBits PackedBits;
UNetConnection* NetConnection = CharacterOwner->GetNetConnection();
#if UE_WITH_IRIS
if (UPackageMap* PackageMap = UE::Private::GetIrisPackageMapToCaptureReferences(NetConnection, &PackedBits.ObjectReferences))
{
ServerMoveBitWriter.PackageMap = PackageMap;
}
else
#endif
{
// Extract the net package map used for serializing object references.
ServerMoveBitWriter.PackageMap = NetConnection ? ToRawPtr(NetConnection->PackageMap) : nullptr;
}
if (ServerMoveBitWriter.PackageMap == nullptr)
{
UE_LOG(LogNetPlayerMovement, Error, TEXT("CallServerMovePacked: Failed to find a NetConnection/PackageMap for data serialization!"));
return;
}
// Serialize move struct into a bit stream
if (!MoveDataContainer.Serialize(*this, ServerMoveBitWriter, ServerMoveBitWriter.PackageMap) || ServerMoveBitWriter.IsError())
{
UE_LOG(LogNetPlayerMovement, Error, TEXT("CallServerMovePacked: Failed to serialize out movement data!"));
return;
}
// Copy bits to our struct that we can NetSerialize to the server.
PackedBits.DataBits.SetNumUninitialized(ServerMoveBitWriter.GetNumBits());
check(PackedBits.DataBits.Num() >= ServerMoveBitWriter.GetNumBits());
FMemory::Memcpy(PackedBits.DataBits.GetData(), ServerMoveBitWriter.GetData(), ServerMoveBitWriter.GetNumBytes());
// Send bits to server!
ServerMovePacked_ClientSend(PackedBits);
MarkForClientCameraUpdate();
}
void UCharacterMovementComponent::ServerMovePacked_ClientSend(const FCharacterServerMovePackedBits& PackedBits)
{
// Pass through RPC call to character on server, there is less RPC bandwidth overhead when used on an Actor rather than a Component.
CharacterOwner->ServerMovePacked(PackedBits);//RPC方法 把数据传送到服务端
}
void ACharacter::ServerMovePacked_Implementation(const FCharacterServerMovePackedBits& PackedBits)
{
GetCharacterMovement()->ServerMovePacked_ServerReceive(PackedBits);//此时已经是在服务上执行了
}server端 接收到 client传过来的数据 源码
//server端收到主控端发来的信息
void UCharacterMovementComponent::ServerMovePacked_ServerReceive(const FCharacterServerMovePackedBits& PackedBits)
{
if (!HasValidData() || !IsActive())
{
return;
}
const int32 NumBits = PackedBits.DataBits.Num();
if (NumBits > CharacterMovementCVars::NetPackedMovementMaxBits)//数据损坏 数量过大
{
// Protect against bad data that could cause server to allocate way too much memory.
UE_LOG(LogNetPlayerMovement, Error, TEXT("ServerMovePacked_ServerReceive (%s): Dropping move due to NumBits (%d) exceeding allowable limit (%d). See NetPackedMovementMaxBits."), *GetNameSafe(GetOwner()), NumBits, CharacterMovementCVars::NetPackedMovementMaxBits);
return;
}
// Reuse bit reader to avoid allocating memory each time.
ServerMoveBitReader.SetData((uint8*)PackedBits.DataBits.GetData(), NumBits);
#if UE_WITH_IRIS
if (UPackageMap* PackageMap = UE::Private::GetIrisPackageMapToReadReferences(CharacterOwner->GetNetConnection(), &PackedBits.ObjectReferences))
{
ServerMoveBitReader.PackageMap = PackageMap;
}
else
#endif
{
ServerMoveBitReader.PackageMap = PackedBits.GetPackageMap();
}
if (ServerMoveBitReader.PackageMap == nullptr)
{
devCode(UE_LOG(LogNetPlayerMovement, Error, TEXT("ServerMovePacked_ServerReceive: Failed to find PackageMap for data serialization!")));
return;
}
// Deserialize bits to move data struct.
// We had to wait until now and use the temp bit stream because the RPC doesn't know about the virtual overrides on the possibly custom struct that is our data container.
FCharacterNetworkMoveDataContainer& MoveDataContainer = GetNetworkMoveDataContainer();
if (!MoveDataContainer.Serialize(*this, ServerMoveBitReader, ServerMoveBitReader.PackageMap) || ServerMoveBitReader.IsError())
{
devCode(UE_LOG(LogNetPlayerMovement, Error, TEXT("ServerMovePacked_ServerReceive: Failed to serialize movement data!")));
return;
}
//把bit数据还原到FCharacterNetworkMoveDataContainer中
ServerMove_HandleMoveData(MoveDataContainer);
}
//同样不理解为啥一次要处理三个移动
void UCharacterMovementComponent::ServerMove_HandleMoveData(const FCharacterNetworkMoveDataContainer& MoveDataContainer)
{
// Optional "old move"
if (MoveDataContainer.bHasOldMove)//先处理最老的移动
{
if (FCharacterNetworkMoveData* OldMove = MoveDataContainer.GetOldMoveData())
{
SetCurrentNetworkMoveData(OldMove);
ServerMove_PerformMovement(*OldMove);
}
}
// Optional scoped movement update for dual moves to combine moves for cheaper performance on the server.
const bool bMoveAllowsScopedDualMove = MoveDataContainer.bHasPendingMove && !MoveDataContainer.bDisableCombinedScopedMove;
FScopedCapsuleMovementUpdate ScopedMovementUpdate(UpdatedComponent, bMoveAllowsScopedDualMove && bEnableServerDualMoveScopedMovementUpdates && bEnableScopedMovementUpdates);
// Optional pending move as part of "dual move"
if (MoveDataContainer.bHasPendingMove)//再处理上pending的移动
{
if (FCharacterNetworkMoveData* PendingMove = MoveDataContainer.GetPendingMoveData())
{
CharacterOwner->bServerMoveIgnoreRootMotion = MoveDataContainer.bIsDualHybridRootMotionMove && CharacterOwner->IsPlayingNetworkedRootMotionMontage();
SetCurrentNetworkMoveData(PendingMove);
ServerMove_PerformMovement(*PendingMove);
CharacterOwner->bServerMoveIgnoreRootMotion = false;
}
}
// Final standard move
if (FCharacterNetworkMoveData* NewMove = MoveDataContainer.GetNewMoveData())//最后处理当前的移动
{
SetCurrentNetworkMoveData(NewMove);
ServerMove_PerformMovement(*NewMove);
}
SetCurrentNetworkMoveData(nullptr);
}
//server 处理一次client传过来的 savemove的处理
void UCharacterMovementComponent::ServerMove_PerformMovement(const FCharacterNetworkMoveData& MoveData)
{
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementServerMove);
CSV_SCOPED_TIMING_STAT(CharacterMovement, CharacterMovementServerMove);
if (!HasValidData() || !IsActive())
{
return;
}
const float ClientTimeStamp = MoveData.TimeStamp;//时间戳
FVector ClientAccel = MoveData.Acceleration;//加速度
// Convert the move's acceleration to worldspace if necessary
if (CharacterMovementCVars::NetUseBaseRelativeAcceleration && MovementBaseUtility::IsDynamicBase(MoveData.MovementBase))
{
MovementBaseUtility::TransformDirectionToWorld(MoveData.MovementBase, MoveData.MovementBaseBoneName, MoveData.Acceleration, ClientAccel);
}
const uint8 ClientMoveFlags = MoveData.CompressedMoveFlags;//各种bool的flag，可以自定义扩展
const FRotator ClientControlRotation = MoveData.ControlRotation;
//这里有一个和FNetworkPredictionData_Client_Character对应的server结构，用来向client传数据
FNetworkPredictionData_Server_Character* ServerData = GetPredictionData_Server_Character();
check(ServerData);
//ServerData.CurrentClientTimeStamp 在 UCharacterMovementComponent::ForcePositionUpdate中每帧都在增加，
//所以ServerData.CurrentClientTimeStamp在和最近一次client savemove同步完时间后，每帧增加，在跟新的save move比较时间戳的时候，应该小于当前的save move的时间戳
if( !VerifyClientTimeStamp(ClientTimeStamp, *ServerData) )//校验时间戳
{
const float ServerTimeStamp = ServerData->CurrentClientTimeStamp;
// This is more severe if the timestamp has a large discrepancy and hasn't been recently reset.
if (ServerTimeStamp > 1.0f && FMath::Abs(ServerTimeStamp - ClientTimeStamp) > CharacterMovementCVars::NetServerMoveTimestampExpiredWarningThreshold)
{
UE_LOG(LogNetPlayerMovement, Warning, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), ClientTimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
}
else
{
UE_LOG(LogNetPlayerMovement, Log, TEXT("ServerMove: TimeStamp expired: %f, CurrentTimeStamp: %f, Character: %s"), ClientTimeStamp, ServerTimeStamp, *GetNameSafe(CharacterOwner));
}
return;
}
bool bServerReadyForClient = true;
APlayerController* PC = Cast<APlayerController>(CharacterOwner->GetController());
if (PC)
{
bServerReadyForClient = PC->NotifyServerReceivedClientData(CharacterOwner, ClientTimeStamp);
if (!bServerReadyForClient)
{
ClientAccel = FVector::ZeroVector;
}
}
const UWorld* MyWorld = GetWorld();
const float DeltaTime = ServerData->GetServerMoveDeltaTime(ClientTimeStamp, CharacterOwner->GetActorTimeDilation(*MyWorld));
// Defer all mesh child updates until all movement completes.
FScopedMeshMovementUpdate ScopedMeshUpdate(CharacterOwner->GetMesh());
if (DeltaTime > 0.f)
{
ServerData->CurrentClientTimeStamp = ClientTimeStamp;//同步一下时间戳
ServerData->ServerAccumulatedClientTimeStamp += DeltaTime;
ServerData->ServerTimeStamp = MyWorld->GetTimeSeconds();
ServerData->ServerTimeStampLastServerMove = ServerData->ServerTimeStamp;
if (AController* CharacterController = Cast<AController>(CharacterOwner->GetController()))
{
CharacterController->SetControlRotation(ClientControlRotation);
}
if (!bServerReadyForClient)
{
return;
}
// Perform actual movement
if ((MyWorld->GetWorldSettings()->GetPauserPlayerState() == NULL))
{
FScopedCapsuleMovementUpdate ScopedMovementUpdate(UpdatedComponent, bEnableScopedMovementUpdates);
if (PC)
{
PC->UpdateRotation(DeltaTime);
}
MoveAutonomous(ClientTimeStamp, DeltaTime, ClientMoveFlags, ClientAccel);//执行移动
}
UE_CLOG(CharacterOwner && UpdatedComponent, LogNetPlayerMovement, VeryVerbose, TEXT("ServerMove Time %f Acceleration %s Velocity %s Position %s Rotation %s GravityDirection %s DeltaTime %f Mode %s MovementBase %s.%s (Dynamic:%d)"),
ClientTimeStamp, *ClientAccel.ToString(), *Velocity.ToString(), *UpdatedComponent->GetComponentLocation().ToString(), *UpdatedComponent->GetComponentRotation().ToCompactString(), *GravityDirection.ToCompactString(), DeltaTime, *GetMovementName(),
*GetNameSafe(GetMovementBase()), *CharacterOwner->GetBasedMovement().BoneName.ToString(), MovementBaseUtility::IsDynamicBase(GetMovementBase()) ? 1 : 0);
}
// Validate move only after old and first dual portion, after all moves are completed.
if (MoveData.NetworkMoveType == FCharacterNetworkMoveData::ENetworkMoveType::NewMove)
{
//收集矫正信息存到serverdata中
ServerMoveHandleClientError(ClientTimeStamp, DeltaTime, ClientAccel, MoveData.Location, MoveData.MovementBase, MoveData.MovementBaseBoneName, MoveData.MovementMode);
}
}
//ServerData.CurrentClientTimeStamp 在 UCharacterMovementComponent::ForcePositionUpdate中每帧都在增加，
//所以ServerData.CurrentClientTimeStamp在和最近一次client savemove同步完时间后，每帧增加，在跟新的save move比较时间戳的时候，应该小于当前的save move的时间戳
bool UCharacterMovementComponent::IsClientTimeStampValid(float TimeStamp, const FNetworkPredictionData_Server_Character& ServerData, bool& bTimeStampResetDetected) const
{
if (TimeStamp <= 0.f || !FMath::IsFinite(TimeStamp))
{
return false;
}
// Very large deltas happen around a TimeStamp reset.
const float DeltaTimeStamp = (TimeStamp - ServerData.CurrentClientTimeStamp);//理论上这个值应该是小于0的
if( FMath::Abs(DeltaTimeStamp) > (MinTimeBetweenTimeStampResets * 0.5f) )//
{
// Client is resetting TimeStamp to increase accuracy.
bTimeStampResetDetected = true;
if( DeltaTimeStamp < 0.f )
{
// Validate that elapsed time since last reset is reasonable, otherwise client could be manipulating resets.
if (GetWorld()->TimeSince(LastTimeStampResetServerTime) < (MinTimeBetweenTimeStampResets * 0.5f))
{
// Reset too recently
return false;
}
else
{
// TimeStamp accepted with reset
return true;
}
}
else
{
// We already reset the TimeStamp, but we just got an old outdated move before the switch, not valid.
return false;
}
}
// If TimeStamp is in the past, move is outdated, not valid.
if( TimeStamp <= ServerData.CurrentClientTimeStamp )
{
return false;
}
// Precision issues (or reordered timestamps from old moves) can cause very small or zero deltas which cause problems.
if (DeltaTimeStamp < UCharacterMovementComponent::MIN_TICK_TIME)
{
return false;
}
// TimeStamp valid.
return true;
}会由一个FSavedMove_Character的池子pool，当需要一个FSavedMove_Character对象的时候，就从这个pool里拿，当不够的时候就创建一个
FSavedMovePtr FNetworkPredictionData_Client_Character::AllocateNewMove()
{
return FSavedMovePtr(new FSavedMove_Character());
}-----------------------------------------------------------------------------------------------
如果有个需求是：一个character 时而 接受input ，charactermovement 网络同步 正常工作，时而就当一个普通的actor沿着固定的路线自动运动
分析一下，正常模式下是charactermovement来影响RootComponent的位移和旋转。
正常模式下的character的位移和rotator变化的流程是
第一 rootcomponent是关闭网络同步的，要不和charactermovement打架
第二charactermovement的网络同步，在不同端分别影响updatecomponent。
所以在沿着固定路线自动移动的时候，要解决最大的问题是，让charactermovement不能影响RootComponent。让charactermovement不工作。同时启用rootcomponent的网络同步，通过在服务器上直接设置setactortransform，通过RootComponent->MoveComponent自动网络同步。
那么如何动态的设置charactermovement不工作呢
第一把组件的tick关掉
第二把另外事件驱动的ServerMove_XXXX之类的关掉，经过查找都有IsActive()过滤，于是可以通过setactive来滤掉ServerMove等操作。
例子如下
void XXCharacter::SetMovementTickEnable(bool TickEnable)
{
if (GetRootComponent() != nullptr)
{
GetRootComponent()->SetIsReplicated(!TickEnable);
}
if (UCharacterMovementComponent* Movement = GetCharacterMovement())
{
Movement->SetComponentTickEnabledAsync(TickEnable);
Movement->SetActive(TickEnable);
}
}之后就可以在server端的tick里面每帧都设置character的位置，就可以自动同步了
但是现实效果很不好，一卡一卡的。还是需要charactermovement正常工作 才行。
这也是当前charactermovement的一个弊端，官方已经注意到这个问题，所以5.4之后有个
character mover 2.0的功能，将来是要代替charactermovement的趋势。
------------------------------------------------------------------------------------------------------------
关于胶囊体的旋转
先 本地移动
然后 把移动保存为 save character 传给服务器
服务器 再移动
然后自动同步给模拟端
关于 compressedflag只同步到服务器 就不会往模拟端同步了
UpdateFromCompressedFlags 这里在服务器解压获得jump变量
可以在这里设置服务器上的 character的变量 然后把这个变量属性同步到模拟端
-----------------------------------------------------------------------------------------------------------------
角色 运动 停止 物理滑动 braking
只有加速度为0 或者 速度超过最大速度了，才会起作用，看如下代码
// Only apply braking if there is no acceleration, or we are over our max speed and need to slow down to it.
if ((bZeroAcceleration && bZeroRequestedAcceleration) || bVelocityOverMax)
{
const FVector OldVelocity = Velocity;
const float ActualBrakingFriction = (bUseSeparateBrakingFriction ? BrakingFriction : Friction);
ApplyVelocityBraking(DeltaTime, ActualBrakingFriction, BrakingDeceleration);
// Don't allow braking to lower us below max speed if we started above it.
if (bVelocityOverMax && Velocity.SizeSquared() < FMath::Square(MaxSpeed) && FVector::DotProduct(Acceleration, OldVelocity) > 0.0f)
{
Velocity = OldVelocity.GetSafeNormal() * MaxSpeed;
}
}如下代码是根据速度和摩擦系数等预计算出要刹车多长距离
FVector UAnimCharacterMovementLibrary::PredictGroundMovementStopLocation(const FVector& Velocity,
bool bUseSeparateBrakingFriction, float BrakingFriction, float GroundFriction, float BrakingFrictionFactor, float BrakingDecelerationWalking)
{
FVector PredictedStopLocation = FVector::ZeroVector;
float ActualBrakingFriction = (bUseSeparateBrakingFriction ? BrakingFriction : GroundFriction);
const float FrictionFactor = FMath::Max(0.f, BrakingFrictionFactor);
ActualBrakingFriction = FMath::Max(0.f, ActualBrakingFriction * FrictionFactor);
float BrakingDeceleration = FMath::Max(0.f, BrakingDecelerationWalking);
const FVector Velocity2D = Velocity * FVector(1.f, 1.f, 0.f);
FVector VelocityDir2D;
float Speed2D;
Velocity2D.ToDirectionAndLength(VelocityDir2D, Speed2D);
const float Divisor = ActualBrakingFriction * Speed2D + BrakingDeceleration;
if (Divisor > 0.f)
{
const float TimeToStop = Speed2D / Divisor;
PredictedStopLocation = Velocity2D * TimeToStop + 0.5f * ((-ActualBrakingFriction) * Velocity2D - BrakingDeceleration * VelocityDir2D) * TimeToStop * TimeToStop;
}
return PredictedStopLocation;
} 上面代码的蓝图
然后在动画蓝图中根据预计算出的距离，计算出刹车动画的那一帧开始播放
动画必须是把距离烘培到曲线的动画并且不能开启rootmotion
------------------------------------------------------------------------
-----------------------------------------------------------------------
AActor中
/**
* Return true if the given Pawn can be "based" on this actor (ie walk on it).
* @param Pawn - The pawn that wants to be based on this actor
*/
virtual bool CanBeBaseForCharacter(class APawn* Pawn) const;决定movement行走的时候 ，能不能跨过或者压过这个actor过去
另外
/**
* Return true if the given Pawn can step up onto this component.
* This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it.
* @param Pawn the Pawn that wants to step onto this component.
* @see CanCharacterStepUpOn
*/
UFUNCTION(BlueprintCallable, Category=Collision)
virtual bool CanCharacterStepUp(class APawn* Pawn) const;
bool UPrimitiveComponent::CanCharacterStepUp(APawn* Pawn) const
{
if ( CanCharacterStepUpOn != ECB_Owner )
{
return CanCharacterStepUpOn == ECB_Yes;
}
else
{
const AActor* Owner = GetOwner();
return Owner && Owner->CanBeBaseForCharacter(Pawn);
}
}----------------------------------------------------------
true 能走下悬崖
false 不能向前走
--------------------------------------------------------------------------------
跳起来 在空中 响应玩家input
跟 这三个参数有关，尤其是AirControl有关
//在计算速度的时候用的加速度是FallAcceleration
void UCharacterMovementComponent::PhysFalling(float deltaTime, int32 Iterations)
{
........
FVector FallAcceleration = GetFallingLateralAcceleration(deltaTime);
FallAcceleration.Z = 0.f;
const bool bHasLimitedAirControl = ShouldLimitAirControl(deltaTime, FallAcceleration);
while( (remainingTime >= MIN_TICK_TIME) && (Iterations < MaxSimulationIterations) )
{
........
const FVector OldVelocity = Velocity;
// Apply input
const float MaxDecel = GetMaxBrakingDeceleration();
if (!HasAnimRootMotion() && !CurrentRootMotion.HasOverrideVelocity())
{
// Compute Velocity
{
// Acceleration = FallAcceleration for CalcVelocity(), but we restore it after using it.
TGuardValue<FVector> RestoreAcceleration(Acceleration, FallAcceleration);
Velocity.Z = 0.f;
CalcVelocity(timeTick, FallingLateralFriction, false, MaxDecel);
Velocity.Z = OldVelocity.Z;
}
}
}
}
//FallAcceleration 用的是加速度的xy，本身包含input
//但是如果FallAcceleration.SizeSquared2D() > 0.f 就会对FallAcceleration 改变
//
FVector UCharacterMovementComponent::GetFallingLateralAcceleration(float DeltaTime)
{
// No acceleration in Z
FVector FallAcceleration = FVector(Acceleration.X, Acceleration.Y, 0.f);
// bound acceleration, falling object has minimal ability to impact acceleration
if (!HasAnimRootMotion() && FallAcceleration.SizeSquared2D() > 0.f)
{
FallAcceleration = GetAirControl(DeltaTime, AirControl, FallAcceleration);
FallAcceleration = FallAcceleration.GetClampedToMaxSize(GetMaxAcceleration());
}
return FallAcceleration;
}
//TickAirControl 大于0 就改变TickAirControl
FVector UCharacterMovementComponent::GetAirControl(float DeltaTime, float TickAirControl, const FVector& FallAcceleration)
{
// Boost
if (TickAirControl != 0.f)
{
TickAirControl = BoostAirControl(DeltaTime, TickAirControl, FallAcceleration);
}
return TickAirControl * FallAcceleration;
}
//如果速度小于AirControlBoostVelocityThreshold 就改变TickAirControl
//AirControlBoostMultiplier * TickAirControl
//所以把TickAirControl=1就会完全用原始加速度的xy
float UCharacterMovementComponent::BoostAirControl(float DeltaTime, float TickAirControl, const FVector& FallAcceleration)
{
// Allow a burst of initial acceleration
if (AirControlBoostMultiplier > 0.f && Velocity.SizeSquared2D() < FMath::Square(AirControlBoostVelocityThreshold))
{
TickAirControl = FMath::Min(1.f, AirControlBoostMultiplier * TickAirControl);
}
return TickAirControl;
}所以把AirControl=1 并且 AirControlBoostMultiplier>1 就会用原始的加速度的xy，就会响应input
-----------------------------------------------------------------------------------------------
input
用户的input 在这里传输到movement里面
void UCharacterMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
SCOPED_NAMED_EVENT(UCharacterMovementComponent_TickComponent, FColor::Yellow);
SCOPE_CYCLE_COUNTER(STAT_CharacterMovement);
SCOPE_CYCLE_COUNTER(STAT_CharacterMovementTick);
CSV_SCOPED_TIMING_STAT_EXCLUSIVE(CharacterMovement);
FVector InputVector = FVector::ZeroVector;
bool bUsingAsyncTick = (CharacterMovementCVars::AsyncCharacterMovement == 1) && IsAsyncCallbackRegistered();
if (!bUsingAsyncTick)
{
// Do not consume input if simulating asynchronously, we will consume input when filling out async inputs.
InputVector = ConsumeInputVector();
}
..........................................
// Allow root motion to move characters that have no controller.
if (CharacterOwner->IsLocallyControlled() || (!CharacterOwner->Controller && bRunPhysicsWithNoController) || (!CharacterOwner->Controller && CharacterOwner->IsPlayingRootMotion()))
{
ControlledCharacterMove(InputVector, DeltaTime);
}
}void UCharacterMovementComponent::ControlledCharacterMove(const FVector& InputVector, float DeltaSeconds)
{
{
SCOPE_CYCLE_COUNTER(STAT_CharUpdateAcceleration);
// We need to check the jump state before adjusting input acceleration, to minimize latency
// and to make sure acceleration respects our potentially new falling state.
CharacterOwner->CheckJumpInput(DeltaSeconds);
// apply input to acceleration
Acceleration = ScaleInputAcceleration(ConstrainInputAcceleration(InputVector));
AnalogInputModifier = ComputeAnalogInputModifier();
}
if (CharacterOwner->GetLocalRole() == ROLE_Authority)
{
PerformMovement(DeltaSeconds);
}
else if (CharacterOwner->GetLocalRole() == ROLE_AutonomousProxy && IsNetMode(NM_Client))
{
ReplicateMoveToServer(DeltaSeconds, Acceleration);
}
}FVector UCharacterMovementComponent::ConstrainInputAcceleration(const FVector& InputAcceleration) const
{
// walking or falling pawns ignore up/down sliding
if (InputAcceleration.Z != 0.f && (IsMovingOnGround() || IsFalling()))
{
return FVector(InputAcceleration.X, InputAcceleration.Y, 0.f);
}
return InputAcceleration;
}//
FVector UCharacterMovementComponent::ScaleInputAcceleration(const FVector& InputAcceleration) const
{
return GetMaxAcceleration() * InputAcceleration.GetClampedToMaxSize(1.0f);
}
//input最大就是1 acc最大也就是maxacc //加速度直接就影响速度了
void UCharacterMovementComponent::CalcVelocity(float DeltaTime, float Friction, bool bFluid, float BrakingDeceleration)
{
// Do not update velocity when using root motion or when SimulatedProxy and not simulating root motion - SimulatedProxy are repped their Velocity
if (!HasValidData() || HasAnimRootMotion() || DeltaTime < MIN_TICK_TIME || (CharacterOwner && CharacterOwner->GetLocalRole() == ROLE_SimulatedProxy && !bWasSimulatingRootMotion))
{
return;
}
Friction = FMath::Max(0.f, Friction);
const float MaxAccel = GetMaxAcceleration();
float MaxSpeed = GetMaxSpeed();
// Check if path following requested movement
bool bZeroRequestedAcceleration = true;
FVector RequestedAcceleration = FVector::ZeroVector;
float RequestedSpeed = 0.0f;
if (ApplyRequestedMove(DeltaTime, MaxAccel, MaxSpeed, Friction, BrakingDeceleration, RequestedAcceleration, RequestedSpeed))
{
bZeroRequestedAcceleration = false;
}
if (bForceMaxAccel)
{
// Force acceleration at full speed.
// In consideration order for direction: Acceleration, then Velocity, then Pawn's rotation.
if (Acceleration.SizeSquared() > UE_SMALL_NUMBER)
{
Acceleration = Acceleration.GetSafeNormal() * MaxAccel;
}
else
{
Acceleration = MaxAccel * (Velocity.SizeSquared() < UE_SMALL_NUMBER ? UpdatedComponent->GetForwardVector() : Velocity.GetSafeNormal());
}
AnalogInputModifier = 1.f;
}
// Path following above didn't care about the analog modifier, but we do for everything else below, so get the fully modified value.
// Use max of requested speed and max speed if we modified the speed in ApplyRequestedMove above.
const float MaxInputSpeed = FMath::Max(MaxSpeed * AnalogInputModifier, GetMinAnalogSpeed());
MaxSpeed = FMath::Max(RequestedSpeed, MaxInputSpeed);
// Apply braking or deceleration
const bool bZeroAcceleration = Acceleration.IsZero();
const bool bVelocityOverMax = IsExceedingMaxSpeed(MaxSpeed);
// Only apply braking if there is no acceleration, or we are over our max speed and need to slow down to it.
if ((bZeroAcceleration && bZeroRequestedAcceleration) || bVelocityOverMax)
{
const FVector OldVelocity = Velocity;
const float ActualBrakingFriction = (bUseSeparateBrakingFriction ? BrakingFriction : Friction);
ApplyVelocityBraking(DeltaTime, ActualBrakingFriction, BrakingDeceleration);
// Don't allow braking to lower us below max speed if we started above it.
if (bVelocityOverMax && Velocity.SizeSquared() < FMath::Square(MaxSpeed) && FVector::DotProduct(Acceleration, OldVelocity) > 0.0f)
{
Velocity = OldVelocity.GetSafeNormal() * MaxSpeed;
}
}
else if (!bZeroAcceleration)
{
// Friction affects our ability to change direction. This is only done for input acceleration, not path following.
const FVector AccelDir = Acceleration.GetSafeNormal();
const float VelSize = Velocity.Size();
Velocity = Velocity - (Velocity - AccelDir * VelSize) * FMath::Min(DeltaTime * Friction, 1.f);
}
// Apply fluid friction
if (bFluid)
{
Velocity = Velocity * (1.f - FMath::Min(Friction * DeltaTime, 1.f));
}
// Apply input acceleration
if (!bZeroAcceleration)
{
const float NewMaxInputSpeed = IsExceedingMaxSpeed(MaxInputSpeed) ? Velocity.Size() : MaxInputSpeed;
Velocity += Acceleration * DeltaTime;
Velocity = Velocity.GetClampedToMaxSize(NewMaxInputSpeed);
}
// Apply additional requested acceleration
if (!bZeroRequestedAcceleration)
{
const float NewMaxRequestedSpeed = IsExceedingMaxSpeed(RequestedSpeed) ? Velocity.Size() : RequestedSpeed;
Velocity += RequestedAcceleration * DeltaTime;
Velocity = Velocity.GetClampedToMaxSize(NewMaxRequestedSpeed);
}
if (bUseRVOAvoidance)
{
CalcAvoidanceVelocity(DeltaTime);
}
}值得注意的是 input 跟角色质量没有关系。如果input要考虑质量就得重写ScaleInputAcceleration方法
---------------------------------------------------------------------
charactermovement里面有几个方法是跟质量有关的
void UCharacterMovementComponent::AddImpulse( FVector Impulse, bool bVelocityChange )
{
if (!Impulse.IsZero() && (MovementMode != MOVE_None) && IsActive() && HasValidData())
{
// handle scaling by mass
FVector FinalImpulse = Impulse;
if ( !bVelocityChange )
{
if (Mass > UE_SMALL_NUMBER)
{
FinalImpulse = FinalImpulse / Mass;
}
else
{
UE_LOG(LogCharacterMovement, Warning, TEXT("Attempt to apply impulse to zero or negative Mass in CharacterMovement"));
}
}
PendingImpulseToApply += FinalImpulse;
}
}
void UCharacterMovementComponent::AddForce( FVector Force )
{
if (!Force.IsZero() && (MovementMode != MOVE_None) && IsActive() && HasValidData())
{
if (Mass > UE_SMALL_NUMBER)
{
PendingForceToApply += Force / Mass;
}
else
{
UE_LOG(LogCharacterMovement, Warning, TEXT("Attempt to apply force to zero or negative Mass in CharacterMovement"));
}
}
}
//PendingImpulseToApply 和 PendingForceToApply 直接影响速度Velocity ，注意force是要乘上帧时间的
void UCharacterMovementComponent::ApplyAccumulatedForces(float DeltaSeconds)
{
if (PendingImpulseToApply.Z != 0.f || PendingForceToApply.Z != 0.f)
{
// check to see if applied momentum is enough to overcome gravity
if ( IsMovingOnGround() && (PendingImpulseToApply.Z + (PendingForceToApply.Z * DeltaSeconds) + (GetGravityZ() * DeltaSeconds) > UE_SMALL_NUMBER))
{
SetMovementMode(MOVE_Falling);
}
}
Velocity += PendingImpulseToApply + (PendingForceToApply * DeltaSeconds);
// Don't call ClearAccumulatedForces() because it could affect launch velocity
PendingImpulseToApply = FVector::ZeroVector;
PendingForceToApply = FVector::ZeroVector;
}ApplyAccumulatedForces(DeltaSeconds);和质量有关
ApplyAccumulatedForces函数是在Physxxx函数之前调用的。
input和质量无关
UPrimitiveComponent下有这个，但是movement的物理并不走UpdatedComponent的物理
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Collision, meta=(ShowOnlyInnerProperties, SkipUCSModifiedProperties))
FBodyInstance BodyInstance;从UpdatedComponent的类型是 USceneComponent类型 就可以看到，movement只是生硬的操纵USceneComponent的位置和朝向而已。
UPROPERTY(BlueprintReadOnly, Transient, DuplicateTransient, Category=MovementComponent)
TObjectPtr<USceneComponent> UpdatedComponent;-----------------------------------------------------------------------------------------------
UCharacterMovementComponent管理角色的移动和空间状态（比如飞翔，游泳，攀爬）
UCharacterMovementComponent是Acharacter的一个组件。它最终操纵的是USceneComponent，如图中的CapsuleComponent。UCharacterMovementComponent::UpdateComponent。
------------------------------------------------------------------------------------------------------------------------------------------------------------
同类的移动组件不止一个如图（盗图）
详解上图四类移动组件
1、
UMovementComponent，实现了最基本的移动功能。调用顺序如下
UMovementComponent::SafeMoveUpdatedComponent()
UMovementComponent::MoveUpdatedComponentImpl()
UpdatedComponent->MoveComponent()
这里的UpdatedComponent就是UScenceComponent。
2、UNavMovementComponent，用于ai，能自动寻路。
3、UPawnMovementComponent，增加了被玩家控制的功能。
void UPawnMovementComponent::AddInputVector(FVector WorldAccel, bool bForce /*=false*/)
{
if (PawnOwner)
{
PawnOwner->Internal_AddMovementInput(WorldAccel, bForce);
}
}流程是，玩家通过InputComponent组件绑定一个按键操作，当按下按键的时候，调用pawn的AddMovementInput方法。
void APawn::AddMovementInput(FVector WorldDirection, float ScaleValue, bool bForce /*=false*/)
{
UPawnMovementComponent* MovementComponent = GetMovementComponent();
if (MovementComponent)
{
MovementComponent->AddInputVector(WorldDirection * ScaleValue, bForce);
}
else
{
Internal_AddMovementInput(WorldDirection * ScaleValue, bForce);
}
}调用结束后会通过ConsumeMovementInputVector()接口消耗掉该次操作的输入数值，完成一次移动操作。
4、UCharacterMovementComponent，此组件就是能操纵人型角色的移动组件了，里面非常精准的处理了各种常见的移动状态细节，实现了比较流畅的同步解决方案，各种位置矫正，平滑处理。我们不需要写很多自己的代码就能做出动作复杂的真实的FPS和第三人称的RPG游戏。
5、UProjectileMovementComponent ，一般用来模拟弓箭，子弹等抛射物的运动状态。
----------------------------------------------------------------------------------------------------------------------------------------------------------------
一个总的框架图（盗图）
来看看UCharacterMovementComponent进化历史：
在一个普通的三维空间里，最简单的移动就是直接修改角色的坐标。所以，我们的角色只要有一个包含坐标信息的组件，就可以通过基本的移动组件完成移动。但是随着游戏世界的复杂程度加深，我们在游戏里面添加了可行走的地面，可以探索的海洋。我们发现移动就变得复杂起来，玩家的脚下有地面才能行走，那就需要不停的检测地面碰撞信息（FFindFloorResult，FBasedMovementInfo）；玩家想进入水中游泳，那就需要检测到水的体积（GetPhysicsVolume()，Overlap事件，同样需要物理）；水中的速度与效果与陆地上差别很大，那就把两个状态分开写（PhysSwimming，PhysWalking）；移动的时候动画动作得匹配上啊，那就在更新位置的时候，更新动画（TickCharacterPose）；移动的时候碰到障碍物怎么办，被其他玩家推怎么处理（MoveAlongFloor里有相关处理）；游戏内容太少，想增加一些可以自己寻路的NPC，又需要设置导航网格（涉及到FNavAgentProperties）；一个玩家太无聊，那就让大家一起联机玩（模拟移动同步FRepMovement，客户端移动修正ClientUpdatePositionAfterServerUpdate）。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
UCharacterMovementComponent是如何处理各种移动状态下的玩家呢？首先从tick开始，因为每帧都要检测、判断、处理各种状态，状态通过MovementMode来区分，在合适的时候修改为正确的移动模式。移动模式默认几种：
/** Movement modes for Characters. */
UENUM(BlueprintType)
enum EMovementMode
{
/** None (movement is disabled). */
MOVE_None UMETA(DisplayName="None"),
/** Walking on a surface. */
MOVE_Walking UMETA(DisplayName="Walking"),
/**
* Simplified walking on navigation data (e.g. navmesh).
* If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move.
* If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions.
*/
MOVE_NavWalking UMETA(DisplayName="Navmesh Walking"),
/** Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. */
MOVE_Falling UMETA(DisplayName="Falling"),
/** Swimming through a fluid volume, under the effects of gravity and buoyancy. */
MOVE_Swimming UMETA(DisplayName="Swimming"),
/** Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. */
MOVE_Flying UMETA(DisplayName="Flying"),
/** User-defined custom movement mode, including many possible sub-modes. */
MOVE_Custom UMETA(DisplayName="Custom"),
MOVE_MAX UMETA(Hidden),
};
扫一扫
634
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
