🔌 Lesson 5.5: Interfaces (UINTERFACE)

The Problem Interfaces Solve

Recall the anti-pattern from Lesson 3.5: a chain of casts to handle many types that all share a behavior.

// ❌ The chain-of-casts anti-pattern:
if (ADoor* Door = Cast<ADoor>(Target))          { Door->Open(); }
else if (AChest* Chest = Cast<AChest>(Target))   { Chest->Open(); }
else if (ANPC* Npc = Cast<ANPC>(Target))         { Npc->Talk(); }
// ...every new interactable type means editing THIS function.

An interface replaces all of it with one question: "Target, are you interactable? If so, interact." The caller never names a concrete type, and adding a new interactable never touches this code.

Declaring an Interface

Unreal interfaces are a pair: a UINTERFACE class (reflection boilerplate you never touch) and an I-prefixed class (where your functions live). Create via New C++ Class → Unreal Interface.

// Interactable.h
#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "Interactable.generated.h"

// 1) The UINTERFACE — pure boilerplate; do not add members here.
UINTERFACE(MinimalAPI, Blueprintable)
class UInteractable : public UInterface
{
    GENERATED_BODY()
};

// 2) The I-class — your actual contract. Implementers inherit from THIS.
class IInteractable
{
    GENERATED_BODY()

public:
    // BlueprintNativeEvent: has a C++ default AND can be overridden in Blueprint.
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interaction")
    void Interact(AActor* Interactor);

    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interaction")
    FText GetInteractionPrompt() const;
};

Implementing It

Any class implements the interface by inheriting the I-class and overriding its functions. Because these are BlueprintNativeEvents, the C++ override is named with an _Implementation suffix.

// Door.h — a door that is interactable.
UCLASS()
class MYPROJECT_API ADoor : public AActor, public IInteractable
{
    GENERATED_BODY()

public:
    // Note the _Implementation suffix for BlueprintNativeEvent functions:
    virtual void Interact_Implementation(AActor* Interactor) override;
    virtual FText GetInteractionPrompt_Implementation() const override;
};

// Door.cpp
void ADoor::Interact_Implementation(AActor* Interactor)
{
    bIsOpen = !bIsOpen;
    // ...play the open/close animation, toggle collision...
    UE_LOG(LogTemp, Log, TEXT("Door %s"), bIsOpen ? TEXT("opened") : TEXT("closed"));
}

FText ADoor::GetInteractionPrompt_Implementation() const
{
    return bIsOpen ? FText::FromString(TEXT("Close"))
                   : FText::FromString(TEXT("Open"));
}

A completely unrelated class — say AChest — implements the same interface with its own behavior. That's the whole point: shared contract, independent implementations, no common base class forced on them.

Calling with Execute_

Here's the Unreal-specific twist. Because an implementer might be a Blueprint, you don't call interface functions directly — you call them through a generated static Execute_ wrapper that routes to the right implementation (C++ or Blueprint).

#include "Interactable.h"

void AMyCharacter::TryInteract()
{
    AActor* Target = GetLookedAtActor(300.0f);   // from Lesson 5.2's trace
    if (!IsValid(Target)) { return; }

    // Does this actor implement the interface?
    if (Target->Implements<UInteractable>())      // note: the U-class here
    {
        // Call through Execute_ — works whether implemented in C++ or Blueprint.
        IInteractable::Execute_Interact(Target, this);
    }
}

The Interaction System

Assembling the module: the character traces for what it's looking at (5.2), asks if it's interactable (5.5), and interacts. A prompt UI can show GetInteractionPrompt. Adding a new interactable type — a lever, a terminal, a pet — requires zero changes to the character.

void AMyCharacter::UpdateInteractionPrompt()
{
    AActor* Target = GetLookedAtActor(300.0f);

    if (IsValid(Target) && Target->Implements<UInteractable>())
    {
        const FText Prompt = IInteractable::Execute_GetInteractionPrompt(Target);
        // ...show Prompt on the HUD: "Press E to " + Prompt...
    }
    else
    {
        // ...hide the prompt...
    }
}

💡 The spectrum, complete: Module 3.5 promised interfaces and delegates as the loose end of the coupling spectrum. You've now built both — delegates for "X happened, whoever cares" (5.4) and interfaces for "can you do X?" (5.5). Between direct references, components, interfaces, and events, you have the full communication toolkit. Choosing among them well is a hallmark of clean Unreal C++.

Hands-on Exercise & Quiz

Summary

📚 Additional Resources

• Interfaces (Epic)
• BenUI — Unreal interfaces explained

🚀 What's Next?

Module 5 is complete — collision, traces, timers, delegates, and interfaces give you the full interaction toolkit. Module 6 is the heart of the course: C++ ↔ Blueprint interop — everything you've been hinting at, made explicit, so your C++ and designers' Blueprints become one seamless workflow.