ATP_ThirdPersonCharacter Class Reference

#include <TP_ThirdPersonCharacter.h>

Inheritance diagram for ATP_ThirdPersonCharacter:

Public Member Functions
	ATP_ThirdPersonCharacter ()
FORCEINLINE class USpringArmComponent *	GetCameraBoom () const
FORCEINLINE class UCameraComponent *	GetFollowCamera () const

Protected Member Functions
void	Move (const FInputActionValue &Value)
void	Look (const FInputActionValue &Value)
virtual void	SetupPlayerInputComponent (class UInputComponent *PlayerInputComponent) override
virtual void	BeginPlay ()

Private Attributes
class USpringArmComponent *	CameraBoom
class UCameraComponent *	FollowCamera
class UInputMappingContext *	DefaultMappingContext
class UInputAction *	JumpAction
class UInputAction *	MoveAction
class UInputAction *	LookAction

Constructor & Destructor Documentation

ATP_ThirdPersonCharacter()

ATP_ThirdPersonCharacter::ATP_ThirdPersonCharacter

(

)

{
    // Set size for collision capsule
    GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
        
    // Don't rotate when the controller rotates. Let that just affect the camera.
    bUseControllerRotationPitch = false;
    bUseControllerRotationYaw = false;
    bUseControllerRotationRoll = false;
 
    // Configure character movement
    GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...   
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 500.0f, 0.0f); // ...at this rotation rate
 
    // Note: For faster iteration times these variables, and many more, can be tweaked in the Character Blueprint
    // instead of recompiling to adjust them
    GetCharacterMovement()->JumpZVelocity = 700.f;
    GetCharacterMovement()->AirControl = 0.35f;
    GetCharacterMovement()->MaxWalkSpeed = 500.f;
    GetCharacterMovement()->MinAnalogWalkSpeed = 20.f;
    GetCharacterMovement()->BrakingDecelerationWalking = 2000.f;
 
    // Create a camera boom (pulls in towards the player if there is a collision)
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->TargetArmLength = 400.0f; // The camera follows at this distance behind the character   
    CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller
 
    // Create a follow camera
    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
    FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
 
    // Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
    // are set in the derived blueprint asset named ThirdPersonCharacter (to avoid direct content references in C++)
}

Member Function Documentation

BeginPlay()

void ATP_ThirdPersonCharacter::BeginPlay ( )

protectedvirtual

{
    // Call the base class  
    Super::BeginPlay();
 
    //Add Input Mapping Context
    if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
    {
        if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
        {
            Subsystem->AddMappingContext(DefaultMappingContext, 0);
        }
    }
}

GetCameraBoom()

FORCEINLINE class USpringArmComponent * ATP_ThirdPersonCharacter::GetCameraBoom ( ) const

inline

Returns CameraBoom subobject

{ return CameraBoom; }

GetFollowCamera()

FORCEINLINE class UCameraComponent * ATP_ThirdPersonCharacter::GetFollowCamera ( ) const

inline

Returns FollowCamera subobject

{ return FollowCamera; }

Look()

void ATP_ThirdPersonCharacter::Look ( const FInputActionValue & Value )

protected

Called for looking input

{
    // input is a Vector2D
    FVector2D LookAxisVector = Value.Get<FVector2D>();
 
    if (Controller != nullptr)
    {
        // add yaw and pitch input to controller
        AddControllerYawInput(LookAxisVector.X);
        AddControllerPitchInput(LookAxisVector.Y);
    }
}

Move()

void ATP_ThirdPersonCharacter::Move ( const FInputActionValue & Value )

protected

Called for movement input

{
    // input is a Vector2D
    FVector2D MovementVector = Value.Get<FVector2D>();
 
    if (Controller != nullptr)
    {
        // find out which way is forward
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);
 
        // get forward vector
        const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    
        // get right vector 
        const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
 
        // add movement 
        AddMovementInput(ForwardDirection, MovementVector.Y);
        AddMovementInput(RightDirection, MovementVector.X);
    }
}

SetupPlayerInputComponent()

void ATP_ThirdPersonCharacter::SetupPlayerInputComponent ( class UInputComponent * PlayerInputComponent )

overrideprotectedvirtual

{
    // Set up action bindings
    if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent)) {
        
        //Jumping
        EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ACharacter::Jump);
        EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);
 
        //Moving
        EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ATP_ThirdPersonCharacter::Move);
 
        //Looking
        EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ATP_ThirdPersonCharacter::Look);
 
    }
 
}

Member Data Documentation

CameraBoom

class USpringArmComponent* ATP_ThirdPersonCharacter::CameraBoom

private

Camera boom positioning the camera behind the character

DefaultMappingContext

class UInputMappingContext* ATP_ThirdPersonCharacter::DefaultMappingContext

private

MappingContext

FollowCamera

class UCameraComponent* ATP_ThirdPersonCharacter::FollowCamera

private

Follow camera

JumpAction

class UInputAction* ATP_ThirdPersonCharacter::JumpAction

private

Jump Input Action

LookAction

class UInputAction* ATP_ThirdPersonCharacter::LookAction

private

Look Input Action

MoveAction

class UInputAction* ATP_ThirdPersonCharacter::MoveAction

private

Move Input Action

---

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

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Source/SpaceAdventure/TP_ThirdPerson/TP_ThirdPersonCharacter.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Source/SpaceAdventure/TP_ThirdPerson/TP_ThirdPersonCharacter.cpp