🧩 Lesson 3.3: Custom Actor & Scene Components

Composition over Inheritance

Imagine health. If you put health logic directly in your ACharacter, then your destructible ABarrel, your ATurret, and your ADoor each need their own copy — or an awkward shared base class that forces unrelated things to be siblings. Inheritance trees get tangled fast.

Composition flips it: write a UHealthComponent once, and attach it to any actor that should have health — character, barrel, turret, door. Each keeps its own base class; they just share a part.

ActorComponent vs SceneComponent

There are two component base classes, and the choice is simple once you know the rule:

Writing a Health Component

Health has no transform, so it's a UActorComponent. Create it via Tools → New C++ Class → Actor Component. Header:

// HealthComponent.h
#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "HealthComponent.generated.h"

// Meta specifier: makes this component addable in the editor's Add Component menu.
UCLASS(ClassGroup = (Custom), meta = (BlueprintSpawnableComponent))
class MYPROJECT_API UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UHealthComponent();

protected:
    virtual void BeginPlay() override;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Health")
    float MaxHealth = 100.0f;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Health")
    float CurrentHealth = 0.0f;

public:
    // Apply damage; returns true if this brought health to zero (a "kill").
    UFUNCTION(BlueprintCallable, Category = "Health")
    bool ApplyDamage(float Amount);

    UFUNCTION(BlueprintPure, Category = "Health")
    bool IsDead() const { return CurrentHealth <= 0.0f; }

    UFUNCTION(BlueprintPure, Category = "Health")
    float GetHealthPercent() const;
};

Source:

// HealthComponent.cpp
#include "HealthComponent.h"

UHealthComponent::UHealthComponent()
{
    // This component has no per-frame work, so disable Tick for performance.
    PrimaryComponentTick.bCanEverTick = false;
}

void UHealthComponent::BeginPlay()
{
    Super::BeginPlay();
    CurrentHealth = MaxHealth;   // start at full when the game begins
}

bool UHealthComponent::ApplyDamage(float Amount)
{
    if (IsDead() || Amount <= 0.0f)
    {
        return false;
    }

    CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
    UE_LOG(LogTemp, Log, TEXT("%s health: %.0f/%.0f"),
        *GetOwner()->GetName(), CurrentHealth, MaxHealth);

    return IsDead();   // true means this hit was fatal
}

float UHealthComponent::GetHealthPercent() const
{
    return (MaxHealth > 0.0f) ? (CurrentHealth / MaxHealth) : 0.0f;
}

Reaching the Owner

A component often needs to talk to the actor it's attached to — its owner. GetOwner() returns that actor as an AActor*; cast it when you need a specific type.

void UHealthComponent::BeginPlay()
{
    Super::BeginPlay();
    CurrentHealth = MaxHealth;

    // Generic owner access:
    AActor* Owner = GetOwner();
    if (!Owner) { return; }

    // Need a specific type? Cast safely (Lesson 2.2):
    if (ACharacter* OwningCharacter = Cast<ACharacter>(Owner))
    {
        // ... do character-specific setup, e.g. bind to its events ...
    }
}

Using the Component

Add the component to an actor in that actor's constructor, then use it:

// In some AEnemy constructor:
#include "HealthComponent.h"

AEnemy::AEnemy()
{
    // Components are created the same way as any subobject.
    Health = CreateDefaultSubobject<UHealthComponent>(TEXT("Health"));
}

// Later, when the enemy is hit:
void AEnemy::OnHit(float Damage)
{
    const bool bKilled = Health->ApplyDamage(Damage);
    if (bKilled)
    {
        // handle death — ragdoll, score, destroy, etc.
        Destroy();
    }
}

Hands-on Exercise & Quiz

bool UCooldownComponent::TryUse()
{
    if (!IsReady()) { return false; }
    LastUsedTime = GetWorld()->GetTimeSeconds();
    return true;
}

bool UCooldownComponent::IsReady() const
{
    return GetWorld()->GetTimeSeconds() - LastUsedTime >= CooldownDuration;
}

Summary

📚 Additional Resources

• Components (Epic)
• Creating & Attaching Components (Epic)

🚀 What's Next?

You can build actors and the components that power them. Next: bringing actors into and out of existence at runtime — spawning, destroying, and iterating actors, the dynamic side of the world.