🎭 Lesson 3.2: Writing Actors in C++

Components & the Root

You met CreateDefaultSubobject in Module 1. Here's the rule stated fully: in an actor's constructor, you create its default components with CreateDefaultSubobject<T>, and exactly one of them becomes the RootComponent — the component that defines the actor's transform in the world.

// In the constructor:
USceneComponent* Root = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
RootComponent = Root;   // this actor's transform IS the root's transform

UStaticMeshComponent* Body = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Body"));
Body->SetupAttachment(RootComponent);   // attach Body under the root

Building a Hierarchy

Components attach into a tree. Moving a parent moves its children; the root moves everything. SetupAttachment (in the constructor) builds this tree.

// Attach relationships form the tree above:
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));

Body = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Body"));
Body->SetupAttachment(RootComponent);

SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
SpringArm->SetupAttachment(RootComponent);

Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
Camera->SetupAttachment(SpringArm);   // camera rides the spring arm

The Actor Lifecycle

An actor passes through a defined sequence. Each stage has an intended purpose, and putting code in the wrong stage is a top source of bugs.

Constructor vs BeginPlay

This is the distinction that separates working actors from mysteriously broken ones. The constructor runs in contexts where the game world does not exist yet — including on the Class Default Object the engine creates just to know your class's defaults, and every time you open the editor.

AItemChest::AItemChest()
{
    PrimaryActorTick.bCanEverTick = false;   // this chest doesn't need Tick

    // ✅ OK in constructor: create components, set defaults.
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
    GoldAmount = 100;

    // ❌ WRONG in constructor — the world isn't ready:
    // TArray<AActor*> Found;
    // UGameplayStatics::GetAllActorsOfClass(GetWorld(), ..., Found); // crash risk
}

void AItemChest::BeginPlay()
{
    Super::BeginPlay();

    // ✅ Now the world exists — safe to interact with it.
    UE_LOG(LogTemp, Log, TEXT("Chest ready with %d gold"), GoldAmount);
    // find other actors, register with a subsystem, start a timer, etc.
}

A Complete Actor

Putting it together — a pickup actor that bobs, exposes tunables, and logs when the game starts. Header:

// FloatingPickup.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "FloatingPickup.generated.h"

class UStaticMeshComponent;

UCLASS()
class MYPROJECT_API AFloatingPickup : public AActor
{
    GENERATED_BODY()

public:
    AFloatingPickup();

protected:
    virtual void BeginPlay() override;

public:
    virtual void Tick(float DeltaTime) override;

    UPROPERTY(VisibleAnywhere, Category = "Pickup")
    TObjectPtr<UStaticMeshComponent> Mesh;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Pickup")
    float BobHeight = 20.0f;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Pickup")
    float BobSpeed = 2.0f;

private:
    float RunningTime = 0.0f;
    FVector StartLocation;
};

Source:

// FloatingPickup.cpp
#include "FloatingPickup.h"
#include "Components/StaticMeshComponent.h"

AFloatingPickup::AFloatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;

    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void AFloatingPickup::BeginPlay()
{
    Super::BeginPlay();

    // World exists now — safe to read our placed transform.
    StartLocation = GetActorLocation();
    UE_LOG(LogTemp, Log, TEXT("%s spawned, bobbing enabled"), *GetName());
}

void AFloatingPickup::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    RunningTime += DeltaTime;
    // Oscillate around the starting height using a sine wave.
    const float NewZ = StartLocation.Z + FMath::Sin(RunningTime * BobSpeed) * BobHeight;
    SetActorLocation(FVector(StartLocation.X, StartLocation.Y, NewZ));
}

Hands-on Exercise & Quiz

ABeacon::ABeacon()
{
    PrimaryActorTick.bCanEverTick = true;

    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));

    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    Mesh->SetupAttachment(RootComponent);

    Light = CreateDefaultSubobject<UPointLightComponent>(TEXT("Light"));
    Light->SetupAttachment(RootComponent);
}

Summary

📚 Additional Resources

• Actors (Epic)
• Actor Lifecycle (Epic)

🚀 What's Next?

You've been attaching engine components. Next you'll write your own — custom Actor and Scene Components that package reusable behavior you can drop onto any actor, the composition pattern that keeps Unreal codebases clean.