Refactoring Inheritance into Composition Models

In this lesson, you will learn how to replace rigid "is-a" inheritance hierarchies with flexible "has-a" composition models to make your game features easier to maintain and reuse.

The Problem with Inheritance

When you rely heavily on inheritance (e.g., ACharacter -> AFighter -> AWeaponWielder), your class tree becomes rigid. If you suddenly want a non-combatant NPC to hold a tool, you might find yourself stuck because the "holding" logic is buried deep inside a combat-specific parent class. This creates "God Classes" that are hard to change without breaking other parts of your game.

Moving to Composition

Composition shifts the focus from "what an object is" to "what an object does." Instead of inheriting behavior, you equip your Actor with reusable UActorComponent modules.

Imagine you have a HealthComponent. Instead of putting health logic inside ACharacter, AVehicle, and ABuilding, you create one UHealthComponent that handles damage, healing, and UI updates. You then simply attach this component to any Actor that needs health.

Example: Before (Inheritance)

// Hard to reuse: Only Characters can have health logic here
class ACharacterWithHealth : public ACharacter {
    float Health;
    void TakeDamage();
};

Example: After (Composition)

// Modular: Any Actor can now have health by adding this component
class UHealthComponent : public UActorComponent {
    float Health;
    void TakeDamage();
};

// In your Actor, you just compose it:
AActor::AActor() {
    HealthComp = CreateDefaultSubobject<UHealthComponent>(TEXT("HealthComp"));
}

Why This Scales

By decoupling logic into components:

1. Maintainability: If you need to change how healing works, you update the UHealthComponent once, and every object in the game using it is automatically updated.
2. Flexibility: You can create "designer-friendly" setups where you can swap or remove features (like removing an InventoryComponent from an enemy) directly in the Unreal Editor without writing new C++ code.

Key Takeaway: Replace deep, brittle inheritance trees with modular, reusable ActorComponents to build systems that are independent of your Actor’s base class.