UALSCharacterMovementComponent Class Reference

#include <ALSCharacterMovementComponent.h>

Inheritance diagram for UALSCharacterMovementComponent:

Classes
class	FNetworkPredictionData_Client_My
class	FSavedMove_My

Protected Member Functions
virtual void	MulticastEnableAlignGravityToBase ()
virtual void	MulticastDisableAlignGravityToBase ()
virtual void	MulticastSetGravityScale (const float NewGravityScale)
virtual void	MulticastSetFixedGravityDirection (const FVector &NewFixedGravityDirection)
virtual void	MulticastSetSplineTangentGravityDirection (AActor *NewGravityActor)
virtual void	MulticastSetPointGravityDirection (const FVector &NewGravityPoint)
virtual void	MulticastSetPointGravityDirectionFromActor (AActor *NewGravityActor)
virtual void	MulticastSetLineGravityDirection (const FVector &NewGravityLineStart, const FVector &NewGravityLineEnd)
virtual void	MulticastSetSegmentGravityDirection (const FVector &NewGravitySegmentStart, const FVector &NewGravitySegmentEnd)
virtual void	MulticastSetSplineGravityDirection (AActor *NewGravityActor)
virtual void	MulticastSetPlaneGravityDirection (const FVector &NewGravityPlaneBase, const FVector &NewGravityPlaneNormal)
virtual void	MulticastSetSplinePlaneGravityDirection (AActor *NewGravityActor)
virtual void	MulticastSetBoxGravityDirection (const FVector &NewGravityBoxOrigin, const FVector &NewGravityBoxExtent)
virtual void	MulticastSetBoxGravityDirectionFromActor (AActor *NewGravityActor)
virtual void	MulticastSetCollisionGravityDirection (AActor *NewGravityActor)
void	GravityDirectionChanged (const EGravityDirectionMode OldGravityDirectionMode)
virtual bool	GetShouldReplicateGravity () const

Protected Attributes
EGravityDirectionMode	GravityDirectionMode
FVector	GravityVectorA
FVector	GravityVectorB
TObjectPtr< AActor >	GravityActor
float	OldGravityScale
uint32	bDirtyGravityDirection:1
uint32	bDisableGravityReplication:1

Private Member Functions
virtual void	UpdateFromCompressedFlags (uint8 Flags) override
virtual class FNetworkPredictionData_Client *	GetPredictionData_Client () const override
virtual void	OnMovementUpdated (float DeltaTime, const FVector &OldLocation, const FVector &OldVelocity) override
virtual void	PhysWalking (float deltaTime, int32 Iterations) override
virtual float	GetMaxAcceleration () const override
virtual float	GetMaxBrakingDeceleration () const override
float	GetMappedSpeed () const
void	SetMovementSettings (FALSMovementSettings NewMovementSettings)
void	SetAllowedGait (EALSGait NewAllowedGait)
void	Server_SetAllowedGait (EALSGait NewAllowedGait)
virtual void	SetNewGravityScale (const float NewGravity) override
virtual void	ResetGravityScale () override
virtual void	SetFixedGravityDirection (const FVector &NewFixedGravityDirection) override
virtual void	SetSplineTangentGravityDirection (AActor *NewGravityActor) override
virtual void	SetPointGravityDirection (const FVector &NewGravityPoint) override
virtual void	SetPointGravityDirectionFromActor (AActor *NewGravityActor) override
virtual void	SetLineGravityDirection (const FVector &NewGravityLineStart, const FVector &NewGravityLineEnd) override
virtual void	SetSegmentGravityDirection (const FVector &NewGravitySegmentStart, const FVector &NewGravitySegmentEnd) override
virtual void	SetSplineGravityDirection (AActor *NewGravityActor) override
virtual void	SetPlaneGravityDirection (const FVector &NewGravityPlaneBase, const FVector &NewGravityPlaneNormal) override
virtual void	SetSplinePlaneGravityDirection (AActor *NewGravityActor) override
virtual void	SetBoxGravityDirection (const FVector &NewGravityBoxOrigin, const FVector &NewGravityBoxExtent) override
virtual void	SetBoxGravityDirectionFromActor (AActor *NewGravityActor) override
virtual void	SetCollisionGravityDirection (AActor *NewGravityActor) override
virtual bool	GetIsWalking () const override
virtual void	LaunchCharacter (const FVector &LaunchVel) override
virtual FVector	GetGravityDirection () const override
virtual void	UpdateGravity ()
virtual void	ReplicateGravityToClients ()
virtual void	SetAlignGravityToBase (bool bNewAlignGravityToBase)

Private Attributes
uint8	bRequestMovementSettingsChange = 1
EALSGait	AllowedGait = EALSGait::Walking
FALSMovementSettings	CurrentMovementSettings
FOnGravityDirectionChanged	OnGravityDirectionChanged
uint32	bAlignGravityToBase:1

Additional Inherited Members

Detailed Description

Authoritative networked Character Movement

Member Function Documentation

GetGravityDirection()

FVector UALSCharacterMovementComponent::GetGravityDirection ( ) const

overrideprivatevirtual

Implements IALSGravityMovementInterface.

{
    switch (GravityDirectionMode)
    {
        case EGravityDirectionMode::Fixed:
            // Gravity is in a fixed direction (GravityVectorA).
            return GravityVectorA.GetSafeNormal();
 
        case EGravityDirectionMode::Point:
            // Gravity pulls towards a specific point (like a planet center).
            if (GravityActor)
            {
                return (GravityActor->GetActorLocation() - GetOwner()->GetActorLocation()).GetSafeNormal();
            }
            return (GravityVectorA - GetOwner()->GetActorLocation()).GetSafeNormal();
 
        case EGravityDirectionMode::Line:
        case EGravityDirectionMode::Segment:
            // Gravity is along a line or segment between two points (GravityVectorA and GravityVectorB).
            return (GravityVectorB - GravityVectorA).GetSafeNormal();
 
        case EGravityDirectionMode::Spline:
        case EGravityDirectionMode::SplineTangent:
        case EGravityDirectionMode::SplinePlane:
            // Gravity follows the tangent of a spline (typically along a path).
            if (const USplineComponent* Spline = Cast<USplineComponent>(GravityActor->GetComponentByClass(USplineComponent::StaticClass())))
            {
                FVector ClosestPoint = Spline->FindLocationClosestToWorldLocation(GetOwner()->GetActorLocation(), ESplineCoordinateSpace::World);
                return Spline->FindTangentClosestToWorldLocation(ClosestPoint, ESplineCoordinateSpace::World).GetSafeNormal();
            }
            break;
 
        case EGravityDirectionMode::Plane:
            // Gravity is along a plane normal (GravityVectorB is the normal).
            return GravityVectorB.GetSafeNormal();
 
        case EGravityDirectionMode::Box:
            // Gravity is towards the center of a box.
            return (GravityVectorA - GetOwner()->GetActorLocation()).GetSafeNormal();
 
        case EGravityDirectionMode::Collision:
            // Gravity is derived from a collision (e.g., based on the normal of the collision surface).
            if (GravityActor)
            {
                const UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(GravityActor->GetRootComponent());
                if (PrimitiveComponent)
                {
                    return PrimitiveComponent->GetComponentLocation().GetSafeNormal();
                }
            }
            break;
 
        default:
            break;
    }
    // Fallback to world gravity (e.g., downwards) if no specific direction is set.
    return FVector(0.0f, 0.0f, -1.0f);
}

GetIsWalking()

bool UALSCharacterMovementComponent::GetIsWalking ( ) const

overrideprivatevirtual

Returns true if the character is in the 'Walking' movement mode.

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    return IsWalking();
}

GetMappedSpeed()

float UALSCharacterMovementComponent::GetMappedSpeed ( ) const

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::GetMappedSpeed);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    // Map the character's current speed to the configured movement speeds with a range of 0-3,
    // with 0 = stopped, 1 = the Walk Speed, 2 = the Run Speed, and 3 = the Sprint Speed.
    // This allows us to vary the movement speeds but still use the mapped range in calculations for consistent results
 
    const float Speed = Velocity.Size2D();
    const float LocWalkSpeed = CurrentMovementSettings.WalkSpeed;
    const float LocRunSpeed = CurrentMovementSettings.RunSpeed;
    const float LocSprintSpeed = CurrentMovementSettings.SprintSpeed;
 
    if (Speed > LocRunSpeed)
    {
        return FMath::GetMappedRangeValueClamped<float, float>({LocRunSpeed, LocSprintSpeed}, {2.0f, 3.0f}, Speed);
    }
 
    if (Speed > LocWalkSpeed)
    {
        return FMath::GetMappedRangeValueClamped<float, float>({LocWalkSpeed, LocRunSpeed}, {1.0f, 2.0f}, Speed);
    }
 
    return FMath::GetMappedRangeValueClamped<float, float>({0.0f, LocWalkSpeed}, {0.0f, 1.0f}, Speed);
}

GetMaxAcceleration()

float UALSCharacterMovementComponent::GetMaxAcceleration ( ) const

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::GetMaxAcceleration);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    // Update the Acceleration using the Movement Curve.
    // This allows for fine control over movement behavior at each speed.
    if (!IsMovingOnGround() || !CurrentMovementSettings.MovementCurve)
    {
        return Super::GetMaxAcceleration();
    }
    return CurrentMovementSettings.MovementCurve->GetVectorValue(GetMappedSpeed()).X;
}

GetMaxBrakingDeceleration()

float UALSCharacterMovementComponent::GetMaxBrakingDeceleration ( ) const

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::GetMaxBrakingDeceleration);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    // Update the Deceleration using the Movement Curve.
    // This allows for fine control over movement behavior at each speed.
    if (!IsMovingOnGround() || !CurrentMovementSettings.MovementCurve)
    {
        return Super::GetMaxBrakingDeceleration();
    }
    return CurrentMovementSettings.MovementCurve->GetVectorValue(GetMappedSpeed()).Y;
}

GetPredictionData_Client()

class FNetworkPredictionData_Client * UALSCharacterMovementComponent::GetPredictionData_Client ( ) const

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::GetPredictionData_Client);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    check(PawnOwner != nullptr);
 
    if (!ClientPredictionData)
    {
        UALSCharacterMovementComponent* MutableThis = const_cast<UALSCharacterMovementComponent*>(this);
 
        MutableThis->ClientPredictionData = new FNetworkPredictionData_Client_My(*this);
        MutableThis->ClientPredictionData->MaxSmoothNetUpdateDist = 92.f;
        MutableThis->ClientPredictionData->NoSmoothNetUpdateDist = 140.f;
    }
 
    return ClientPredictionData;
}

GetShouldReplicateGravity()

bool UALSCharacterMovementComponent::GetShouldReplicateGravity ( ) const

protectedvirtual

Asks if gravity data should be replicated from server to clients.

Returns

true if gravity data should be replicated

{
    return (!bDisableGravityReplication && CharacterOwner != nullptr &&
    CharacterOwner->HasAuthority() && GetNetMode() != ENetMode::NM_Standalone);
 
}

GravityDirectionChanged()

void UALSCharacterMovementComponent::GravityDirectionChanged ( const EGravityDirectionMode OldGravityDirectionMode )

protected

Called after GravityDirectionMode (or related data) has changed.

Parameters

OldGravityDirectionMode

- previous value of GravityDirectionMode

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    OnGravityDirectionChanged.Broadcast(OldGravityDirectionMode, GravityDirectionMode);
 
    // Call owner delegate
    // IALSCharacterInterface* Character = Cast<IALSCharacterInterface>(CharacterOwner);
    // if (Character != nullptr)
    // {
    //  Character->GravityDirectionChanged(OldGravityDirectionMode, GravityDirectionMode);
    // }
 
}

LaunchCharacter()

void UALSCharacterMovementComponent::LaunchCharacter ( const FVector & LaunchVel )

overrideprivatevirtual

Queue a pending launch with velocity LaunchVel.

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    Launch(LaunchVel);
}

MulticastDisableAlignGravityToBase()

virtual void UALSCharacterMovementComponent::MulticastDisableAlignGravityToBase ( )

protectedvirtual

Disables bAlignGravityToBase flag for clients.

MulticastEnableAlignGravityToBase()

virtual void UALSCharacterMovementComponent::MulticastEnableAlignGravityToBase ( )

protectedvirtual

Enables bAlignGravityToBase flag for clients.

MulticastSetBoxGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetBoxGravityDirection ( const FVector & NewGravityBoxOrigin, const FVector & NewGravityBoxExtent )

protectedvirtual

Replicates a new axis-aligned box for gravity to clients.

Parameters

NewGravityBoxOrigin	- origin of the box
NewGravityBoxExtent	- extents of the box

MulticastSetBoxGravityDirectionFromActor()

virtual void UALSCharacterMovementComponent::MulticastSetBoxGravityDirectionFromActor ( AActor * NewGravityActor )

protectedvirtual

Replicates a new axis-aligned box for gravity to clients.

Parameters

NewGravityActor

- Actor that provides its collision bounding box as gravity target

MulticastSetCollisionGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetCollisionGravityDirection ( AActor * NewGravityActor )

protectedvirtual

Replicates a new collision geometry for gravity to clients.

Parameters

NewGravityActor

- Actor that owns the PrimitiveComponent that has collision geometry

MulticastSetFixedGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetFixedGravityDirection ( const FVector & NewFixedGravityDirection )

protectedvirtual

Replicates a new fixed gravity direction to clients.

Parameters

NewFixedGravityDirection

- new fixed gravity direction, assumes it is normalized

MulticastSetGravityScale()

virtual void UALSCharacterMovementComponent::MulticastSetGravityScale ( const float NewGravityScale )

protectedvirtual

Replicates gravity scale factor to clients.

Parameters

NewGravityScale

- new gravity scale factor

MulticastSetLineGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetLineGravityDirection ( const FVector & NewGravityLineStart, const FVector & NewGravityLineEnd )

protectedvirtual

Replicates a new infinite line for gravity to clients.

Parameters

NewGravityLineStart	- a point that belongs to the infinite line
NewGravityLineEnd	- another point that belongs to the infinite line

MulticastSetPlaneGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetPlaneGravityDirection ( const FVector & NewGravityPlaneBase, const FVector & NewGravityPlaneNormal )

protectedvirtual

Replicates a new infinite plane for gravity to clients.

Parameters

NewGravityPlaneBase	- a point that belongs to the plane
NewGravityPlaneNormal	- normal of the plane, assumes it is normalized

MulticastSetPointGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetPointGravityDirection ( const FVector & NewGravityPoint )

protectedvirtual

Replicates a new gravity point to clients.

Parameters

NewGravityPoint

- new point which gravity direction points to

MulticastSetPointGravityDirectionFromActor()

virtual void UALSCharacterMovementComponent::MulticastSetPointGravityDirectionFromActor ( AActor * NewGravityActor )

protectedvirtual

Replicates a new gravity point to clients.

Parameters

NewGravityActor

- Actor that provides its location as gravity point

MulticastSetSegmentGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetSegmentGravityDirection ( const FVector & NewGravitySegmentStart, const FVector & NewGravitySegmentEnd )

protectedvirtual

Replicates a new segment line for gravity to clients.

Parameters

NewGravitySegmentStart	- start point of the segment line
NewGravitySegmentEnd	- end point of the segment line

MulticastSetSplineGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetSplineGravityDirection ( AActor * NewGravityActor )

protectedvirtual

Replicates a new spline for gravity to clients.

Parameters

NewGravityActor

- Actor that provides a spline

MulticastSetSplinePlaneGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetSplinePlaneGravityDirection ( AActor * NewGravityActor )

protectedvirtual

Replicates a new infinite plane determined by closest spline point for gravity to clients.

Parameters

NewGravityActor

- Actor that provides a spline

MulticastSetSplineTangentGravityDirection()

virtual void UALSCharacterMovementComponent::MulticastSetSplineTangentGravityDirection ( AActor * NewGravityActor )

protectedvirtual

Replicates a new spline gravity direction to clients.

Parameters

NewGravityActor

- Actor that provides a spline

OnMovementUpdated()

void UALSCharacterMovementComponent::OnMovementUpdated ( float DeltaTime, const FVector & OldLocation, const FVector & OldVelocity )

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::OnMovementUpdated);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    Super::OnMovementUpdated(DeltaTime, OldLocation, OldVelocity);
 
    
    if (!CharacterOwner)
    {
        return;
    }
 
    // Set Movement Settings
    if (bRequestMovementSettingsChange)
    {
        const float UpdateMaxWalkSpeed = CurrentMovementSettings.GetSpeedForGait(AllowedGait);
        MaxWalkSpeed = UpdateMaxWalkSpeed;
        MaxWalkSpeedCrouched = UpdateMaxWalkSpeed;
 
        bRequestMovementSettingsChange = false;
    }
 
    
    //~ Gravity Functions   //
    UpdateGravity();
    if(GetShouldReplicateGravity())
    {
        ReplicateGravityToClients();
    }
 
}

PhysWalking()

void UALSCharacterMovementComponent::PhysWalking ( float deltaTime, int32 Iterations )

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::PhysWalking);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    if (CurrentMovementSettings.MovementCurve)
    {
        // Update the Ground Friction using the Movement Curve.
        // This allows for fine control over movement behavior at each speed.
        GroundFriction = CurrentMovementSettings.MovementCurve->GetVectorValue(GetMappedSpeed()).Z;
    }
    Super::PhysWalking(deltaTime, Iterations);
}

ReplicateGravityToClients()

void UALSCharacterMovementComponent::ReplicateGravityToClients ( )

privatevirtual

Sends gravity data from server to clients.

{
    if (bDirtyGravityDirection)
    {
        // Replicate gravity direction to clients
        switch (GravityDirectionMode)
        {
        case EGravityDirectionMode::Fixed:
            {
                MulticastSetFixedGravityDirection(GravityVectorA);
                break;
            }
 
        case EGravityDirectionMode::SplineTangent:
            {
                MulticastSetSplineTangentGravityDirection(GravityActor);
                break;
            }
 
        case EGravityDirectionMode::Point:
            {
                MulticastSetPointGravityDirection(GravityVectorA);
                break;
            }
 
        case EGravityDirectionMode::Line:
            {
                MulticastSetLineGravityDirection(GravityVectorA, GravityVectorB);
                break;
            }
 
        case EGravityDirectionMode::Segment:
            {
                MulticastSetSegmentGravityDirection(GravityVectorA, GravityVectorB);
                break;
            }
 
        case EGravityDirectionMode::Spline:
            {
                MulticastSetSplineGravityDirection(GravityActor);
                break;
            }
 
        case EGravityDirectionMode::Plane:
            {
                MulticastSetPlaneGravityDirection(GravityVectorA, GravityVectorB);
                break;
            }
 
        case EGravityDirectionMode::SplinePlane:
            {
                MulticastSetSplinePlaneGravityDirection(GravityActor);
                break;
            }
 
        case EGravityDirectionMode::Box:
            {
                MulticastSetBoxGravityDirection(GravityVectorA, GravityVectorB);
                break;
            }
 
        case EGravityDirectionMode::Collision:
            {
                MulticastSetCollisionGravityDirection(GravityActor);
                break;
            }
        }
 
        bDirtyGravityDirection = false;
    }
    if (OldGravityScale != GravityScale)
    {
        // Replicate gravity scale to clients
        MulticastSetGravityScale(GravityScale);
        OldGravityScale = GravityScale;
    }
}

ResetGravityScale()

void UALSCharacterMovementComponent::ResetGravityScale ( )

overrideprivatevirtual

Implements IALSGravityMovementInterface.

{
    GravityScale = OldGravityScale;
}

Server_SetAllowedGait()

void UALSCharacterMovementComponent::Server_SetAllowedGait ( EALSGait NewAllowedGait )

private

SetAlignGravityToBase()

void UALSCharacterMovementComponent::SetAlignGravityToBase ( bool bNewAlignGravityToBase )

privatevirtual

Sets a new state for bAlignGravityToBase flag.

Parameters

bNewAlignGravityToBase

- new value for bAlignGravityToBase flag

{
    if (bAlignGravityToBase == bNewAlignGravityToBase)
    {
        return;
    }
 
    bAlignGravityToBase = bNewAlignGravityToBase;
 
    if (GetShouldReplicateGravity())
    {
        if (!bAlignGravityToBase)
        {
            MulticastDisableAlignGravityToBase();
        }
        else
        {
            MulticastEnableAlignGravityToBase();
        }
    }
 
}

SetAllowedGait()

void UALSCharacterMovementComponent::SetAllowedGait ( EALSGait NewAllowedGait )

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::SetAllowedGait);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    if (AllowedGait != NewAllowedGait)
    {
        if (PawnOwner->IsLocallyControlled())
        {
            AllowedGait = NewAllowedGait;
            if (GetCharacterOwner()->GetLocalRole() == ROLE_AutonomousProxy)
            {
                Server_SetAllowedGait(NewAllowedGait);
            }
            bRequestMovementSettingsChange = true;
            return;
        }
        if (!PawnOwner->HasAuthority())
        {
            const float UpdateMaxWalkSpeed = CurrentMovementSettings.GetSpeedForGait(AllowedGait);
            MaxWalkSpeed = UpdateMaxWalkSpeed;
            MaxWalkSpeedCrouched = UpdateMaxWalkSpeed;
        }
    }
}

SetBoxGravityDirection()

void UALSCharacterMovementComponent::SetBoxGravityDirection ( const FVector & NewGravityBoxOrigin, const FVector & NewGravityBoxExtent )

overrideprivatevirtual

Sets a new axis-aligned box which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityBoxOrigin	- origin of the box
NewGravityBoxExtent	- extents of the box

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (GravityDirectionMode == EGravityDirectionMode::Box &&
    GravityVectorA == NewGravityBoxOrigin && GravityVectorB == NewGravityBoxExtent)
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Box;
    GravityVectorA = NewGravityBoxOrigin;
    GravityVectorB = NewGravityBoxExtent;
    GravityActor = nullptr;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
 
}

SetBoxGravityDirectionFromActor()

void UALSCharacterMovementComponent::SetBoxGravityDirectionFromActor ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new axis-aligned box which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that provides its collision bounding box as gravity target

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (GravityDirectionMode == EGravityDirectionMode::Box && GravityActor == NewGravityActor)
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Box;
    GravityActor = NewGravityActor;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
 
}

SetCollisionGravityDirection()

void UALSCharacterMovementComponent::SetCollisionGravityDirection ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new collision geometry which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that owns the PrimitiveComponent that has collision geometry

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::Collision &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const UPrimitiveComponent* Primitive = Cast<UPrimitiveComponent>(NewGravityActor->GetRootComponent());
    if (Primitive != nullptr)
    {
        const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
        bDirtyGravityDirection = true;
        GravityDirectionMode = EGravityDirectionMode::Collision;
        GravityActor = NewGravityActor;
 
        GravityDirectionChanged(OldGravityDirectionMode);
    }
 
 
}

SetFixedGravityDirection()

void UALSCharacterMovementComponent::SetFixedGravityDirection ( const FVector & NewFixedGravityDirection )

overrideprivatevirtual

Sets a new fixed gravity direction.

Note

It can be influenced by GravityScale

Parameters

NewFixedGravityDirection

- new fixed gravity direction, assumes it is normalized

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewFixedGravityDirection.IsZero() ||
    (GravityDirectionMode == EGravityDirectionMode::Fixed &&
    GravityVectorA == NewFixedGravityDirection))
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Fixed;
    GravityVectorA = NewFixedGravityDirection;
    GravityDirectionChanged(OldGravityDirectionMode);
}

SetLineGravityDirection()

void UALSCharacterMovementComponent::SetLineGravityDirection ( const FVector & NewGravityLineStart, const FVector & NewGravityLineEnd )

overrideprivatevirtual

Sets a new infinite line which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityLineStart	- a point that belongs to the infinite line
NewGravityLineEnd	- another point that belongs to the infinite line

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityLineStart == NewGravityLineEnd ||
        (GravityDirectionMode == EGravityDirectionMode::Line &&
        GravityVectorA == NewGravityLineStart && GravityVectorB == NewGravityLineEnd))
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Line;
    GravityVectorA = NewGravityLineStart;
    GravityVectorB = NewGravityLineEnd;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
}

SetMovementSettings()

void UALSCharacterMovementComponent::SetMovementSettings ( FALSMovementSettings NewMovementSettings )

private

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::SetMovementSettings);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    // Set the current movement settings from the owner
    CurrentMovementSettings = NewMovementSettings;
    bRequestMovementSettingsChange = true;
}

SetNewGravityScale()

void UALSCharacterMovementComponent::SetNewGravityScale ( const float NewGravity )

overrideprivatevirtual

Implements IALSGravityMovementInterface.

{
    OldGravityScale = GravityScale;
    GravityScale = NewGravity;
}

SetPlaneGravityDirection()

void UALSCharacterMovementComponent::SetPlaneGravityDirection ( const FVector & NewGravityPlaneBase, const FVector & NewGravityPlaneNormal )

overrideprivatevirtual

Sets a new infinite plane which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityPlaneBase	- a point that belongs to the plane
NewGravityPlaneNormal	- normal of the plane, assumes it is normalized

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityPlaneNormal.IsZero() ||
    (GravityDirectionMode == EGravityDirectionMode::Plane &&
    GravityVectorA == NewGravityPlaneBase && GravityVectorB == NewGravityPlaneNormal))
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Plane;
    GravityVectorA = NewGravityPlaneBase;
    GravityVectorB = NewGravityPlaneNormal;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
 
}

SetPointGravityDirection()

void UALSCharacterMovementComponent::SetPointGravityDirection ( const FVector & NewGravityPoint )

overrideprivatevirtual

Sets a new point which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityPoint

- new point which gravity direction points to

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (GravityDirectionMode == EGravityDirectionMode::Point &&
        GravityVectorA == NewGravityPoint)
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Point;
    GravityVectorA = NewGravityPoint;
    GravityActor = nullptr;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
}

SetPointGravityDirectionFromActor()

void UALSCharacterMovementComponent::SetPointGravityDirectionFromActor ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new point which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that provides its location as gravity point

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (GravityDirectionMode == EGravityDirectionMode::Point &&
        GravityActor == NewGravityActor)
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Point;
    GravityActor = NewGravityActor;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
}

SetSegmentGravityDirection()

void UALSCharacterMovementComponent::SetSegmentGravityDirection ( const FVector & NewGravitySegmentStart, const FVector & NewGravitySegmentEnd )

overrideprivatevirtual

Sets a new segment line which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravitySegmentStart	- start point of the segment line
NewGravitySegmentEnd	- end point of the segment line

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravitySegmentStart == NewGravitySegmentEnd ||
    (GravityDirectionMode == EGravityDirectionMode::Segment &&
    GravityVectorA == NewGravitySegmentStart && GravityVectorB == NewGravitySegmentEnd))
    {
        return;
    }
 
    const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
    bDirtyGravityDirection = true;
    GravityDirectionMode = EGravityDirectionMode::Segment;
    GravityVectorA = NewGravitySegmentStart;
    GravityVectorB = NewGravitySegmentEnd;
 
    GravityDirectionChanged(OldGravityDirectionMode);
 
 
}

SetSplineGravityDirection()

void UALSCharacterMovementComponent::SetSplineGravityDirection ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new spline which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that provides a spline

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::Spline &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
        bDirtyGravityDirection = true;
        GravityDirectionMode = EGravityDirectionMode::Spline;
        GravityActor = NewGravityActor;
 
        GravityDirectionChanged(OldGravityDirectionMode);
    }
}

SetSplinePlaneGravityDirection()

void UALSCharacterMovementComponent::SetSplinePlaneGravityDirection ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new infinite plane determined by closest spline point and spline up vector which gravity direction points to.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that provides a spline

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::SplinePlane &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
        bDirtyGravityDirection = true;
        GravityDirectionMode = EGravityDirectionMode::SplinePlane;
        GravityActor = NewGravityActor;
 
        GravityDirectionChanged(OldGravityDirectionMode);
    }
 
 
}

SetSplineTangentGravityDirection()

void UALSCharacterMovementComponent::SetSplineTangentGravityDirection ( AActor * NewGravityActor )

overrideprivatevirtual

Sets a new gravity direction determined by closest spline tangent.

Note

It can be influenced by GravityScale

Parameters

NewGravityActor

- Actor that provides a spline

Implements IALSGravityMovementInterface.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement_Gravity);
    if (NewGravityActor == nullptr ||
        (GravityDirectionMode == EGravityDirectionMode::SplineTangent &&
        GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        const EGravityDirectionMode OldGravityDirectionMode = GravityDirectionMode;
 
        bDirtyGravityDirection = true;
        GravityDirectionMode = EGravityDirectionMode::SplineTangent;
        GravityActor = NewGravityActor;
 
        GravityDirectionChanged(OldGravityDirectionMode);
    }
 
}

UpdateFromCompressedFlags()

void UALSCharacterMovementComponent::UpdateFromCompressedFlags ( uint8 Flags )

overrideprivatevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UALSCharacterMovementComponent::UpdateFromCompressedFlags);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Movement);
 
    Super::UpdateFromCompressedFlags(Flags);
 
    bRequestMovementSettingsChange = (Flags & FSavedMove_Character::FLAG_Custom_0) != 0;
}

UpdateGravity()

void UALSCharacterMovementComponent::UpdateGravity ( )

privatevirtual

Update values related to gravity.

{
    if (!bAlignGravityToBase || !IsMovingOnGround())
    {
        return;
    }
 
    switch (GravityDirectionMode)
    {
    case EGravityDirectionMode::Fixed:
        {
            if (!CurrentFloor.HitResult.ImpactNormal.IsZero())
            {
                // Set the fixed gravity direction to reversed floor normal vector
                SetFixedGravityDirection(CurrentFloor.HitResult.ImpactNormal * -1.0f);
            }
 
            break;
        }
 
    case EGravityDirectionMode::Point:
        {
            if (CurrentFloor.HitResult.GetActor() != nullptr)
            {
                // Set the point gravity direction from base
                SetPointGravityDirectionFromActor(CurrentFloor.HitResult.GetActor());
            }
 
            break;
        }
 
    case EGravityDirectionMode::Box:
        {
            if (CurrentFloor.HitResult.GetActor() != nullptr)
            {
                // Set the box gravity direction from base
                SetBoxGravityDirectionFromActor(CurrentFloor.HitResult.GetActor());
            }
 
            break;
        }
    case EGravityDirectionMode::Collision:
    default:
        {
            if (CurrentFloor.HitResult.GetActor() != nullptr)
            {
                // Set the collision gravity direction from base
                SetCollisionGravityDirection(CurrentFloor.HitResult.GetActor());
            }
 
            break;
        }
    }
 
}

Member Data Documentation

AllowedGait

EALSGait UALSCharacterMovementComponent::AllowedGait = EALSGait::Walking

private

bAlignGravityToBase

uint32 UALSCharacterMovementComponent::bAlignGravityToBase

private

If true and a floor is found, rotate gravity direction and align it to floor base.

Note

For "Fixed" gravity mode, gravity direction is set to reverse floor normal vector

For "Point" gravity mode, gravity direction points to base's location

For "Box" gravity mode, gravity direction points to base's bounding box

For "Collision" gravity mode, gravity direction points to base's collision geometry

bDirtyGravityDirection

uint32 UALSCharacterMovementComponent::bDirtyGravityDirection

protected

If true, gravity direction changed and needs to be replicated.

bDisableGravityReplication

uint32 UALSCharacterMovementComponent::bDisableGravityReplication

protected

If true, gravity data isn't replicated from server to clients.

bRequestMovementSettingsChange

uint8 UALSCharacterMovementComponent::bRequestMovementSettingsChange = 1

private

CurrentMovementSettings

FALSMovementSettings UALSCharacterMovementComponent::CurrentMovementSettings

private

GravityActor

TObjectPtr<AActor> UALSCharacterMovementComponent::GravityActor

protected

Optional Actor that determines direction of gravity.

GravityDirectionMode

EGravityDirectionMode UALSCharacterMovementComponent::GravityDirectionMode

protected

Mode that determines direction of gravity.

GravityVectorA

FVector UALSCharacterMovementComponent::GravityVectorA

protected

Stores information that determines direction of gravity.

GravityVectorB

FVector UALSCharacterMovementComponent::GravityVectorB

protected

Stores additional information that determines direction of gravity.

OldGravityScale

float UALSCharacterMovementComponent::OldGravityScale

protected

Stores last known value of GravityScale.

See also

GravityScale

OnGravityDirectionChanged

FOnGravityDirectionChanged UALSCharacterMovementComponent::OnGravityDirectionChanged

private

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Public/Character/ALSCharacterMovementComponent.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Private/Character/ALSCharacterMovementComponent.cpp