📣 Lesson 5.4: Delegates & Events

What Is a Delegate?

A delegate is a variable that holds one or more function references and can call them all. The object that owns the delegate broadcasts; other objects subscribe. Crucially, the broadcaster doesn't know or care who's listening — it just fires.

Delegate Flavors

Unreal has several delegate types. Two axes describe them:

Declaring & Broadcasting

You declare a delegate type with a macro whose name encodes its parameter count, then make a UPROPERTY of that type. The macro goes above the class, in the header.

// HealthComponent.h — declare the delegate TYPE (one param: the component).
// The macro name encodes arity: ..._OneParam, _TwoParams, etc.
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(
    FOnDeathSignature, UHealthComponent*, DeadComponent);

UCLASS(ClassGroup = (Custom), meta = (BlueprintSpawnableComponent))
class MYPROJECT_API UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    // The event instance. BlueprintAssignable lets Blueprints bind to it too.
    UPROPERTY(BlueprintAssignable, Category = "Health")
    FOnDeathSignature OnDeath;

    // ... existing MaxHealth, CurrentHealth, ApplyDamage ...
};

// HealthComponent.cpp — fire the event when health reaches zero.
bool UHealthComponent::ApplyDamage(float Amount)
{
    if (IsDead() || Amount <= 0.0f) { return false; }

    CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);

    if (IsDead())
    {
        // Announce to every listener. We pass 'this' so they know who died.
        OnDeath.Broadcast(this);
        return true;
    }
    return false;
}

Subscribing & Unsubscribing

A listener binds a UFUNCTION() whose signature matches the delegate. Same AddDynamic you used for collision in Lesson 5.1 — because those collision events are dynamic multicast delegates.

// A ScoreManager listens for a specific enemy's death.
void AScoreManager::WatchEnemy(AEnemy* Enemy)
{
    if (UHealthComponent* Health = Enemy->FindComponentByClass<UHealthComponent>())
    {
        // Subscribe: call HandleDeath when this component broadcasts OnDeath.
        Health->OnDeath.AddDynamic(this, &AScoreManager::HandleDeath);
    }
}

// The handler — signature MUST match the delegate (one UHealthComponent* param).
UFUNCTION()
void AScoreManager::HandleDeath(UHealthComponent* DeadComponent)
{
    Score += 100;
    UE_LOG(LogTemp, Log, TEXT("Kill! Score = %d"), Score);
}

// Later, stop listening (e.g. in EndPlay, Lesson 2.6 cleanup discipline):
void AScoreManager::EndPlay(const EEndPlayReason::Type Reason)
{
    if (WatchedHealth) { WatchedHealth->OnDeath.RemoveDynamic(this, &AScoreManager::HandleDeath); }
    Super::EndPlay(Reason);
}

Refactoring HealthComponent

Look at what the OnDeath event buys us across the modules. Before, an enemy had to poll Health->IsDead() and everyone needed a reference to the enemy. Now:

💡 When NOT to use an event: if exactly one object cares and it already has a direct reference, a plain function call is simpler. Events shine for one-to-many and for decoupling a sender from unknown receivers. Don't add a delegate where a direct call would do — match the tool to the relationship (Lesson 3.5).

Hands-on Exercise & Quiz

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnHealthChangedSignature, float, NewHealth, float, MaxHealth);

UPROPERTY(BlueprintAssignable, Category = "Health")
FOnHealthChangedSignature OnHealthChanged;

// After any change:
OnHealthChanged.Broadcast(CurrentHealth, MaxHealth);

Summary

📚 Additional Resources

• Delegates (Epic)
• Dynamic Delegates (Epic)

🚀 What's Next?

Delegates broadcast "something happened." The last interaction pattern answers "can you do X?" across unrelated types — interfaces. We'll build IInteractable and finally close the coupling spectrum from Module 3.5.