🏃 Lesson 4.2: Pawns, Characters & Movement

Anatomy of a Character

Recall from Lesson 3.1: ACharacter arrives with a capsule (collision), a skeletal mesh, and a Character Movement Component. For a third-person game you add a spring arm (a camera boom that pulls in near walls) and a camera on its end.

Building the Character

Create via New C++ Class → Character. Add the camera boom and camera in the constructor. Header (abbreviated to the new parts; input properties from Lesson 4.1 still apply):

// MyCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h"

class USpringArmComponent;
class UCameraComponent;
class UInputAction;
class UInputMappingContext;
struct FInputActionValue;

UCLASS()
class MYPROJECT_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

protected:
    virtual void BeginPlay() override;
    virtual void SetupPlayerInputComponent(UInputComponent* InputComponent) override;

    UPROPERTY(VisibleAnywhere, Category = "Camera")
    TObjectPtr<USpringArmComponent> SpringArm;

    UPROPERTY(VisibleAnywhere, Category = "Camera")
    TObjectPtr<UCameraComponent> Camera;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputMappingContext> DefaultMappingContext;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> MoveAction;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> LookAction;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> JumpAction;

    void Move(const FInputActionValue& Value);
    void Look(const FInputActionValue& Value);
};

// MyCharacter.cpp (constructor)
#include "MyCharacter.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/CharacterMovementComponent.h"

AMyCharacter::AMyCharacter()
{
    PrimaryActorTick.bCanEverTick = false;   // movement comp handles per-frame work

    // Spring arm: a boom attached to the capsule root.
    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
    SpringArm->SetupAttachment(RootComponent);
    SpringArm->TargetArmLength = 400.0f;
    SpringArm->bUsePawnControlRotation = true;   // arm rotates with the controller

    // Camera on the end of the arm.
    Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    Camera->SetupAttachment(SpringArm);
    Camera->bUsePawnControlRotation = false;     // camera follows the arm, not input directly

    // Movement feel: the body turns toward its movement direction, not the camera.
    bUseControllerRotationYaw = false;
    GetCharacterMovement()->bOrientRotationToMovement = true;
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f);
    GetCharacterMovement()->JumpZVelocity = 500.0f;
    GetCharacterMovement()->MaxWalkSpeed = 500.0f;
}

Movement & Jump

Bind input as in Lesson 4.1, then implement the handlers. The movement handler is where the camera-relative feel comes together:

#include "EnhancedInputComponent.h"
#include "InputActionValue.h"

void AMyCharacter::SetupPlayerInputComponent(UInputComponent* InputComponent)
{
    Super::SetupPlayerInputComponent(InputComponent);

    if (UEnhancedInputComponent* EIC = Cast<UEnhancedInputComponent>(InputComponent))
    {
        EIC->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyCharacter::Move);
        EIC->BindAction(LookAction, ETriggerEvent::Triggered, this, &AMyCharacter::Look);
        // ACharacter provides Jump()/StopJumping() out of the box:
        EIC->BindAction(JumpAction, ETriggerEvent::Started,   this, &ACharacter::Jump);
        EIC->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);
    }
}

void AMyCharacter::Move(const FInputActionValue& Value)
{
    const FVector2D Axis = Value.Get<FVector2D>();
    if (!Controller) { return; }

    // Move relative to where the CONTROLLER faces (camera-relative), ignoring pitch.
    const FRotator YawRotation(0.0f, Controller->GetControlRotation().Yaw, 0.0f);
    const FVector Forward = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector Right   = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

    AddMovementInput(Forward, Axis.Y);
    AddMovementInput(Right,   Axis.X);
}

void AMyCharacter::Look(const FInputActionValue& Value)
{
    const FVector2D Axis = Value.Get<FVector2D>();
    AddControllerYawInput(Axis.X);
    AddControllerPitchInput(Axis.Y);
}

Tuning the Movement Component

UCharacterMovementComponent is a deep, battle-tested system (it's even network-predicted — Module 10). You mostly tune it via properties. The essentials:

// Access it anywhere via GetCharacterMovement():
UCharacterMovementComponent* Move = GetCharacterMovement();
Move->MaxWalkSpeed = 600.0f;    // e.g. when sprinting
Move->AirControl   = 0.2f;

When to Use a Bare Pawn

ACharacter is purpose-built for humanoid walking. When your controllable thing doesn't walk like a person, a bare APawn is the better base:

💡 The trade: ACharacter gives you a lot for free but assumes humanoid locomotion. A bare APawn gives you a blank body — you add a mesh, a collision component, and your own movement (or a UFloatingPawnMovement / UPawnMovementComponent). Pick the one whose assumptions match your creature.

Hands-on Exercise & Quiz

void AMyCharacter::StartSprint(const FInputActionValue&)
{
    GetCharacterMovement()->MaxWalkSpeed = 900.0f;
}
void AMyCharacter::StopSprint(const FInputActionValue&)
{
    GetCharacterMovement()->MaxWalkSpeed = 500.0f;
}

Summary

📚 Additional Resources

• Character Movement Component (Epic)
• Setting Up a Character (Epic)

🚀 What's Next?

Your character moves. But who owns the input, the camera target, and the per-player data — and how does a brain attach to a body? The final Module 4 lesson covers the PlayerController and possession, tying the framework together.