#include <ALSBaseCharacter.h>

Inheritance diagram for AALSBaseCharacter:

Public Member Functions
	AALSBaseCharacter (const FObjectInitializer &ObjectInitializer)

FORCEINLINE class UALSCharacterMovementComponent *	GetALSMovementComponent () const

virtual FVector	GetLeftHandGoal () const override

virtual FVector	GetRightHandGoal () const override

virtual EALSOverlayState	GetCurrentOverlayState () const override

virtual bool	GetIsMantling () const override

virtual FORCEINLINE IALSGravityMovementInterface *	GetALSGravityMovementInterface () const override

virtual void	Ragdoll () override

virtual void	Tick (float DeltaTime) override

virtual void	BeginPlay () override

virtual void	PostInitializeComponents () override

virtual void	GetLifetimeReplicatedProps (TArray< FLifetimeProperty > &OutLifetimeProps) const override

UAnimMontage *	GetGetUpAnimation (bool bRagdollFaceUpState)

virtual void	RagdollStart ()

virtual void	RagdollEnd ()

void	Server_SetMeshLocationDuringRagdoll (FVector MeshLocation)

void	SetMovementState (EALSMovementState NewState, bool bForce=false)

EALSMovementState	GetMovementState () const

EALSMovementState	GetPrevMovementState () const

void	SetMovementAction (EALSMovementAction NewAction, bool bForce=false)

EALSMovementAction	GetMovementAction () const

void	SetStance (EALSStance NewStance, bool bForce=false)

EALSStance	GetStance () const

void	SetOverlayOverrideState (int32 NewState)

int32	GetOverlayOverrideState () const

void	SetGait (EALSGait NewGait, bool bForce=false)

EALSGait	GetGait () const

EALSGait	GetDesiredGait () const

virtual void	SetRotationMode (EALSRotationMode NewRotationMode, bool bForce=false)

void	Server_SetRotationMode (EALSRotationMode NewRotationMode, bool bForce)

EALSRotationMode	GetRotationMode () const

virtual void	SetViewMode (EALSViewMode NewViewMode, bool bForce=false)

void	Server_SetViewMode (EALSViewMode NewViewMode, bool bForce)

EALSViewMode	GetViewMode () const

void	SetOverlayState (EALSOverlayState NewState, bool bForce=false)

void	SetGroundedEntryState (EALSGroundedEntryState NewState)

void	Server_SetOverlayState (EALSOverlayState NewState, bool bForce)

EALSOverlayState	GetOverlayState () const

EALSGroundedEntryState	GetGroundedEntryState () const

void	EventOnLanded ()

void	Multicast_OnLanded ()

void	EventOnJumped ()

void	Multicast_OnJumped ()

void	Server_PlayMontage (UAnimMontage *Montage, float PlayRate)

void	Multicast_PlayMontage (UAnimMontage *Montage, float PlayRate)

void	Server_StopMontage (const float InBlendOutTime, const UAnimMontage *Montage)

void	Multicast_StopMontage (const float InBlendOutTime, const UAnimMontage *Montage)

void	ReplicatedRagdollStart ()

void	Server_RagdollStart ()

void	Multicast_RagdollStart ()

void	ReplicatedRagdollEnd ()

void	Server_RagdollEnd (FVector CharacterLocation)

void	Multicast_RagdollEnd (FVector CharacterLocation)

EALSStance	GetDesiredStance () const

void	SetDesiredStance (EALSStance NewStance)

void	Server_SetDesiredStance (EALSStance NewStance)

void	SetDesiredGait (EALSGait NewGait)

void	Server_SetDesiredGait (EALSGait NewGait)

EALSRotationMode	GetDesiredRotationMode () const

virtual void	SetDesiredRotationMode (EALSRotationMode NewRotMode)

void	Server_SetDesiredRotationMode (EALSRotationMode NewRotMode)

void	SetActorLocationAndTargetRotation (FVector NewLocation, FRotator NewRotation)

bool	HasMovementInput () const

FALSMovementSettings	GetTargetMovementSettings () const

virtual EALSGait	GetAllowedGait () const

EALSGait	GetActualGait (EALSGait AllowedGait) const

virtual bool	CanSprint () const

void	OnBreakfall ()

virtual void	OnBreakfall_Implementation ()

virtual float	PlayReplicatedMontage (UAnimMontage *MontageToPlay, const float InPlayRate, const EMontagePlayReturnType ReturnValueType, const float InTimeToStartMontageAt, const bool bStopAllMontages) override

virtual void	StopReplicatedMontage (const float InBlendOutTime, const UAnimMontage *Montage) override

void	Replicated_PlayMontage (UAnimMontage *Montage, float PlayRate)

virtual void	Replicated_PlayMontage_Implementation (UAnimMontage *Montage, float PlayRate)

UAnimMontage *	GetRollAnimation ()

float	GetAnimCurveValue (FName CurveName) const

void	SetVisibleMesh (USkeletalMesh *NewSkeletalMesh)

void	Server_SetVisibleMesh (USkeletalMesh *NewSkeletalMesh)

bool	IsRightShoulder () const

void	SetRightShoulder (const bool bNewRightShoulder)

bool	IsAimingDownSights () const

virtual bool	GetCanAimDownSights () const

void	SetAimDownSights (const bool bNewAimDownSights)

virtual ECollisionChannel	GetThirdPersonTraceParams (FVector &TraceOrigin, float &TraceRadius)

virtual FTransform	GetThirdPersonPivotTarget ()

virtual FVector	GetFirstPersonCameraTarget ()

virtual FVector	GetAimDownSightCameraTarget () const

virtual float	GetAimDownSightFOV () const

void	GetCameraParameters (float &TPFOVOut, float &FPFOVOut, bool &bRightShoulderOut) const

void	SetCameraBehavior (UALSPlayerCameraBehavior *CamBeh)

FVector	GetAcceleration () const

bool	IsMoving () const

bool	GetIsFlying () const

FVector	GetMovementInput () const

float	GetMovementInputAmount () const

float	GetSpeed () const

FRotator	GetAimingRotation () const

float	GetAimYawRate () const

virtual void	ForwardMovementAction (float Value)

virtual void	RightMovementAction (float Value)

void	CameraUpAction (float Value)

void	CameraRightAction (float Value)

virtual void	JumpAction (bool bValue)

virtual void	SprintAction (bool bValue)

virtual void	AimAction (bool bValue)

virtual void	CameraTapAction ()

virtual void	CameraHeldAction ()

virtual void	StanceAction ()

void	WalkAction ()

void	RagdollAction ()

void	VelocityDirectionAction ()

void	LookingDirectionAction ()

Public Member Functions inherited from AInteractableCharacter
	AInteractableCharacter (const FObjectInitializer &ObjectInitializer)

virtual USceneComponent *	GetThrowPoint () const override

virtual void	ReceiveStartFocus (AActor *Caller)

virtual void	ReceiveEndFocus (AActor *Caller)

virtual void	ReceiveOnInteract (AActor *Caller, const EInteractionType InteractionType)

virtual void	ReceiveOnEndInteract (AActor *Caller)

virtual void	ReceiveOnOverlap (AActor *Caller)

virtual void	ReceiveOnEndOverlap (AActor *Caller)

virtual void	ReceiveToggleSwitch (AActor *Caller, const bool bOn)

Public Member Functions inherited from ACharacterBase
	ACharacterBase (const FObjectInitializer &ObjectInitializer)

virtual void	SetupPlayerInputComponent (class UInputComponent *PlayerInputComponent) override

virtual bool	SaveGame () override

virtual bool	LoadGame () override

virtual USkeletalMeshComponent *	GetCharacterMesh () const override

virtual UPrimitiveComponent *	GetPrimitiveComponent () override

virtual void	RagdollStop () override

virtual bool	GetCharacterHealth (float &Health, float &MaxHealth) const override

virtual FCharacterBaseSkills &	GetCharacterSkills () override

virtual bool	GetAudioSocketLocation (const FName &AudioSocket, FVector &Location) const override

virtual FCharacterInfo	GetCharacterInfo () const override

virtual void	GetThrowStats (FTransform &OutTransform, FVector &OutThrowForce) const override

virtual void	CharacterModeChanged (const FGameplayTag &NewMode) override

virtual int32	GetStrength () const

virtual int32	GetPerception () const

virtual int32	GetEndurance () const

virtual int32	GetCharisma () const

virtual int32	GetIntelligence () const

virtual int32	GetAgility () const

virtual int32	GetWeaponSkill () const

virtual int32	GetStealth () const

virtual int32	GetLuck () const

virtual int32	GetSkillPoints () const

Public Attributes
float	GravityMultiplier = 9.8f

FJumpPressedSignature	JumpPressedDelegate

FOnJumpedSignature	OnJumpedDelegate

FRagdollStateChangedSignature	RagdollStateChangedDelegate

Public Attributes inherited from ACharacterBase
FOnCharacterDeath	OnCharacterDeath

Protected Member Functions
void	RagdollUpdate (float DeltaTime)

void	SetActorLocationDuringRagdoll (float DeltaTime)

virtual void	OnMovementModeChanged (EMovementMode PrevMovementMode, uint8 PreviousCustomMode=0) override

virtual void	OnMovementStateChanged (EALSMovementState PreviousState)

virtual void	OnMovementActionChanged (EALSMovementAction PreviousAction)

virtual void	OnStanceChanged (EALSStance PreviousStance)

virtual void	OnRotationModeChanged (EALSRotationMode PreviousRotationMode)

virtual void	OnGaitChanged (EALSGait PreviousGait)

virtual void	OnViewModeChanged (EALSViewMode PreviousViewMode)

virtual void	OnOverlayStateChanged (EALSOverlayState PreviousState)

virtual void	OnVisibleMeshChanged (const USkeletalMesh *PreviousSkeletalMesh)

virtual void	OnStartCrouch (float HalfHeightAdjust, float ScaledHalfHeightAdjust) override

virtual void	OnEndCrouch (float HalfHeightAdjust, float ScaledHalfHeightAdjust) override

virtual void	OnJumped_Implementation () override

virtual void	Landed (const FHitResult &Hit) override

void	OnLandFrictionReset ()

void	SetEssentialValues (float DeltaTime)

void	UpdateCharacterMovement ()

void	UpdateGroundedRotation (float DeltaTime)

void	UpdateInAirRotation (float DeltaTime)

void	SmoothCharacterRotation (FRotator Target, float TargetInterpSpeed, float ActorInterpSpeed, float DeltaTime)

float	CalculateGroundedRotationRate () const

void	LimitRotation (float AimYawMin, float AimYawMax, float InterpSpeed, float DeltaTime)

void	SetMovementModel ()

void	ForceUpdateCharacterState ()

void	OnRep_RotationMode (EALSRotationMode PrevRotMode)

void	OnRep_ViewMode (EALSViewMode PrevViewMode)

void	OnRep_OverlayState (EALSOverlayState PrevOverlayState)

void	OnRep_VisibleMesh (const USkeletalMesh *PreviousSkeletalMesh)

void	HandleNonMovingRotation (float DeltaTime)

Protected Member Functions inherited from AInteractableCharacter
virtual void	OnPawnSpawned () override

virtual void	InteractionDataUpdated ()

Protected Member Functions inherited from ACharacterBase
virtual void	NotifyHit (UPrimitiveComponent MyComp, AActor Other, UPrimitiveComponent *OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult &Hit) override

virtual void	FallOver (const float WaitTime)

void	OnFallOver (const float WaitTime)

virtual void	GetUpFromFall ()

void	OnGetUpFromFall ()

void	OnRep_CharacterDeath ()

IPlayerControllerInterface *	GetPlayerControllerInterface ()

IPlayerStateInterface *	GetPlayerStateInterface ()

void	LogDebugError (const FString &Message) const

void	LogDebugError (const FString &Message, const int32 Value) const

void	LogDebugError (const FString &Message, const float Value) const

void	LogDebugWarning (const FString &Message) const

void	LogDebugWarning (const FString &Message, const int32 Value) const

void	LogDebugWarning (const FString &Message, const float Value) const

void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const

void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const

void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const

void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const

void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const

void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
TObjectPtr< UALSCharacterMovementComponent >	MyCharacterMovementComponent

bool	bOptimizeGroundRotation = true

bool	bOptimizeAnimValues = true

FALSAnimValues	AnimValues

IALSAnimInterface *	AnimInstanceInterface

EALSRotationMode	DesiredRotationMode = EALSRotationMode::LookingDirection

EALSGait	DesiredGait = EALSGait::Running

EALSStance	DesiredStance = EALSStance::Standing

float	LookUpDownRate = 1.25f

float	LookLeftRightRate = 1.25f

float	RollDoubleTapTimeout = 0.3f

bool	bBreakFall = false

bool	bSprintHeld = false

float	ThirdPersonFOV = 90.0f

float	FirstPersonFOV = 90.0f

bool	bRightShoulder = false

bool	bAimDownSights = false

FDataTableRowHandle	MovementModel

FVector	Acceleration = FVector::ZeroVector

bool	bIsMoving = false

bool	bIsFlying = false

bool	bHasMovementInput = false

FRotator	LastVelocityRotation

FRotator	LastMovementInputRotation

float	Speed = 0.0f

float	MovementInputAmount = 0.0f

float	AimYawRate = 0.0f

float	EasedMaxAcceleration = 0.0f

FVector	ReplicatedCurrentAcceleration = FVector::ZeroVector

FRotator	ReplicatedControlRotation = FRotator::ZeroRotator

TObjectPtr< USkeletalMesh >	VisibleMesh = nullptr

EALSOverlayState	OverlayState = EALSOverlayState::Default

EALSGroundedEntryState	GroundedEntryState

EALSMovementState	MovementState = EALSMovementState::None

EALSMovementState	PrevMovementState = EALSMovementState::None

EALSMovementAction	MovementAction = EALSMovementAction::None

EALSRotationMode	RotationMode = EALSRotationMode::LookingDirection

EALSGait	Gait = EALSGait::Walking

EALSStance	Stance = EALSStance::Standing

EALSViewMode	ViewMode = EALSViewMode::ThirdPerson

int32	OverlayOverrideState = 0

FALSMovementStateSettings	MovementData

FRotator	TargetRotation = FRotator::ZeroRotator

FRotator	InAirRotation = FRotator::ZeroRotator

float	YawOffset = 0.0f

bool	bBreakfallOnLand = true

float	BreakfallOnLandVelocity = 700.0f

bool	bReversedPelvis = false

bool	bRagdollOnLand = false

float	RagdollOnLandVelocity = 1000.0f

bool	bRagdollOnGround = false

bool	bRagdollFaceUp = false

FVector	LastRagdollVelocity = FVector::ZeroVector

FVector	TargetRagdollLocation = FVector::ZeroVector

float	ServerRagdollPull = 0.0f

EVisibilityBasedAnimTickOption	DefVisBasedTickOp

bool	bPreRagdollURO = false

FVector	PreviousVelocity = FVector::ZeroVector

float	PreviousAimYaw = 0.0f

TObjectPtr< UALSPlayerCameraBehavior >	CameraBehavior

float	LastStanceInputTime = 0.0f

FTimerHandle	OnLandedFrictionResetTimer

FRotator	AimingRotation = FRotator::ZeroRotator

bool	bEnableNetworkOptimizations = false

bool	bForceEnableNetworkOptimizationsOff = false

Protected Attributes inherited from AInteractableCharacter
USceneComponent *	ThrowPoint

class UInteractionComponent *	InteractionComponent

class UInteractableActorComponent *	InteractableActorComponent

class USphereComponent *	InteractionSphere

class UInventoryComponent *	InventoryComponent

class UAudioReactionComponent *	AudioReactionComponent

bool	bAlwaysShowOutline = false

Protected Attributes inherited from ACharacterBase
bool	bDebuggingMode = false

FCharacterBaseSkills	CharacterSkills

FCharacterInfo	CharacterInfo

bool	bDead = false

float	PickupThrowIntensity = 500.0f

bool	bCanBePushed = false

float	HitVelocityThreshold = 50.0f

float	HitVelocityMultiplier = 5.0f

float	HitReactionMultiplier = 0.01f

bool	bPushHitReaction = true

bool	bAddMovementInput = true

bool	bAddCharacterMovement = true

float	PushFallVelocityThreshold = 200.0f

float	PushedFallVelocityThreshold = 500.0f

float	PushedFallOverWaitTime = 2.0f

Private Member Functions
void	SetupCapsuleComponent () const

void	SetupMeshComponent () const

Private Attributes
TObjectPtr< UALSDebugComponent >	ALSDebugComponent = nullptr

Constructor & Destructor Documentation

◆ AALSBaseCharacter()

AALSBaseCharacter::AALSBaseCharacter ( const FObjectInitializer & ObjectInitializer )

    : Super(ObjectInitializer.SetDefaultSubobjectClass<UALSCharacterMovementComponent>(CharacterMovementComponentName))
{
    PrimaryActorTick.bCanEverTick = true;
    bUseControllerRotationYaw = false;
    bReplicates = true;
    SetReplicatingMovement(true);
    
    SetupCapsuleComponent();    
    SetupMeshComponent();
    UDataTable* MovementDT =  UBaseHelpersBPLib::GetDefaultDataTable("/ALSV4_CPP/AdvancedLocomotionV4/Data/DataTables/MovementModelTable");
    MovementModel.DataTable = MovementDT;
    MovementModel.RowName = FName("Normal");
}

Member Function Documentation

◆ AimAction()

void AALSBaseCharacter::AimAction ( bool bValue )

virtual

Reimplemented in AMultiplayerPlayerCharacter, and ACustomPlayerCharacter.

{
    if(bValue)
    {
        // AimAction: Hold "AimAction" to enter the aiming mode, release to revert back the desired rotation mode.
        SetRotationMode(EALSRotationMode::Aiming);
    }
    else
    {
        if (ViewMode == EALSViewMode::ThirdPerson)
        {
            SetRotationMode(DesiredRotationMode);
        }
        else if (ViewMode == EALSViewMode::FirstPerson)
        {
            SetRotationMode(EALSRotationMode::LookingDirection);
        }
    }
}

◆ BeginPlay()

void AALSBaseCharacter::BeginPlay ( )

overridevirtual

Reimplemented from AInteractableCharacter.

Reimplemented in AALSCharacter, ACampaignAICharacter, ACampaignPlayerCharacter, ACustomAICharacter, ACustomCharacterBase, ACustomPlayerCharacter, and AMultiplayerPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::BeginPlay);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    Super::BeginPlay();
    //@ TEST Optimizations 
    if(GetMesh() != nullptr && GetMesh()->GetAnimInstance() != nullptr)
    {
        AnimInstanceInterface = Cast<IALSAnimInterface>(GetMesh()->GetAnimInstance());
    }
 
    // If we're in networked game, disable curved movement
    bEnableNetworkOptimizations = !IsNetMode(NM_Standalone);
    if(bForceEnableNetworkOptimizationsOff){bEnableNetworkOptimizations = false;}
 
    // Make sure the mesh and animbp update after the CharacterBP to ensure it gets the most recent values.
    GetMesh()->AddTickPrerequisiteActor(this);
 
    // Set the Movement Model
    SetMovementModel();
 
    // Force update states to use the initial desired values.
    ForceUpdateCharacterState();
 
    if (Stance == EALSStance::Standing)
    {
        UnCrouch();
    }
    else if (Stance == EALSStance::Crouching)
    {
        Crouch();
    }
 
    // Set default rotation values.
    TargetRotation = GetActorRotation();
    LastVelocityRotation = TargetRotation;
    LastMovementInputRotation = TargetRotation;
 
    if (GetMesh()->GetAnimInstance() && GetLocalRole() == ROLE_SimulatedProxy)
    {
        GetMesh()->GetAnimInstance()->SetRootMotionMode(ERootMotionMode::IgnoreRootMotion);
    }
 
    MyCharacterMovementComponent->SetMovementSettings(GetTargetMovementSettings());
 
    ALSDebugComponent = FindComponentByClass<UALSDebugComponent>();
}

◆ CalculateGroundedRotationRate()

float AALSBaseCharacter::CalculateGroundedRotationRate ( ) const

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Calculate the rotation rate by using the current Rotation Rate Curve in the Movement Settings.
    // Using the curve in conjunction with the mapped speed gives you a high level of control over the rotation
    // rates for each speed. Increase the speed if the camera is rotating quickly for more responsive rotation.
    if (ensure(IsValid(MyCharacterMovementComponent) && ensure(IsValid(MyCharacterMovementComponent->CurrentMovementSettings.RotationRateCurve))))
    {
        const float MappedSpeedVal = MyCharacterMovementComponent->GetMappedSpeed();
        const float CurveVal =
            MyCharacterMovementComponent->CurrentMovementSettings.RotationRateCurve->GetFloatValue(MappedSpeedVal);
        const float ClampedAimYawRate = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 300.0f}, {1.0f, 3.0f}, AimYawRate);
        return CurveVal * ClampedAimYawRate;
    }
    return 0.0f;
}

◆ CameraHeldAction()

void AALSBaseCharacter::CameraHeldAction ( )

virtual

Reimplemented in AMultiplayerPlayerCharacter.

{
    // Switch camera mode
    if (ViewMode == EALSViewMode::FirstPerson)
    {
        SetViewMode(EALSViewMode::ThirdPerson);
    }
    else if (ViewMode == EALSViewMode::ThirdPerson)
    {
        SetViewMode(EALSViewMode::FirstPerson);
    }
}

◆ CameraRightAction()

void AALSBaseCharacter::CameraRightAction ( float Value )

◆ CameraTapAction()

void AALSBaseCharacter::CameraTapAction ( )

virtual

Reimplemented in AMultiplayerPlayerCharacter.

{
    if (ViewMode == EALSViewMode::FirstPerson)
    {
        // Don't swap shoulders on first person mode
        return;
    }
 
    // Switch shoulders
    SetRightShoulder(!bRightShoulder);
}

◆ CameraUpAction()

void AALSBaseCharacter::CameraUpAction ( float Value )

◆ CanSprint()

bool AALSBaseCharacter::CanSprint ( ) const

virtual

Reimplemented in ACustomAICharacter, and ACustomCharacterBase.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::CanSprint);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    // Determine if the character is currently able to sprint based on the Rotation mode and current acceleration
    // (input) rotation. If the character is in the Looking Rotation mode, only allow sprinting if there is full
    // movement input and it is faced forward relative to the camera + or - 50 degrees.
 
    if (!bHasMovementInput || RotationMode == EALSRotationMode::Aiming)
    {
        return false;
    }
 
    const bool bValidInputAmount = MovementInputAmount > 0.9f;
 
    if (RotationMode == EALSRotationMode::VelocityDirection)
    {
        return bValidInputAmount;
    }
 
    if (RotationMode == EALSRotationMode::LookingDirection)
    {
        const FRotator AccRot = ReplicatedCurrentAcceleration.ToOrientationRotator();
        FRotator Delta = AccRot - AimingRotation;
        Delta.Normalize();
 
        return bValidInputAmount && FMath::Abs(Delta.Yaw) < 50.0f;
    }
 
    return false;
}

◆ EventOnJumped()

void AALSBaseCharacter::EventOnJumped ( )

On Jumped

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Set the new In Air Rotation to the velocity rotation if speed is greater than 100.
    InAirRotation = Speed > 100.0f ? LastVelocityRotation : GetActorRotation();
 
    OnJumpedDelegate.Broadcast();
}

◆ EventOnLanded()

void AALSBaseCharacter::EventOnLanded ( )

Landed, Jumped, Rolling, Mantling and Ragdoll On Landed

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::EventOnLanded);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    const float VelZ = FMath::Abs(GetCharacterMovement()->Velocity.Z);
 
    if (bRagdollOnLand && VelZ > RagdollOnLandVelocity)
    {
        ReplicatedRagdollStart();
    }
    else if (bBreakfallOnLand && bHasMovementInput && VelZ >= BreakfallOnLandVelocity)
    {
        OnBreakfall();
    }
    else
    {
        GetCharacterMovement()->BrakingFrictionFactor = bHasMovementInput ? 0.5f : 3.0f;
 
        // After 0.5 secs, reset braking friction factor to zero
        GetWorldTimerManager().SetTimer(OnLandedFrictionResetTimer, this,
                                        &AALSBaseCharacter::OnLandFrictionReset, 0.5f, false);
    }
}

◆ ForceUpdateCharacterState()

void AALSBaseCharacter::ForceUpdateCharacterState ( )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::ForceUpdateCharacterState);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    SetGait(DesiredGait, true);
    SetStance(DesiredStance, true);
    SetRotationMode(DesiredRotationMode, true);
    SetViewMode(ViewMode, true);
    SetOverlayState(OverlayState, true);
    SetMovementState(MovementState, true);
    SetMovementAction(MovementAction, true);
}

◆ ForwardMovementAction()

void AALSBaseCharacter::ForwardMovementAction ( float Value )

virtual

Input

Reimplemented in ACustomCharacterBase.

{
    if (MovementState == EALSMovementState::Grounded || MovementState == EALSMovementState::InAir)
    {
        // Default camera relative movement behavior
        const FRotator DirRotator(0.0f, AimingRotation.Yaw, 0.0f);
        AddMovementInput(UKismetMathLibrary::GetForwardVector(DirRotator), Value);
    }
}

◆ GetAcceleration()

FVector AALSBaseCharacter::GetAcceleration ( ) const

inline

Essential Information Getters/Setters

341{ return Acceleration; }

AALSBaseCharacter::Acceleration

FVector Acceleration

Definition ALSBaseCharacter.h:548

◆ GetActualGait()

EALSGait AALSBaseCharacter::GetActualGait ( EALSGait AllowedGait ) const

{
    // Get the Actual Gait. This is calculated by the actual movement of the character,  and so it can be different
    // from the desired gait or allowed gait. For instance, if the Allowed Gait becomes walking,
    // the Actual gait will still be running until the character decelerates to the walking speed.
 
    const float LocWalkSpeed = MyCharacterMovementComponent->CurrentMovementSettings.WalkSpeed;
    const float LocRunSpeed = MyCharacterMovementComponent->CurrentMovementSettings.RunSpeed;
 
    if (Speed > LocRunSpeed + 10.0f)
    {
        if (AllowedGait == EALSGait::Sprinting)
        {
            return EALSGait::Sprinting;
        }
        return EALSGait::Running;
    }
 
    if (Speed >= LocWalkSpeed + 10.0f)
    {
        return EALSGait::Running;
    }
 
    return EALSGait::Walking;
}

◆ GetAimDownSightCameraTarget()

FVector AALSBaseCharacter::GetAimDownSightCameraTarget ( ) const

virtual

Reimplemented in ACustomPlayerCharacter.

{
    if(GetMesh() == nullptr){return FVector::ZeroVector;}
    return GetMesh()->GetSocketLocation(NAME_ADS_Camera);
}

◆ GetAimDownSightFOV()

float AALSBaseCharacter::GetAimDownSightFOV ( ) const

virtual

Reimplemented in ACustomPlayerCharacter.

{
    return FirstPersonFOV;
}

◆ GetAimingRotation()

FRotator AALSBaseCharacter::GetAimingRotation ( ) const

inline

360{ return AimingRotation; }

◆ GetAimYawRate()

float AALSBaseCharacter::GetAimYawRate ( ) const

inline

363{ return AimYawRate; }

◆ GetAllowedGait()

EALSGait AALSBaseCharacter::GetAllowedGait ( ) const

virtual

Reimplemented in ACustomCharacterBase, ACustomPlayerCharacter, and AMultiplayerPlayerCharacter.

{
    // Calculate the Allowed Gait. This represents the maximum Gait the character is currently allowed to be in,
    // and can be determined by the desired gait, the rotation mode, the stance, etc. For example,
    // if you wanted to force the character into a walking state while indoors, this could be done here.
 
    if (Stance == EALSStance::Standing)
    {
        if (RotationMode != EALSRotationMode::Aiming)
        {
            if (DesiredGait == EALSGait::Sprinting)
            {
                return CanSprint() ? EALSGait::Sprinting : EALSGait::Running;
            }
            return DesiredGait;
        }
    }
 
    // Crouching stance & Aiming rot mode has same behaviour
 
    if (DesiredGait == EALSGait::Sprinting)
    {
        return EALSGait::Running;
    }
 
    return DesiredGait;
}

◆ GetALSGravityMovementInterface()

virtual FORCEINLINE IALSGravityMovementInterface * AALSBaseCharacter::GetALSGravityMovementInterface ( ) const

inlineoverridevirtual

Implements IALSCharacterInterface.

    {
        return Cast<IALSGravityMovementInterface>(MyCharacterMovementComponent);
    }

◆ GetALSMovementComponent()

FORCEINLINE class UALSCharacterMovementComponent * AALSBaseCharacter::GetALSMovementComponent ( ) const

inline

    {
        return MyCharacterMovementComponent;
    }

◆ GetAnimCurveValue()

float AALSBaseCharacter::GetAnimCurveValue ( FName CurveName ) const

Utility

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::GetAnimCurveValue);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    if(GetMesh() != nullptr && GetMesh()->GetAnimInstance())
    {
        return GetMesh()->GetAnimInstance()->GetCurveValue(CurveName);
    }
 
    return 0.0f;
}

◆ GetCameraParameters()

void AALSBaseCharacter::GetCameraParameters	(	float &	TPFOVOut,
		float &	FPFOVOut,
		bool &	bRightShoulderOut ) const

{
    TPFOVOut = ThirdPersonFOV;
    FPFOVOut = FirstPersonFOV;
    bRightShoulderOut = bRightShoulder;
}

◆ GetCanAimDownSights()

bool AALSBaseCharacter::GetCanAimDownSights ( ) const

virtual

Reimplemented in ACustomPlayerCharacter.

{
    if(RotationMode != EALSRotationMode::Aiming)
    {
        return false;
    }
    return true;
}

◆ GetCurrentOverlayState()

virtual EALSOverlayState AALSBaseCharacter::GetCurrentOverlayState ( ) const

inlineoverridevirtual

Implements IALSCharacterInterface.

51{return OverlayState;};

◆ GetDesiredGait()

EALSGait AALSBaseCharacter::GetDesiredGait ( ) const

inline

129{ return DesiredGait; }

◆ GetDesiredRotationMode()

EALSRotationMode AALSBaseCharacter::GetDesiredRotationMode ( ) const

inline

238{ return DesiredRotationMode; }

◆ GetDesiredStance()

EALSStance AALSBaseCharacter::GetDesiredStance ( ) const

inline

223{ return DesiredStance; }

◆ GetFirstPersonCameraTarget()

FVector AALSBaseCharacter::GetFirstPersonCameraTarget ( )

virtual

Reimplemented in AALSCharacter.

{
    if(GetMesh() == nullptr){return FVector::ZeroVector;}
    return GetMesh()->GetSocketLocation(NAME_FP_Camera);
}

◆ GetGait()

EALSGait AALSBaseCharacter::GetGait ( ) const

inline

126{ return Gait; }

AALSBaseCharacter::Gait

EALSGait Gait

Definition ALSBaseCharacter.h:610

◆ GetGetUpAnimation()

UAnimMontage * AALSBaseCharacter::GetGetUpAnimation ( bool bRagdollFaceUpState )

Ragdoll System Implement on BP to get required get up animation according to character's state

◆ GetGroundedEntryState()

EALSGroundedEntryState AALSBaseCharacter::GetGroundedEntryState ( ) const

inline

162{ return GroundedEntryState; }

AALSBaseCharacter::GroundedEntryState

EALSGroundedEntryState GroundedEntryState

Definition ALSBaseCharacter.h:595

◆ GetIsFlying()

bool AALSBaseCharacter::GetIsFlying ( ) const

inline

347{ return bIsFlying; }

AALSBaseCharacter::bIsFlying

bool bIsFlying

Definition ALSBaseCharacter.h:554

◆ GetIsMantling()

bool AALSBaseCharacter::GetIsMantling ( ) const

overridevirtual

Implements IALSCharacterInterface.

{
    return GetMovementState() == EALSMovementState::Mantling;
}

◆ GetLeftHandGoal()

FVector AALSBaseCharacter::GetLeftHandGoal ( ) const

overridevirtual

Implements IALSCharacterInterface.

{
    if(GetMesh() != nullptr)
    {
        return GetMesh()->GetSocketLocation("Hand_L");
    }
    return FVector::ZeroVector;
}

◆ GetLifetimeReplicatedProps()

void AALSBaseCharacter::GetLifetimeReplicatedProps ( TArray< FLifetimeProperty > & OutLifetimeProps ) const

overridevirtual

{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(AALSBaseCharacter, TargetRagdollLocation);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, ReplicatedCurrentAcceleration, COND_SkipOwner);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, ReplicatedControlRotation, COND_SkipOwner);
 
    DOREPLIFETIME(AALSBaseCharacter, DesiredGait);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, DesiredStance, COND_SkipOwner);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, DesiredRotationMode, COND_SkipOwner);
 
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, RotationMode, COND_SkipOwner);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, OverlayState, COND_SkipOwner);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, ViewMode, COND_SkipOwner);
    DOREPLIFETIME_CONDITION(AALSBaseCharacter, VisibleMesh, COND_SkipOwner);
}

◆ GetMovementAction()

EALSMovementAction AALSBaseCharacter::GetMovementAction ( ) const

inline

108{ return MovementAction; }

◆ GetMovementInput()

FVector AALSBaseCharacter::GetMovementInput ( ) const

{
    return ReplicatedCurrentAcceleration;
}

◆ GetMovementInputAmount()

float AALSBaseCharacter::GetMovementInputAmount ( ) const

inline

354{ return MovementInputAmount; }

◆ GetMovementState()

EALSMovementState AALSBaseCharacter::GetMovementState ( ) const

inline

99{ return MovementState; }

◆ GetOverlayOverrideState()

int32 AALSBaseCharacter::GetOverlayOverrideState ( ) const

inline

120{ return OverlayOverrideState; }

AALSBaseCharacter::OverlayOverrideState

int32 OverlayOverrideState

Definition ALSBaseCharacter.h:619

◆ GetOverlayState()

EALSOverlayState AALSBaseCharacter::GetOverlayState ( ) const

inline

159{ return OverlayState; }

◆ GetPrevMovementState()

EALSMovementState AALSBaseCharacter::GetPrevMovementState ( ) const

inline

102{ return PrevMovementState; }

AALSBaseCharacter::PrevMovementState

EALSMovementState PrevMovementState

Definition ALSBaseCharacter.h:601

◆ GetRightHandGoal()

FVector AALSBaseCharacter::GetRightHandGoal ( ) const

overridevirtual

Implements IALSCharacterInterface.

{
    if(GetMesh() != nullptr)
    {
        return GetMesh()->GetSocketLocation("Hand_R");
    }
    return FVector::ZeroVector;
}

◆ GetRollAnimation()

UAnimMontage * AALSBaseCharacter::GetRollAnimation ( )

Implement on BP to get required roll animation according to character's state

◆ GetRotationMode()

EALSRotationMode AALSBaseCharacter::GetRotationMode ( ) const

inline

138{ return RotationMode; }

◆ GetSpeed()

float AALSBaseCharacter::GetSpeed ( ) const

inline

357{ return Speed; }

◆ GetStance()

EALSStance AALSBaseCharacter::GetStance ( ) const

inline

114{ return Stance; }

◆ GetTargetMovementSettings()

FALSMovementSettings AALSBaseCharacter::GetTargetMovementSettings ( ) const

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::GetTargetMovementSettings);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    if (RotationMode == EALSRotationMode::VelocityDirection)
    {
        if (Stance == EALSStance::Standing)
        {
            return MovementData.VelocityDirection.Standing;
        }
        if (Stance == EALSStance::Crouching)
        {
            return MovementData.VelocityDirection.Crouching;
        }
    }
    else if (RotationMode == EALSRotationMode::LookingDirection)
    {
        if (Stance == EALSStance::Standing)
        {
            return MovementData.LookingDirection.Standing;
        }
        if (Stance == EALSStance::Crouching)
        {
            return MovementData.LookingDirection.Crouching;
        }
    }
    else if (RotationMode == EALSRotationMode::Aiming)
    {
        if (Stance == EALSStance::Standing)
        {
            return MovementData.Aiming.Standing;
        }
        if (Stance == EALSStance::Crouching)
        {
            return MovementData.Aiming.Crouching;
        }
    }
 
    // Default to velocity dir standing
    return MovementData.VelocityDirection.Standing;
}

◆ GetThirdPersonPivotTarget()

FTransform AALSBaseCharacter::GetThirdPersonPivotTarget ( )

virtual

Reimplemented in AALSCharacter.

{
    return GetActorTransform();
}

◆ GetThirdPersonTraceParams()

ECollisionChannel AALSBaseCharacter::GetThirdPersonTraceParams	(	FVector &	TraceOrigin,
		float &	TraceRadius )

virtual

Reimplemented in AALSCharacter.

{
    TraceOrigin = GetActorLocation();
    TraceRadius = 10.0f;
    return ECC_Visibility;
}

◆ GetViewMode()

EALSViewMode AALSBaseCharacter::GetViewMode ( ) const

inline

147{ return ViewMode; }

◆ HandleNonMovingRotation()

void AALSBaseCharacter::HandleNonMovingRotation ( float DeltaTime )

protected

{
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS HandleNonMovingRotation"), STAT_ALS_HandleNonMovingRotation, STATGROUP_ALS)
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Handle Aiming or First-Person View rotation limits
    if ((ViewMode == EALSViewMode::ThirdPerson && RotationMode == EALSRotationMode::Aiming) ||
        ViewMode == EALSViewMode::FirstPerson)
    {
        LimitRotation(-100.0f, 100.0f, 20.0f, DeltaTime);
    }
 
    const float RotAmountCurve = GetAnimCurveValue(NAME_RotationAmount);
    if (FMath::Abs(RotAmountCurve) > 0.001f)
    {
        const float RotationDelta = RotAmountCurve * (DeltaTime / (1.0f / 30.0f));
 
        if (GetLocalRole() == ROLE_AutonomousProxy)
        {
            TargetRotation.Yaw = UKismetMathLibrary::NormalizeAxis(TargetRotation.Yaw + RotationDelta);
            SetActorRotation(TargetRotation);
        }
        else
        {
            AddActorWorldRotation({0, RotationDelta, 0});
        }
        TargetRotation = GetActorRotation();  // Cache the updated rotation
    }
}

◆ HasMovementInput()

bool AALSBaseCharacter::HasMovementInput ( ) const

inline

Movement System

254{ return bHasMovementInput; }

◆ IsAimingDownSights()

bool AALSBaseCharacter::IsAimingDownSights ( ) const

inline

309{ return bAimDownSights; }

AALSBaseCharacter::bAimDownSights

bool bAimDownSights

Definition ALSBaseCharacter.h:537

◆ IsMoving()

bool AALSBaseCharacter::IsMoving ( ) const

inline

344{ return bIsMoving; }

AALSBaseCharacter::bIsMoving

bool bIsMoving

Definition ALSBaseCharacter.h:551

◆ IsRightShoulder()

bool AALSBaseCharacter::IsRightShoulder ( ) const

inline

Camera System

303{ return bRightShoulder; }

◆ JumpAction()

void AALSBaseCharacter::JumpAction ( bool bValue )

virtual

Reimplemented in ACustomCharacterBase.

{
    if (bValue)
    {
        // Jump Action: Press "Jump Action" to end the ragdoll if ragdolling, stand up if crouching, or jump if standing.
        if (JumpPressedDelegate.IsBound())
        {
            JumpPressedDelegate.Broadcast();
        }
 
        if (MovementAction == EALSMovementAction::None)
        {
            if (MovementState == EALSMovementState::Grounded)
            {
                if (Stance == EALSStance::Standing)
                {
                    Jump();
                }
                else if (Stance == EALSStance::Crouching)
                {
                    UnCrouch();
                }
            }
            else if (MovementState == EALSMovementState::Ragdoll)
            {
                ReplicatedRagdollEnd();
            }
        }
    }
    else
    {
        StopJumping();
    }
}

◆ Landed()

void AALSBaseCharacter::Landed ( const FHitResult & Hit )

overrideprotectedvirtual

Reimplemented in ACustomCharacterBase.

{
    Super::Landed(Hit);
 
    if (IsLocallyControlled())
    {
        EventOnLanded();
    }
    if (HasAuthority())
    {
        Multicast_OnLanded();
    }
}

◆ LimitRotation()

void AALSBaseCharacter::LimitRotation	(	float	AimYawMin,
		float	AimYawMax,
		float	InterpSpeed,
		float	DeltaTime )

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Prevent the character from rotating past a certain angle.
    FRotator Delta = AimingRotation - GetActorRotation();
    Delta.Normalize();
    const float RangeVal = Delta.Yaw;
 
    if (RangeVal < AimYawMin || RangeVal > AimYawMax)
    {
        const float ControlRotYaw = AimingRotation.Yaw;
        const float TargetYaw = ControlRotYaw + (RangeVal > 0.0f ? AimYawMin : AimYawMax);
        SmoothCharacterRotation({0.0f, TargetYaw, 0.0f}, 0.0f, InterpSpeed, DeltaTime);
    }
}

◆ LookingDirectionAction()

void AALSBaseCharacter::LookingDirectionAction ( )

◆ Multicast_OnJumped()

void AALSBaseCharacter::Multicast_OnJumped ( )

◆ Multicast_OnLanded()

void AALSBaseCharacter::Multicast_OnLanded ( )

◆ Multicast_PlayMontage()

void AALSBaseCharacter::Multicast_PlayMontage	(	UAnimMontage *	Montage,
		float	PlayRate )

◆ Multicast_RagdollEnd()

void AALSBaseCharacter::Multicast_RagdollEnd ( FVector CharacterLocation )

◆ Multicast_RagdollStart()

void AALSBaseCharacter::Multicast_RagdollStart ( )

◆ Multicast_StopMontage()

void AALSBaseCharacter::Multicast_StopMontage	(	const float	InBlendOutTime,
		const UAnimMontage *	Montage )

◆ OnBreakfall()

void AALSBaseCharacter::OnBreakfall ( )

BP implementable function that called when Breakfall starts

◆ OnBreakfall_Implementation()

void AALSBaseCharacter::OnBreakfall_Implementation ( )

virtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnBreakfall_Implementation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    Replicated_PlayMontage(GetRollAnimation(), 1.35);
}

◆ OnEndCrouch()

void AALSBaseCharacter::OnEndCrouch	(	float	HalfHeightAdjust,
		float	ScaledHalfHeightAdjust )

overrideprotectedvirtual

{
    Super::OnEndCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
 
    SetStance(EALSStance::Standing);
}

◆ OnGaitChanged()

void AALSBaseCharacter::OnGaitChanged ( EALSGait PreviousGait )

protectedvirtual

{
    if (CameraBehavior)
    {
        CameraBehavior->Gait = Gait;
    }
}

◆ OnJumped_Implementation()

void AALSBaseCharacter::OnJumped_Implementation ( )

overrideprotectedvirtual

Reimplemented in ACustomCharacterBase.

{
    Super::OnJumped_Implementation();
    if (IsLocallyControlled())
    {
        EventOnJumped();
    }
    if (HasAuthority())
    {
        Multicast_OnJumped();
    }
}

◆ OnLandFrictionReset()

void AALSBaseCharacter::OnLandFrictionReset ( )

protected

{
    // Reset the braking friction
    GetCharacterMovement()->BrakingFrictionFactor = 0.0f;
}

◆ OnMovementActionChanged()

void AALSBaseCharacter::OnMovementActionChanged ( EALSMovementAction PreviousAction )

protectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnMovementActionChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Make the character crouch if performing a roll.
    if (MovementAction == EALSMovementAction::Rolling)
    {
        Crouch();
    }
 
    if (PreviousAction == EALSMovementAction::Rolling)
    {
        if (DesiredStance == EALSStance::Standing)
        {
            UnCrouch();
        }
        else if (DesiredStance == EALSStance::Crouching)
        {
            Crouch();
        }
    }
 
    if (CameraBehavior)
    {
        CameraBehavior->MovementAction = MovementAction;
    }
}

◆ OnMovementModeChanged()

void AALSBaseCharacter::OnMovementModeChanged	(	EMovementMode	PrevMovementMode,
		uint8	PreviousCustomMode = 0 )

overrideprotectedvirtual

State Changes

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnMovementModeChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    Super::OnMovementModeChanged(PrevMovementMode, PreviousCustomMode);
 
    // Use the Character Movement Mode changes to set the Movement States to the right values. This allows you to have
    // a custom set of movement states but still use the functionality of the default character movement component.
 
    if (GetCharacterMovement()->MovementMode == MOVE_Walking ||
        GetCharacterMovement()->MovementMode == MOVE_NavWalking)
    {
        SetMovementState(EALSMovementState::Grounded);
    }
    else if (GetCharacterMovement()->MovementMode == MOVE_Falling)
    {
        SetMovementState(EALSMovementState::InAir);
    }
}

◆ OnMovementStateChanged()

void AALSBaseCharacter::OnMovementStateChanged ( EALSMovementState PreviousState )

protectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnMovementStateChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (MovementState == EALSMovementState::InAir)
    {
        if (MovementAction == EALSMovementAction::None)
        {
            // If the character enters the air, set the In Air Rotation and uncrouch if crouched.
            InAirRotation = GetActorRotation();
            if (Stance == EALSStance::Crouching)
            {
                UnCrouch();
            }
        }
        else if (MovementAction == EALSMovementAction::Rolling)
        {
            // If the character is currently rolling, enable the ragdoll.
            ReplicatedRagdollStart();
        }
    }
 
    if (CameraBehavior)
    {
        CameraBehavior->MovementState = MovementState;
    }
}

◆ OnOverlayStateChanged()

void AALSBaseCharacter::OnOverlayStateChanged ( EALSOverlayState PreviousState )

protectedvirtual

Reimplemented in AALSCharacter.

1261{

1262}

◆ OnRep_OverlayState()

void AALSBaseCharacter::OnRep_OverlayState ( EALSOverlayState PrevOverlayState )

protected

{
    OnOverlayStateChanged(PrevOverlayState);
}

◆ OnRep_RotationMode()

void AALSBaseCharacter::OnRep_RotationMode ( EALSRotationMode PrevRotMode )

protected

Replication

{
    OnRotationModeChanged(PrevRotMode);
}

◆ OnRep_ViewMode()

void AALSBaseCharacter::OnRep_ViewMode ( EALSViewMode PrevViewMode )

protected

{
    OnViewModeChanged(PrevViewMode);
}

◆ OnRep_VisibleMesh()

void AALSBaseCharacter::OnRep_VisibleMesh ( const USkeletalMesh * PreviousSkeletalMesh )

protected

{
    OnVisibleMeshChanged(PreviousSkeletalMesh);
}

◆ OnRotationModeChanged()

void AALSBaseCharacter::OnRotationModeChanged ( EALSRotationMode PreviousRotationMode )

protectedvirtual

Reimplemented in ACustomPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnRotationModeChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (RotationMode == EALSRotationMode::VelocityDirection && ViewMode == EALSViewMode::FirstPerson)
    {
        // If the new rotation mode is Velocity Direction and the character is in First Person,
        // set the viewmode to Third Person.
        SetViewMode(EALSViewMode::ThirdPerson);
    }
 
    if (CameraBehavior)
    {
        CameraBehavior->SetRotationMode(RotationMode);
    }
 
    MyCharacterMovementComponent->SetMovementSettings(GetTargetMovementSettings());
}

◆ OnStanceChanged()

void AALSBaseCharacter::OnStanceChanged ( EALSStance PreviousStance )

protectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnStanceChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (CameraBehavior)
    {
        CameraBehavior->Stance = Stance;
    }
 
    MyCharacterMovementComponent->SetMovementSettings(GetTargetMovementSettings());
}

◆ OnStartCrouch()

void AALSBaseCharacter::OnStartCrouch	(	float	HalfHeightAdjust,
		float	ScaledHalfHeightAdjust )

overrideprotectedvirtual

{
    Super::OnStartCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
 
    SetStance(EALSStance::Crouching);
}

◆ OnViewModeChanged()

void AALSBaseCharacter::OnViewModeChanged ( EALSViewMode PreviousViewMode )

protectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::OnViewModeChanged);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (ViewMode == EALSViewMode::ThirdPerson)
    {
        if (RotationMode == EALSRotationMode::VelocityDirection || RotationMode == EALSRotationMode::LookingDirection)
        {
            // If Third Person, set the rotation mode back to the desired mode.
            SetRotationMode(DesiredRotationMode);
        }
    }
    else if (ViewMode == EALSViewMode::FirstPerson && RotationMode == EALSRotationMode::VelocityDirection)
    {
        // If First Person, set the rotation mode to looking direction if currently in the velocity direction mode.
        SetRotationMode(EALSRotationMode::LookingDirection);
    }
 
    if (CameraBehavior)
    {
        CameraBehavior->ViewMode = ViewMode;
    }
}

◆ OnVisibleMeshChanged()

void AALSBaseCharacter::OnVisibleMeshChanged ( const USkeletalMesh * PreviousSkeletalMesh )

protectedvirtual

{
    // Update the Skeletal Mesh before we update materials and anim bp variables
    GetMesh()->SetSkeletalMesh(VisibleMesh);
 
    // Reset materials to their new mesh defaults
    if (GetMesh() != nullptr)
    {
        for (int32 MaterialIndex = 0; MaterialIndex < GetMesh()->GetNumMaterials(); ++MaterialIndex)
        {
            GetMesh()->SetMaterial(MaterialIndex, nullptr);
        }
    }
 
    // Force set variables. This ensures anim instance & character stay synchronized on mesh changes
    ForceUpdateCharacterState();
}

◆ PlayReplicatedMontage()

float AALSBaseCharacter::PlayReplicatedMontage	(	UAnimMontage *	MontageToPlay,
		const float	InPlayRate,
		const EMontagePlayReturnType	ReturnValueType,
		const float	InTimeToStartMontageAt,
		const bool	bStopAllMontages )

overridevirtual

Reimplemented from ACharacterBase.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::PlayReplicatedMontage);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    Super::PlayReplicatedMontage(MontageToPlay, InPlayRate, ReturnValueType, InTimeToStartMontageAt, bStopAllMontages);
    float AnimDuration = 0.0f;
    if(GetMesh() != nullptr && GetMesh()->GetAnimInstance() != nullptr)
    {
        AnimDuration = GetMesh()->GetAnimInstance()->Montage_Play(MontageToPlay, InPlayRate, ReturnValueType, InTimeToStartMontageAt, bStopAllMontages);
    }
    Server_PlayMontage(MontageToPlay, InPlayRate);
    return AnimDuration;
}

◆ PostInitializeComponents()

void AALSBaseCharacter::PostInitializeComponents ( )

overridevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::PostInitializeComponents);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    Super::PostInitializeComponents();
    MyCharacterMovementComponent = Cast<UALSCharacterMovementComponent>(Super::GetMovementComponent());
}

◆ Ragdoll()

void AALSBaseCharacter::Ragdoll ( )

overridevirtual

Reimplemented from ACharacterBase.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    Super::Ragdoll();
    RagdollStart();
}

◆ RagdollAction()

void AALSBaseCharacter::RagdollAction ( )

◆ RagdollEnd()

void AALSBaseCharacter::RagdollEnd ( )

virtual

Re-enable Replicate Movement and if the host is a dedicated server set mesh visibility based anim tick option back to default

Reimplemented in AALSCharacter, ACustomAICharacter, and ACustomCharacterBase.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::RagdollEnd);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
        SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    if (UKismetSystemLibrary::IsDedicatedServer(GetWorld()))
    {
        GetMesh()->VisibilityBasedAnimTickOption = DefVisBasedTickOp;
    }
 
    GetMesh()->bEnableUpdateRateOptimizations = bPreRagdollURO;
 
    // Revert back to default settings
    MyCharacterMovementComponent->bIgnoreClientMovementErrorChecksAndCorrection = 0;
    GetMesh()->bOnlyAllowAutonomousTickPose = false;
    SetReplicateMovement(true);
 
    // Step 1: Save a snapshot of the current Ragdoll Pose for use in AnimGraph to blend out of the ragdoll
    if (GetMesh()->GetAnimInstance())
    {
        GetMesh()->GetAnimInstance()->SavePoseSnapshot(NAME_RagdollPose);
    }
 
    // Step 2: If the ragdoll is on the ground, set the movement mode to walking and play a Get Up animation.
    // If not, set the movement mode to falling and update the character movement velocity to match the last ragdoll velocity.
    if (bRagdollOnGround)
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Walking);
        if (GetMesh()->GetAnimInstance())
        {
            GetMesh()->GetAnimInstance()->Montage_Play(GetGetUpAnimation(bRagdollFaceUp), 1.0f, EMontagePlayReturnType::MontageLength, 0.0f, true);
        }
    }
    else
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Falling);
        GetCharacterMovement()->Velocity = LastRagdollVelocity;
    }
 
    // Step 3: Re-Enable capsule collision, and disable physics simulation on the mesh.
    GetCapsuleComponent()->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    GetMesh()->SetCollisionObjectType(ECC_Pawn);
    GetMesh()->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    GetMesh()->SetAllBodiesSimulatePhysics(false);
 
    if (RagdollStateChangedDelegate.IsBound())
    {
        RagdollStateChangedDelegate.Broadcast(false);
    }
}

◆ RagdollStart()

void AALSBaseCharacter::RagdollStart ( )

virtual

When Networked, disables replicate movement reset TargetRagdollLocation and ServerRagdollPull variable and if the host is a dedicated server, change character mesh optimisation option to avoid z-location bug

Reimplemented in AALSCharacter, ACustomAICharacter, and ACustomCharacterBase.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::RagdollStart);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    if(GetWorld() == nullptr){return;} //- Added world Check..
    if (RagdollStateChangedDelegate.IsBound())
    {
        RagdollStateChangedDelegate.Broadcast(true);
    }
 
 
    MyCharacterMovementComponent->bIgnoreClientMovementErrorChecksAndCorrection = 1;
    if (UKismetSystemLibrary::IsDedicatedServer(GetWorld()))
    {
        DefVisBasedTickOp = GetMesh()->VisibilityBasedAnimTickOption;
        GetMesh()->VisibilityBasedAnimTickOption = EVisibilityBasedAnimTickOption::AlwaysTickPoseAndRefreshBones;
    }
    TargetRagdollLocation = GetMesh()->GetSocketLocation(NAME_Pelvis);
    ServerRagdollPull = 0;
 
    // Disable URO
    bPreRagdollURO = GetMesh()->bEnableUpdateRateOptimizations;
    GetMesh()->bEnableUpdateRateOptimizations = false;
 
    // Step 1: Clear the Character Movement Mode and set the Movement State to Ragdoll
    GetCharacterMovement()->SetMovementMode(MOVE_None);
    SetMovementState(EALSMovementState::Ragdoll);
 
    // Step 2: Disable capsule collision and enable mesh physics simulation starting from the pelvis.
    GetCapsuleComponent()->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    GetMesh()->SetCollisionObjectType(ECC_PhysicsBody);
    GetMesh()->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    GetMesh()->SetAllBodiesBelowSimulatePhysics(NAME_Pelvis, true, true);
 
    // Step 3: Stop any active montages.
    if (GetMesh()->GetAnimInstance())
    {
        GetMesh()->GetAnimInstance()->Montage_Stop(0.2f);
    }
 
    // Fixes character mesh is showing default A pose for a split-second just before ragdoll ends in listen server games
    GetMesh()->bOnlyAllowAutonomousTickPose = true;
 
    SetReplicateMovement(false);
}

◆ RagdollUpdate()

void AALSBaseCharacter::RagdollUpdate ( float DeltaTime )

protected

Ragdoll System

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::RagdollUpdate);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_RagdollUpdate);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    GetMesh()->bOnlyAllowAutonomousTickPose = false;
 
    // Set the Last Ragdoll Velocity.
    const FVector NewRagdollVel = GetMesh()->GetPhysicsLinearVelocity(NAME_root);
    LastRagdollVelocity = (NewRagdollVel != FVector::ZeroVector || IsLocallyControlled())
                              ? NewRagdollVel
                              : LastRagdollVelocity / 2;
 
    // Use the Ragdoll Velocity to scale the ragdoll's joint strength for physical animation.
    const float SpringValue = FMath::GetMappedRangeValueClamped<float, float>({0.0f, 1000.0f}, {0.0f, 25000.0f},
                                                                LastRagdollVelocity.Size());
    GetMesh()->SetAllMotorsAngularDriveParams(SpringValue, 0.0f, 0.0f, false);
 
    //@ TODO Needs to be properly Tested, currently don't work as required  //
    // GetMesh()->SetEnableGravity(false);  // Disable default gravity
    // // Get the current gravity direction from the movement component (assuming this is set based on the room's gravity).
    // const FVector GravityDirection = GetALSMovementComponent()->GetGravityDirection(); // Assuming you have a method for this
    // const FVector GravityForce = GravityDirection * (GetCharacterMovement()->GravityScale * GravityMultiplier); // 980.0f is Earth's gravity
    // UE_LOG(LogGravity, Warning, TEXT("Gravity Direction: %s  Force: %s "), *GravityDirection.ToString(), *GravityForce.ToString());
    // GetMesh()->AddForce(GravityForce * GetMesh()->GetMass(), NAME_Pelvis, true);
    
 
    // // Disable Gravity if falling faster than -4000 to prevent continual acceleration.
    // // This also prevents the ragdoll from going through the floor.
    const bool bEnableGrav = LastRagdollVelocity.Z > -4000.0f;
    GetMesh()->SetEnableGravity(bEnableGrav);
 
    // Update the Actor location to follow the ragdoll.
    SetActorLocationDuringRagdoll(DeltaTime);
}

◆ Replicated_PlayMontage()

void AALSBaseCharacter::Replicated_PlayMontage	(	UAnimMontage *	Montage,
		float	PlayRate )

BP implementable function that called when A Montage starts, e.g. during rolling

◆ Replicated_PlayMontage_Implementation()

void AALSBaseCharacter::Replicated_PlayMontage_Implementation	(	UAnimMontage *	Montage,
		float	PlayRate )

virtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::Replicated_PlayMontage_Implementation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    // Roll: Simply play a Root Motion Montage.
    if (GetMesh()->GetAnimInstance())
    {
        GetMesh()->GetAnimInstance()->Montage_Play(Montage, PlayRate);
    }
 
    Server_PlayMontage(Montage, PlayRate);
}

◆ ReplicatedRagdollEnd()

void AALSBaseCharacter::ReplicatedRagdollEnd ( )

{
    if (HasAuthority())
    {
        Multicast_RagdollEnd(GetActorLocation());
    }
    else
    {
        Server_RagdollEnd(GetActorLocation());
    }
}

◆ ReplicatedRagdollStart()

void AALSBaseCharacter::ReplicatedRagdollStart ( )

Ragdolling

{
    if (HasAuthority())
    {
        Multicast_RagdollStart();
    }
    else
    {
        Server_RagdollStart();
    }
}

◆ RightMovementAction()

void AALSBaseCharacter::RightMovementAction ( float Value )

virtual

Reimplemented in ACustomCharacterBase.

{
    if (MovementState == EALSMovementState::Grounded || MovementState == EALSMovementState::InAir)
    {
        // Default camera relative movement behavior
        const FRotator DirRotator(0.0f, AimingRotation.Yaw, 0.0f);
        AddMovementInput(UKismetMathLibrary::GetRightVector(DirRotator), Value);
    }
}

◆ Server_PlayMontage()

void AALSBaseCharacter::Server_PlayMontage	(	UAnimMontage *	Montage,
		float	PlayRate )

Rolling Montage Play Replication

◆ Server_RagdollEnd()

void AALSBaseCharacter::Server_RagdollEnd ( FVector CharacterLocation )

◆ Server_RagdollStart()

void AALSBaseCharacter::Server_RagdollStart ( )

◆ Server_SetDesiredGait()

void AALSBaseCharacter::Server_SetDesiredGait ( EALSGait NewGait )

◆ Server_SetDesiredRotationMode()

void AALSBaseCharacter::Server_SetDesiredRotationMode ( EALSRotationMode NewRotMode )

◆ Server_SetDesiredStance()

void AALSBaseCharacter::Server_SetDesiredStance ( EALSStance NewStance )

◆ Server_SetMeshLocationDuringRagdoll()

void AALSBaseCharacter::Server_SetMeshLocationDuringRagdoll ( FVector MeshLocation )

◆ Server_SetOverlayState()

void AALSBaseCharacter::Server_SetOverlayState	(	EALSOverlayState	NewState,
		bool	bForce )

◆ Server_SetRotationMode()

void AALSBaseCharacter::Server_SetRotationMode	(	EALSRotationMode	NewRotationMode,
		bool	bForce )

◆ Server_SetViewMode()

void AALSBaseCharacter::Server_SetViewMode	(	EALSViewMode	NewViewMode,
		bool	bForce )

◆ Server_SetVisibleMesh()

void AALSBaseCharacter::Server_SetVisibleMesh ( USkeletalMesh * NewSkeletalMesh )

◆ Server_StopMontage()

void AALSBaseCharacter::Server_StopMontage	(	const float	InBlendOutTime,
		const UAnimMontage *	Montage )

◆ SetActorLocationAndTargetRotation()

void AALSBaseCharacter::SetActorLocationAndTargetRotation	(	FVector	NewLocation,
		FRotator	NewRotation )

Rotation System

{
    SetActorLocationAndRotation(NewLocation, NewRotation);
    TargetRotation = NewRotation;
}

◆ SetActorLocationDuringRagdoll()

void AALSBaseCharacter::SetActorLocationDuringRagdoll ( float DeltaTime )

protected

Check if Socket exists, if not use other case

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetActorLocationDuringRagdoll);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (IsLocallyControlled())
    {
        // Set the pelvis as the target location.
        TargetRagdollLocation = GetMesh()->GetSocketLocation(NAME_Pelvis);
        if (!HasAuthority())
        {
            Server_SetMeshLocationDuringRagdoll(TargetRagdollLocation);
        }
    }
 
    // Determine whether the ragdoll is facing up or down and set the target rotation accordingly.
    const FRotator PelvisRot = GetMesh()->GetSocketRotation(NAME_Pelvis);
 
    if (bReversedPelvis) {
        bRagdollFaceUp = PelvisRot.Roll > 0.0f;
    } else
    {
        bRagdollFaceUp = PelvisRot.Roll < 0.0f;
    }
 
 
    const FRotator TargetRagdollRotation(0.0f, bRagdollFaceUp ? PelvisRot.Yaw - 180.0f : PelvisRot.Yaw, 0.0f);
 
    // Trace downward from the target location to offset the target location,
    // preventing the lower half of the capsule from going through the floor when the ragdoll is laying on the ground.
    const FVector TraceVect(TargetRagdollLocation.X, TargetRagdollLocation.Y,
                            TargetRagdollLocation.Z - GetCapsuleComponent()->GetScaledCapsuleHalfHeight());
 
    UWorld* World = GetWorld();
    check(World);
 
    FCollisionQueryParams Params;
    Params.AddIgnoredActor(this);
 
    FHitResult HitResult;
    const bool bHit = World->LineTraceSingleByChannel(HitResult, TargetRagdollLocation, TraceVect,
                                                      ECC_Visibility, Params);
 
    if (ALSDebugComponent && ALSDebugComponent->GetShowTraces())
    {
        UALSDebugComponent::DrawDebugLineTraceSingle(World,
                                                     TargetRagdollLocation,
                                                     TraceVect,
                                                     EDrawDebugTrace::Type::ForOneFrame,
                                                     bHit,
                                                     HitResult,
                                                     FLinearColor::Red,
                                                     FLinearColor::Green,
                                                     1.0f);
    }
 
    bRagdollOnGround = HitResult.IsValidBlockingHit();
    FVector NewRagdollLoc = TargetRagdollLocation;
 
    if (bRagdollOnGround)
    {
        const float ImpactDistZ = FMath::Abs(HitResult.ImpactPoint.Z - HitResult.TraceStart.Z);
        NewRagdollLoc.Z += GetCapsuleComponent()->GetScaledCapsuleHalfHeight() - ImpactDistZ + 2.0f;
    }
    if (!IsLocallyControlled())
    {
        ServerRagdollPull = FMath::FInterpTo(ServerRagdollPull, 750.0f, DeltaTime, 0.6f);
        float RagdollSpeed = FVector(LastRagdollVelocity.X, LastRagdollVelocity.Y, 0).Size();
 
        FName RagdollPelvisSocket = GetMesh()->DoesSocketExist(NAME_pelvis) ? NAME_pelvis : NAME_Pelvis;
        //FName RagdollSocketPullName = RagdollSpeed > 300 ? NAME_spine_03 : NAME_pelvis;
        FName RagdollSocketPullName = RagdollSpeed > 300 ? NAME_spine_03 : RagdollPelvisSocket;
        GetMesh()->AddForce(
            (TargetRagdollLocation - GetMesh()->GetSocketLocation(RagdollSocketPullName)) * ServerRagdollPull,
            RagdollSocketPullName, true);
    }
    SetActorLocationAndTargetRotation(bRagdollOnGround ? NewRagdollLoc : TargetRagdollLocation, TargetRagdollRotation);
}

◆ SetAimDownSights()

void AALSBaseCharacter::SetAimDownSights ( const bool bNewAimDownSights )

{
    if(GetCanAimDownSights() && bNewAimDownSights)
    {
        bAimDownSights = bNewAimDownSights;
        if(CameraBehavior != nullptr)
        {
            CameraBehavior->bAimDownSights = bAimDownSights;
        }
    }
    else
    {
        bAimDownSights = false;
        if(CameraBehavior != nullptr)
        {
            CameraBehavior->bAimDownSights = false;
        }
 
    }
}

◆ SetCameraBehavior()

void AALSBaseCharacter::SetCameraBehavior ( UALSPlayerCameraBehavior * CamBeh )

inline

336{ CameraBehavior = CamBeh; }

◆ SetDesiredGait()

void AALSBaseCharacter::SetDesiredGait ( EALSGait NewGait )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetDesiredGait);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    DesiredGait = NewGait;
    if (GetLocalRole() == ROLE_AutonomousProxy)
    {
        Server_SetDesiredGait(NewGait);
    }
}

◆ SetDesiredRotationMode()

void AALSBaseCharacter::SetDesiredRotationMode ( EALSRotationMode NewRotMode )

virtual

Reimplemented in AMultiplayerPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetDesiredRotationMode);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    DesiredRotationMode = NewRotMode;
    if (GetLocalRole() == ROLE_AutonomousProxy)
    {
        Server_SetDesiredRotationMode(NewRotMode);
    }
    if(AnimInstanceInterface != nullptr)
    {
        AnimInstanceInterface->SetRotationMode(DesiredRotationMode);
    }
}

◆ SetDesiredStance()

void AALSBaseCharacter::SetDesiredStance ( EALSStance NewStance )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetDesiredStance);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    DesiredStance = NewStance;
    if (GetLocalRole() == ROLE_AutonomousProxy)
    {
        Server_SetDesiredStance(NewStance);
    }
    if(AnimInstanceInterface != nullptr)
    {
        AnimInstanceInterface->SetStance(DesiredStance);
    }
}

◆ SetEssentialValues()

void AALSBaseCharacter::SetEssentialValues ( float DeltaTime )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetEssentialValues);
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ALS SetEssentialValues"), STAT_ALS_SetEssentialValues, STATGROUP_ALS)
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    if (GetLocalRole() != ROLE_SimulatedProxy)
    {
        if(GetCharacterMovement() != nullptr)
        {
            ReplicatedCurrentAcceleration = GetCharacterMovement()->GetCurrentAcceleration();
            EasedMaxAcceleration = GetCharacterMovement()->GetMaxAcceleration();
        }
        ReplicatedControlRotation = GetControlRotation();
    }
    else
    {
        if(GetCharacterMovement() != nullptr)
        {
            EasedMaxAcceleration = GetCharacterMovement()->GetMaxAcceleration() != 0
                                       ? GetCharacterMovement()->GetMaxAcceleration()
                                       : EasedMaxAcceleration / 2;
        }
    }
 
 
 
    // Interp AimingRotation to current control rotation for smooth character rotation movement. Decrease InterpSpeed
    // for slower but smoother movement.
    AimingRotation = FMath::RInterpTo(AimingRotation, ReplicatedControlRotation, DeltaTime, 30);
 
    // These values represent how the capsule is moving as well as how it wants to move, and therefore are essential
    // for any data driven animation system. They are also used throughout the system for various functions,
    // so I found it is easiest to manage them all in one place.
 
    const FVector CurrentVel = GetVelocity();
 
    // Set the amount of Acceleration.
    const FVector NewAcceleration = (CurrentVel - PreviousVelocity) / DeltaTime;
    Acceleration = NewAcceleration.IsNearlyZero() || IsLocallyControlled() ? NewAcceleration : Acceleration / 2;
 
    // Flying 
    bIsFlying = (GetALSMovementComponent() != nullptr && MovementState == EALSMovementState::InAir && GetALSMovementComponent()->IsFlying());
 
 
    
    // Determine if the character is moving by getting it's speed. The Speed equals the length of the horizontal (x y)
    // velocity, so it does not take vertical movement into account. If the character is moving, update the last
    // velocity rotation. This value is saved because it might be useful to know the last orientation of movement
    // even after the character has stopped.
    Speed = CurrentVel.Size2D();
    if(GetIsFlying())
    {
        Speed = CurrentVel.Size();
    }
 
        
    bIsMoving = Speed > 1.0f;
    if (bIsMoving)
    {
        LastVelocityRotation = CurrentVel.ToOrientationRotator();
    }
 
 
        
    // Determine if the character has movement input by getting its movement input amount.
    // The Movement Input Amount is equal to the current acceleration divided by the max acceleration so that
    // it has a range of 0-1, 1 being the maximum possible amount of input, and 0 being none.
    // If the character has movement input, update the Last Movement Input Rotation.
    MovementInputAmount = ReplicatedCurrentAcceleration.Size() / EasedMaxAcceleration;
    bHasMovementInput = MovementInputAmount > 0.0f;
    if (bHasMovementInput)
    {
        LastMovementInputRotation = ReplicatedCurrentAcceleration.ToOrientationRotator();
    }
 
    // Set the Aim Yaw rate by comparing the current and previous Aim Yaw value, divided by Delta Seconds.
    // This represents the speed the camera is rotating left to right.
    AimYawRate = FMath::Abs((AimingRotation.Yaw - PreviousAimYaw) / DeltaTime);
 
    if(AnimInstanceInterface != nullptr)
    {
        if(bOptimizeAnimValues)
        {
            // FALSAnimValues AnimValues;
            AnimValues.ActorRotation = GetActorRotation();
            AnimValues.CharacterInfo.MovementInputAmount = MovementInputAmount;
            AnimValues.CharacterInfo.bHasMovementInput = bHasMovementInput;
            AnimValues.CharacterInfo.bIsMoving = bIsMoving;
            AnimValues.CharacterInfo.Acceleration = Acceleration;
            AnimValues.CharacterInfo.AimYawRate = AimYawRate;
            AnimValues.CharacterInfo.Speed = Speed;
            AnimValues.CharacterInfo.bIsFlying = bIsFlying;
            if(GetCharacterMovement() != nullptr)
            {
                AnimValues.CharacterInfo.Velocity = GetCharacterMovement()->Velocity;
            }
            AnimValues.CharacterInfo.MovementInput = GetMovementInput();
            AnimValues.CharacterInfo.AimingRotation = AimingRotation;
            // AnimValues.CharacterInfo.ViewMode = ViewMode;
            AnimValues.CharacterInfo.PrevMovementState = PrevMovementState;
            // AnimValues.OverlayOverrideState = OverlayOverrideState;
            // AnimValues.MovementState = MovementState;
            AnimValues.MovementAction = MovementAction;
            // AnimValues.Stance = Stance;
            // AnimValues.RotationMode = RotationMode;
            // AnimValues.Gait = Gait;
            // AnimValues.OverlayState = OverlayState;
            // AnimValues.GroundedEntryState = GroundedEntryState;
            AnimInstanceInterface->SetEssentialInfo(AnimValues);
        }
        AnimInstanceInterface->SetOptimize(bOptimizeAnimValues);
    }
}

◆ SetGait()

void AALSBaseCharacter::SetGait	(	EALSGait	NewGait,
		bool	bForce = false )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetGait);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    if (bForce || Gait != NewGait)
    {
        const EALSGait Prev = Gait;
        Gait = NewGait;
        OnGaitChanged(Prev);
        //@ TEST Performance 
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetGait(Gait);
        }
 
    }
}

◆ SetGroundedEntryState()

void AALSBaseCharacter::SetGroundedEntryState ( EALSGroundedEntryState NewState )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetGroundedEntryState);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    GroundedEntryState = NewState;
    if(AnimInstanceInterface != nullptr)
    {
        AnimInstanceInterface->SetNewGroundedEntryState(GroundedEntryState);
    }
}

◆ SetMovementAction()

void AALSBaseCharacter::SetMovementAction	(	EALSMovementAction	NewAction,
		bool	bForce = false )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetMovementAction);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    if (bForce || MovementAction != NewAction)
    {
        const EALSMovementAction Prev = MovementAction;
        MovementAction = NewAction;
        OnMovementActionChanged(Prev);
    }
}

◆ SetMovementModel()

void AALSBaseCharacter::SetMovementModel ( )

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetMovementModel);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
 
    if (ensureMsgf(!MovementModel.IsNull(), TEXT("Did you forget to fill in MovementModel information?")))
    {
        const FString ContextString = GetFullName();
        FALSMovementStateSettings* OutRow = MovementModel.DataTable->FindRow<FALSMovementStateSettings>(MovementModel.RowName, ContextString);
        if (ensureMsgf(OutRow, TEXT("Failed to find row")))
        {
            MovementData = *OutRow;
            return;
        }
    }
    MovementData = {};
}

◆ SetMovementState()

void AALSBaseCharacter::SetMovementState	(	EALSMovementState	NewState,
		bool	bForce = false )

Character States

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetMovementState);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    if (bForce || MovementState != NewState)
    {
        PrevMovementState = MovementState;
        MovementState = NewState;
        OnMovementStateChanged(PrevMovementState);
        //@ TEST Performance
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetMovementState(MovementState);
        }
    }
}

◆ SetOverlayOverrideState()

void AALSBaseCharacter::SetOverlayOverrideState ( int32 NewState )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetOverlayOverrideState);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    OverlayOverrideState = NewState;
    //@ TEST Performance 
    if(AnimInstanceInterface != nullptr)
    {
        AnimInstanceInterface->SetOverlayOverrideState(OverlayOverrideState);
    }
}

◆ SetOverlayState()

void AALSBaseCharacter::SetOverlayState	(	EALSOverlayState	NewState,
		bool	bForce = false )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetOverlayState);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    if (bForce || OverlayState != NewState)
    {
        const EALSOverlayState Prev = OverlayState;
        OverlayState = NewState;
        OnOverlayStateChanged(Prev);
 
        if (GetLocalRole() == ROLE_AutonomousProxy)
        {
            Server_SetOverlayState(NewState, bForce);
        }
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetOverlayState(OverlayState);
        }
    }
}

◆ SetRightShoulder()

void AALSBaseCharacter::SetRightShoulder ( const bool bNewRightShoulder )

{
    bRightShoulder = bNewRightShoulder;
    if (CameraBehavior)
    {
        CameraBehavior->bRightShoulder = bRightShoulder;
    }
}

◆ SetRotationMode()

void AALSBaseCharacter::SetRotationMode	(	EALSRotationMode	NewRotationMode,
		bool	bForce = false )

virtual

Reimplemented in AMultiplayerPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetRotationMode);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (bForce || RotationMode != NewRotationMode)
    {
        const EALSRotationMode Prev = RotationMode;
        RotationMode = NewRotationMode;
        OnRotationModeChanged(Prev);
 
        if (GetLocalRole() == ROLE_AutonomousProxy)
        {
            Server_SetRotationMode(NewRotationMode, bForce);
        }
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetRotationMode(RotationMode);
        }
    }
}

◆ SetStance()

void AALSBaseCharacter::SetStance	(	EALSStance	NewStance,
		bool	bForce = false )

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetStance);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    if (bForce || Stance != NewStance)
    {
        const EALSStance Prev = Stance;
        Stance = NewStance;
        OnStanceChanged(Prev);
        //@ TEST Performance 
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetStance(Stance);
        }
    }
}

◆ SetupCapsuleComponent()

void AALSBaseCharacter::SetupCapsuleComponent ( ) const

private

{
    if(GetCapsuleComponent() == nullptr){UE_LOG(LogTemp, Error, TEXT("AALSBaseCharacter::SetupCapsuleComponent FAILED"));return;}
    GetCapsuleComponent()->SetCapsuleHalfHeight(90.0f);
    GetCapsuleComponent()->SetCapsuleRadius(35.0f);
    GetCapsuleComponent()->SetAreaClassOverride(UNavArea_Obstacle::StaticClass());\
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_Visibility, ECR_Ignore);
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_Camera, ECR_Ignore);
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_GameTraceChannel3, ECR_Ignore);    // Climable
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_GameTraceChannel4, ECR_Ignore);    // WeaponTraceChannel
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_GameTraceChannel5, ECR_Overlap);   // Interactable
    GetCapsuleComponent()->SetCollisionResponseToChannel(ECC_GameTraceChannel6, ECR_Ignore);    // Characters
}

◆ SetupMeshComponent()

void AALSBaseCharacter::SetupMeshComponent ( ) const

private

{
    if(GetMesh() == nullptr){UE_LOG(LogTemp, Error, TEXT("AALSBaseCharacter::SetupMeshComponent FAILED"));return;}
    GetMesh()->SetWorldTransform(FTransform(FRotator(0.0f,-90.0f,0.0f), FVector(0.0f,0.0f,-92.0f)));
    GetMesh()->SetCollisionResponseToChannel(ECC_Visibility, ECR_Ignore);
    GetMesh()->SetCollisionResponseToChannel(ECC_Camera, ECR_Ignore);
    GetMesh()->SetCollisionResponseToChannel(ECC_GameTraceChannel3, ECR_Ignore);    // Climable
    GetMesh()->SetCollisionResponseToChannel(ECC_GameTraceChannel4, ECR_Block);     // WeaponTraceChannel
    GetMesh()->SetCollisionResponseToChannel(ECC_GameTraceChannel5, ECR_Block);     // Interactable
    GetMesh()->SetCollisionResponseToChannel(ECC_GameTraceChannel5, ECR_Block);     // Characters
    GetMesh()->SetGenerateOverlapEvents(true);
    //@TODO if Using only one Skeleton, Remove this //
    GetMesh()->bUpdateMeshWhenKinematic = true;
    GetMesh()->VisibilityBasedAnimTickOption = EVisibilityBasedAnimTickOption::AlwaysTickPoseAndRefreshBones;
}

◆ SetViewMode()

void AALSBaseCharacter::SetViewMode	(	EALSViewMode	NewViewMode,
		bool	bForce = false )

virtual

Reimplemented in AMultiplayerPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::SetViewMode);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (bForce || ViewMode != NewViewMode)
    {
        const EALSViewMode Prev = ViewMode;
        ViewMode = NewViewMode;
        OnViewModeChanged(Prev);
 
        if (GetLocalRole() == ROLE_AutonomousProxy)
        {
            Server_SetViewMode(NewViewMode, bForce);
        }
        if(AnimInstanceInterface != nullptr)
        {
            AnimInstanceInterface->SetViewMode(ViewMode);
        }
    }
}

◆ SetVisibleMesh()

void AALSBaseCharacter::SetVisibleMesh ( USkeletalMesh * NewSkeletalMesh )

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (VisibleMesh != NewVisibleMesh)
    {
        const USkeletalMesh* Prev = VisibleMesh;
        VisibleMesh = NewVisibleMesh;
        OnVisibleMeshChanged(Prev);
 
        if (GetLocalRole() != ROLE_Authority)
        {
            Server_SetVisibleMesh(NewVisibleMesh);
        }
    }
}

◆ SmoothCharacterRotation()

void AALSBaseCharacter::SmoothCharacterRotation	(	FRotator	Target,
		float	TargetInterpSpeed,
		float	ActorInterpSpeed,
		float	DeltaTime )

protected

Utils

{
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_SmoothCharacterRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    // Interpolate the Target Rotation for extra smooth rotation behavior
    TargetRotation =
        FMath::RInterpConstantTo(TargetRotation, Target, DeltaTime, TargetInterpSpeed);
    SetActorRotation(
        FMath::RInterpTo(GetActorRotation(), TargetRotation, DeltaTime, ActorInterpSpeed));
}

◆ SprintAction()

void AALSBaseCharacter::SprintAction ( bool bValue )

virtual

Reimplemented in ACustomCharacterBase.

{
    if(bValue)
    {
        SetDesiredGait(EALSGait::Sprinting);
    }
    else
    {
        SetDesiredGait(EALSGait::Running);
    }
}

◆ StanceAction()

void AALSBaseCharacter::StanceAction ( )

virtual

Reimplemented in ACustomCharacterBase, and ACustomPlayerCharacter.

{
    // Stance Action: Press "Stance Action" to toggle Standing / Crouching, double tap to Roll.
 
    if (MovementAction != EALSMovementAction::None)
    {
        return;
    }
 
    UWorld* World = GetWorld();
    check(World);
 
    const float PrevStanceInputTime = LastStanceInputTime;
    LastStanceInputTime = World->GetTimeSeconds();
 
    if (LastStanceInputTime - PrevStanceInputTime <= RollDoubleTapTimeout)
    {
        // Roll
        Replicated_PlayMontage(GetRollAnimation(), 1.15f);
 
        if (Stance == EALSStance::Standing)
        {
            SetDesiredStance(EALSStance::Crouching);
        }
        else if (Stance == EALSStance::Crouching)
        {
            SetDesiredStance(EALSStance::Standing);
        }
        return;
    }
 
    if (MovementState == EALSMovementState::Grounded)
    {
        if (Stance == EALSStance::Standing)
        {
            SetDesiredStance(EALSStance::Crouching);
            Crouch();
        }
        else if (Stance == EALSStance::Crouching)
        {
            SetDesiredStance(EALSStance::Standing);
            UnCrouch();
        }
    }
 
    // Notice: MovementState == EALSMovementState::InAir case is removed
}

◆ StopReplicatedMontage()

void AALSBaseCharacter::StopReplicatedMontage	(	const float	InBlendOutTime,
		const UAnimMontage *	Montage )

overridevirtual

Reimplemented from ACharacterBase.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::StopReplicatedMontage);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
    Super::StopReplicatedMontage(InBlendOutTime, Montage);
    if(GetMesh() != nullptr && GetMesh()->GetAnimInstance() != nullptr)
    {
        GetMesh()->GetAnimInstance()->Montage_Stop(InBlendOutTime, Montage);
    }
    Server_StopMontage(InBlendOutTime, Montage);
}

◆ Tick()

void AALSBaseCharacter::Tick ( float DeltaTime )

overridevirtual

Reimplemented from ACharacterBase.

Reimplemented in ACustomAICharacter, ACustomCharacterBase, AALSCharacter, ACampaignAICharacter, and ACustomPlayerCharacter.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::Tick);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_Tick);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    Super::Tick(DeltaTime);
 
    // Set required values
    SetEssentialValues(DeltaTime);
 
    if (MovementState == EALSMovementState::Grounded)
    {
        UpdateCharacterMovement();
        UpdateGroundedRotation(DeltaTime);
    }
    else if(MovementState == EALSMovementState::InAir)
    {
        if(GetIsFlying())
        {
            UpdateCharacterMovement();
            UpdateGroundedRotation(DeltaTime);
        }
        else
        {
            UpdateInAirRotation(DeltaTime);
        }
    }
    else if(MovementState == EALSMovementState::Ragdoll)
    {
        RagdollUpdate(DeltaTime);
    }
 
    // Cache values
    PreviousVelocity = GetVelocity();
    PreviousAimYaw = AimingRotation.Yaw;
}

◆ UpdateCharacterMovement()

void AALSBaseCharacter::UpdateCharacterMovement ( )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::UpdateCharacterMovement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_UpdateMovement);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
 
    // Set the Allowed Gait
    const EALSGait AllowedGait = GetAllowedGait();
 
    // Determine the Actual Gait. If it is different from the current Gait, Set the new Gait Event.
    const EALSGait ActualGait = GetActualGait(AllowedGait);
 
    if (ActualGait != Gait)
    {
        SetGait(ActualGait);
    }
 
    // Update the Character Max Walk Speed to the configured speeds based on the currently Allowed Gait.
    MyCharacterMovementComponent->SetAllowedGait(AllowedGait);
}

◆ UpdateGroundedRotation()

void AALSBaseCharacter::UpdateGroundedRotation ( float DeltaTime )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::UpdateGroundedRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_UpdateGroundedRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if(bOptimizeGroundRotation)
    {
        if (MovementAction != EALSMovementAction::None)
        {
            // Handle Rolling Rotation (skip other actions)
            if (MovementAction == EALSMovementAction::Rolling && !bEnableNetworkOptimizations && bHasMovementInput)
            {
                SmoothCharacterRotation({0.0f, LastMovementInputRotation.Yaw, 0.0f}, 0.0f, 2.0f, DeltaTime);
            }
            return;
        }
 
        // Check if we can update the moving rotation
        const bool bCanUpdateMovingRot = (((bIsMoving && bHasMovementInput) || (Speed > 150.0f || GetIsFlying())) && !HasAnyRootMotion());
        if (bCanUpdateMovingRot)
        {
            const float GroundedRotationRate = CalculateGroundedRotationRate();
            FRotator TargetRot{0.0f, 0.0f, 0.0f};
 
            switch (RotationMode)
            {
            case EALSRotationMode::VelocityDirection:
                TargetRot.Yaw = LastVelocityRotation.Yaw;
                SmoothCharacterRotation(TargetRot, 800.0f, GroundedRotationRate, DeltaTime);
                break;
 
            case EALSRotationMode::LookingDirection:
                TargetRot.Yaw = (Gait == EALSGait::Sprinting) 
                                ? LastVelocityRotation.Yaw 
                                : AimingRotation.Yaw + GetAnimCurveValue(NAME_YawOffset);
                SmoothCharacterRotation(TargetRot, 500.0f, GroundedRotationRate, DeltaTime);
                break;
 
            case EALSRotationMode::Aiming:
                TargetRot.Yaw = AimingRotation.Yaw;
                SmoothCharacterRotation(TargetRot, 1000.0f, 20.0f, DeltaTime);
                break;
            }
        }
        else
        {
            // if(GetIsFlying())
            // {
            //  // Check for Moving when speed is 0
            //  return;
            // }
            // Handle Non-Moving Rotation
            HandleNonMovingRotation(DeltaTime);
        }
        return;
    }
    //@ TEST Optimizations  //
    if (MovementAction == EALSMovementAction::None)
    {
        const bool bCanUpdateMovingRot = ((bIsMoving && bHasMovementInput) || (Speed > 150.0f || GetIsFlying())) && !HasAnyRootMotion();
        if (bCanUpdateMovingRot)
        {
            const float GroundedRotationRate = CalculateGroundedRotationRate();
            if (RotationMode == EALSRotationMode::VelocityDirection)
            {
                // Velocity Direction Rotation
                SmoothCharacterRotation({0.0f, LastVelocityRotation.Yaw, 0.0f}, 800.0f, GroundedRotationRate,
                                        DeltaTime);
            }
            else if (RotationMode == EALSRotationMode::LookingDirection)
            {
                // Looking Direction Rotation
                float YawValue;
                if (Gait == EALSGait::Sprinting)
                {
                    YawValue = LastVelocityRotation.Yaw;
                }
                else
                {
                    // Walking or Running..
                    const float YawOffsetCurveVal = GetAnimCurveValue(NAME_YawOffset);
                    YawValue = AimingRotation.Yaw + YawOffsetCurveVal;
                }
                SmoothCharacterRotation({0.0f, YawValue, 0.0f}, 500.0f, GroundedRotationRate, DeltaTime);
            }
            else if (RotationMode == EALSRotationMode::Aiming)
            {
                const float ControlYaw = AimingRotation.Yaw;
                SmoothCharacterRotation({0.0f, ControlYaw, 0.0f}, 1000.0f, 20.0f, DeltaTime);
            }
        }
        else
        {
            // Not Moving
    
            if ((ViewMode == EALSViewMode::ThirdPerson && RotationMode == EALSRotationMode::Aiming) ||
                ViewMode == EALSViewMode::FirstPerson)
            {
                LimitRotation(-100.0f, 100.0f, 20.0f, DeltaTime);
            }
    
            // Apply the RotationAmount curve from Turn In Place Animations.
            // The Rotation Amount curve defines how much rotation should be applied each frame,
            // and is calculated for animations that are animated at 30fps.
    
            const float RotAmountCurve = GetAnimCurveValue(NAME_RotationAmount);
    
            if (FMath::Abs(RotAmountCurve) > 0.001f)
            {
                if (GetLocalRole() == ROLE_AutonomousProxy)
                {
                    TargetRotation.Yaw = UKismetMathLibrary::NormalizeAxis(
                        TargetRotation.Yaw + (RotAmountCurve * (DeltaTime / (1.0f / 30.0f))));
                    SetActorRotation(TargetRotation);
                }
                else
                {
                    AddActorWorldRotation({0, RotAmountCurve * (DeltaTime / (1.0f / 30.0f)), 0});
                }
                TargetRotation = GetActorRotation();
            }
        }
    }
    else if (MovementAction == EALSMovementAction::Rolling)
    {
        // Rolling Rotation (Not allowed on networked games)
        if (!bEnableNetworkOptimizations && bHasMovementInput)
        {
            SmoothCharacterRotation({0.0f, LastMovementInputRotation.Yaw, 0.0f}, 0.0f, 2.0f, DeltaTime);
        }
    }
    
    // Other actions are ignored...
}

◆ UpdateInAirRotation()

void AALSBaseCharacter::UpdateInAirRotation ( float DeltaTime )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSBaseCharacter::UpdateInAirRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Base_Character_AirRotation);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_All);
 
    if (RotationMode == EALSRotationMode::VelocityDirection || RotationMode == EALSRotationMode::LookingDirection)
    {
        // Velocity / Looking Direction Rotation
        SmoothCharacterRotation({0.0f, InAirRotation.Yaw, 0.0f}, 0.0f, 5.0f, DeltaTime);
    }
    else if (RotationMode == EALSRotationMode::Aiming)
    {
        // Aiming Rotation
        SmoothCharacterRotation({0.0f, AimingRotation.Yaw, 0.0f}, 0.0f, 15.0f, DeltaTime);
        InAirRotation = GetActorRotation();
    }
}

◆ VelocityDirectionAction()

void AALSBaseCharacter::VelocityDirectionAction ( )

◆ WalkAction()

void AALSBaseCharacter::WalkAction ( )

Member Data Documentation

◆ Acceleration

FVector AALSBaseCharacter::Acceleration = FVector::ZeroVector

protected

Essential Information

◆ AimingRotation

FRotator AALSBaseCharacter::AimingRotation = FRotator::ZeroRotator

protected

◆ AimYawRate

float AALSBaseCharacter::AimYawRate = 0.0f

protected

◆ ALSDebugComponent

TObjectPtr<UALSDebugComponent> AALSBaseCharacter::ALSDebugComponent = nullptr

private

◆ AnimInstanceInterface

IALSAnimInterface* AALSBaseCharacter::AnimInstanceInterface

protected

◆ AnimValues

FALSAnimValues AALSBaseCharacter::AnimValues

protected

◆ bAimDownSights

bool AALSBaseCharacter::bAimDownSights = false

protected

◆ bBreakFall

bool AALSBaseCharacter::bBreakFall = false

protected

◆ bBreakfallOnLand

bool AALSBaseCharacter::bBreakfallOnLand = true

protected

Breakfall System If player hits to the ground with a specified amount of velocity, switch to breakfall state

◆ bEnableNetworkOptimizations

bool AALSBaseCharacter::bEnableNetworkOptimizations = false

protected

We won't use curve based movement and a few other features on networked games

◆ bForceEnableNetworkOptimizationsOff

bool AALSBaseCharacter::bForceEnableNetworkOptimizationsOff = false

protected

◆ bHasMovementInput

bool AALSBaseCharacter::bHasMovementInput = false

protected

◆ bIsFlying

bool AALSBaseCharacter::bIsFlying = false

protected

◆ bIsMoving

bool AALSBaseCharacter::bIsMoving = false

protected

◆ bOptimizeAnimValues

bool AALSBaseCharacter::bOptimizeAnimValues = true

protected

◆ bOptimizeGroundRotation

bool AALSBaseCharacter::bOptimizeGroundRotation = true

protected

Optimizations

◆ bPreRagdollURO

bool AALSBaseCharacter::bPreRagdollURO = false

protected

◆ bRagdollFaceUp

bool AALSBaseCharacter::bRagdollFaceUp = false

protected

◆ bRagdollOnGround

bool AALSBaseCharacter::bRagdollOnGround = false

protected

◆ bRagdollOnLand

bool AALSBaseCharacter::bRagdollOnLand = false

protected

If player hits to the ground with a specified amount of velocity, switch to ragdoll state

◆ BreakfallOnLandVelocity

float AALSBaseCharacter::BreakfallOnLandVelocity = 700.0f

protected

If player hits to the ground with an amount of velocity greater than specified value, switch to breakfall state

◆ bReversedPelvis

bool AALSBaseCharacter::bReversedPelvis = false

protected

Ragdoll System If the skeleton uses a reversed pelvis bone, flip the calculation operator

◆ bRightShoulder

bool AALSBaseCharacter::bRightShoulder = false

protected

◆ bSprintHeld

bool AALSBaseCharacter::bSprintHeld = false

protected

◆ CameraBehavior

TObjectPtr<UALSPlayerCameraBehavior> AALSBaseCharacter::CameraBehavior

protected

◆ DefVisBasedTickOp

EVisibilityBasedAnimTickOption AALSBaseCharacter::DefVisBasedTickOp

protected

◆ DesiredGait

EALSGait AALSBaseCharacter::DesiredGait = EALSGait::Running

protected

◆ DesiredRotationMode

EALSRotationMode AALSBaseCharacter::DesiredRotationMode = EALSRotationMode::LookingDirection

protected

Optimizations
Input

◆ DesiredStance

EALSStance AALSBaseCharacter::DesiredStance = EALSStance::Standing

protected

◆ EasedMaxAcceleration

float AALSBaseCharacter::EasedMaxAcceleration = 0.0f

protected

Replicated Essential Information

◆ FirstPersonFOV

float AALSBaseCharacter::FirstPersonFOV = 90.0f

protected

◆ Gait

EALSGait AALSBaseCharacter::Gait = EALSGait::Walking

protected

◆ GravityMultiplier

float AALSBaseCharacter::GravityMultiplier = 9.8f

◆ GroundedEntryState

EALSGroundedEntryState AALSBaseCharacter::GroundedEntryState

protected

◆ InAirRotation

FRotator AALSBaseCharacter::InAirRotation = FRotator::ZeroRotator

protected

◆ JumpPressedDelegate

FJumpPressedSignature AALSBaseCharacter::JumpPressedDelegate

Input

◆ LastMovementInputRotation

FRotator AALSBaseCharacter::LastMovementInputRotation

protected

◆ LastRagdollVelocity

FVector AALSBaseCharacter::LastRagdollVelocity = FVector::ZeroVector

protected

◆ LastStanceInputTime

float AALSBaseCharacter::LastStanceInputTime = 0.0f

protected

Last time the 'first' crouch/roll button is pressed

◆ LastVelocityRotation

FRotator AALSBaseCharacter::LastVelocityRotation

protected

◆ LookLeftRightRate

float AALSBaseCharacter::LookLeftRightRate = 1.25f

protected

◆ LookUpDownRate

float AALSBaseCharacter::LookUpDownRate = 1.25f

protected

◆ MovementAction

EALSMovementAction AALSBaseCharacter::MovementAction = EALSMovementAction::None

protected

◆ MovementData

FALSMovementStateSettings AALSBaseCharacter::MovementData

protected

Movement System

◆ MovementInputAmount

float AALSBaseCharacter::MovementInputAmount = 0.0f

protected

◆ MovementModel

FDataTableRowHandle AALSBaseCharacter::MovementModel

protected

Movement System

◆ MovementState

EALSMovementState AALSBaseCharacter::MovementState = EALSMovementState::None

protected

◆ MyCharacterMovementComponent

TObjectPtr<UALSCharacterMovementComponent> AALSBaseCharacter::MyCharacterMovementComponent

protected

◆ OnJumpedDelegate

FOnJumpedSignature AALSBaseCharacter::OnJumpedDelegate

◆ OnLandedFrictionResetTimer

FTimerHandle AALSBaseCharacter::OnLandedFrictionResetTimer

protected

◆ OverlayOverrideState

int32 AALSBaseCharacter::OverlayOverrideState = 0

protected

◆ OverlayState

EALSOverlayState AALSBaseCharacter::OverlayState = EALSOverlayState::Default

protected

State Values

◆ PreviousAimYaw

float AALSBaseCharacter::PreviousAimYaw = 0.0f

protected

◆ PreviousVelocity

FVector AALSBaseCharacter::PreviousVelocity = FVector::ZeroVector

protected

Cached Variables

◆ PrevMovementState

EALSMovementState AALSBaseCharacter::PrevMovementState = EALSMovementState::None

protected

◆ RagdollOnLandVelocity

float AALSBaseCharacter::RagdollOnLandVelocity = 1000.0f

protected

If player hits to the ground with an amount of velocity greater than specified value, switch to ragdoll state

◆ RagdollStateChangedDelegate

FRagdollStateChangedSignature AALSBaseCharacter::RagdollStateChangedDelegate

◆ ReplicatedControlRotation

FRotator AALSBaseCharacter::ReplicatedControlRotation = FRotator::ZeroRotator

protected

◆ ReplicatedCurrentAcceleration

FVector AALSBaseCharacter::ReplicatedCurrentAcceleration = FVector::ZeroVector

protected

◆ RollDoubleTapTimeout

float AALSBaseCharacter::RollDoubleTapTimeout = 0.3f

protected

◆ RotationMode

EALSRotationMode AALSBaseCharacter::RotationMode = EALSRotationMode::LookingDirection

protected

◆ ServerRagdollPull

float AALSBaseCharacter::ServerRagdollPull = 0.0f

protected

◆ Speed

float AALSBaseCharacter::Speed = 0.0f

protected

◆ Stance

EALSStance AALSBaseCharacter::Stance = EALSStance::Standing

protected

◆ TargetRagdollLocation

FVector AALSBaseCharacter::TargetRagdollLocation = FVector::ZeroVector

protected

◆ TargetRotation

FRotator AALSBaseCharacter::TargetRotation = FRotator::ZeroRotator

protected

Rotation System

◆ ThirdPersonFOV

float AALSBaseCharacter::ThirdPersonFOV = 90.0f

protected

Camera System

◆ ViewMode

EALSViewMode AALSBaseCharacter::ViewMode = EALSViewMode::ThirdPerson

protected

◆ VisibleMesh

TObjectPtr<USkeletalMesh> AALSBaseCharacter::VisibleMesh = nullptr

protected

Replicated Skeletal Mesh Information

◆ YawOffset

float AALSBaseCharacter::YawOffset = 0.0f

protected

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/ALSBaseCharacter.h
T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Private/Character/ALSBaseCharacter.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ AALSBaseCharacter()

Member Function Documentation

◆ AimAction()

◆ BeginPlay()

◆ CalculateGroundedRotationRate()

◆ CameraHeldAction()

◆ CameraRightAction()

◆ CameraTapAction()

◆ CameraUpAction()

◆ CanSprint()

◆ EventOnJumped()

◆ EventOnLanded()

◆ ForceUpdateCharacterState()

◆ ForwardMovementAction()

◆ GetAcceleration()

◆ GetActualGait()

◆ GetAimDownSightCameraTarget()

◆ GetAimDownSightFOV()

◆ GetAimingRotation()

◆ GetAimYawRate()

◆ GetAllowedGait()

◆ GetALSGravityMovementInterface()

◆ GetALSMovementComponent()

◆ GetAnimCurveValue()

◆ GetCameraParameters()

◆ GetCanAimDownSights()

◆ GetCurrentOverlayState()

◆ GetDesiredGait()

◆ GetDesiredRotationMode()

◆ GetDesiredStance()

◆ GetFirstPersonCameraTarget()

◆ GetGait()

◆ GetGetUpAnimation()

◆ GetGroundedEntryState()

◆ GetIsFlying()

◆ GetIsMantling()

◆ GetLeftHandGoal()

◆ GetLifetimeReplicatedProps()

◆ GetMovementAction()

◆ GetMovementInput()

◆ GetMovementInputAmount()

◆ GetMovementState()

◆ GetOverlayOverrideState()

◆ GetOverlayState()

◆ GetPrevMovementState()

◆ GetRightHandGoal()

◆ GetRollAnimation()

◆ GetRotationMode()

◆ GetSpeed()

◆ GetStance()

◆ GetTargetMovementSettings()

◆ GetThirdPersonPivotTarget()

◆ GetThirdPersonTraceParams()

◆ GetViewMode()

◆ HandleNonMovingRotation()

◆ HasMovementInput()

◆ IsAimingDownSights()

◆ IsMoving()

◆ IsRightShoulder()

◆ JumpAction()

◆ Landed()

◆ LimitRotation()

◆ LookingDirectionAction()

◆ Multicast_OnJumped()

◆ Multicast_OnLanded()

◆ Multicast_PlayMontage()

◆ Multicast_RagdollEnd()

◆ Multicast_RagdollStart()

◆ Multicast_StopMontage()

◆ OnBreakfall()

◆ OnBreakfall_Implementation()

◆ OnEndCrouch()

◆ OnGaitChanged()