🏛️ Lesson 6.4: The C++ Base / Blueprint Subclass Pattern

The Division of Labor

The pattern from Lesson 1.1, now with the vocabulary to build it. A single C++ base class holds the mechanics; each Blueprint subclass supplies the content and tuning.

Blueprintable & Abstract

Two UCLASS specifiers set up the base for subclassing:

• Blueprintable — allows designers to create Blueprint subclasses of this C++ class. Without it, "Create Blueprint Class based on…" won't offer your class.
• Abstract — marks the base as not-directly-usable: you can't place a raw AWeaponBase in a level, only its concrete subclasses. This prevents designers from accidentally using the un-configured base.

// A base meant to be subclassed in Blueprint, never used directly.
UCLASS(Abstract, Blueprintable)
class MYPROJECT_API AWeaponBase : public AActor
{
    GENERATED_BODY()
    // ...
};

Building AWeaponBase

Here's the base, using every interop tool from this module. Header:

// WeaponBase.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "WeaponStats.h"     // FWeaponStats + EWeaponType (Lesson 6.3)
#include "WeaponBase.generated.h"

class USkeletalMeshComponent;

UCLASS(Abstract, Blueprintable)
class MYPROJECT_API AWeaponBase : public AActor
{
    GENERATED_BODY()

public:
    AWeaponBase();

protected:
    virtual void BeginPlay() override;

    // ---- Content: designers set these on the Blueprint subclass ----
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Weapon")
    TObjectPtr<USkeletalMeshComponent> Mesh;

    // Tuning bundled as a struct (Lesson 6.3), edited on the BP default.
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
    FWeaponStats Stats;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
    EWeaponType Type = EWeaponType::Rifle;

    // ---- Runtime state: C++ owns it, BP reads it ----
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "State")
    int32 CurrentAmmo = 0;

public:
    // ---- Mechanics: BP can trigger, C++ implements (Lesson 6.1) ----
    UFUNCTION(BlueprintCallable, Category = "Weapon")
    void Fire();

    UFUNCTION(BlueprintCallable, Category = "Weapon")
    void Reload();

    UFUNCTION(BlueprintPure, Category = "Weapon")
    bool CanFire() const;

    // ---- Cosmetic hooks: C++ calls, designers implement in BP ----
    UFUNCTION(BlueprintImplementableEvent, Category = "Weapon")
    void OnFired();              // muzzle flash, sound, recoil

    UFUNCTION(BlueprintImplementableEvent, Category = "Weapon")
    void OnReloadStarted();      // reload animation, sound

    // ---- Event others can subscribe to (Lesson 5.4) ----
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnAmmoChanged, int32, NewAmmo);
    UPROPERTY(BlueprintAssignable, Category = "Weapon")
    FOnAmmoChanged OnAmmoChanged;

private:
    FTimerHandle ReloadTimer;    // cooldown/timer (Lesson 5.3)
};

Implementation — the mechanics, in C++:

// WeaponBase.cpp
#include "WeaponBase.h"
#include "Components/SkeletalMeshComponent.h"

AWeaponBase::AWeaponBase()
{
    PrimaryActorTick.bCanEverTick = false;
    Mesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void AWeaponBase::BeginPlay()
{
    Super::BeginPlay();
    CurrentAmmo = Stats.MagazineSize;   // start full, using the tuned struct
    OnAmmoChanged.Broadcast(CurrentAmmo);
}

bool AWeaponBase::CanFire() const
{
    return CurrentAmmo > 0;
}

void AWeaponBase::Fire()
{
    if (!CanFire()) { return; }         // enforce the invariant in C++

    --CurrentAmmo;                       // ammo math: mechanics
    // ...trace or spawn projectile using Stats.Damage (Modules 3-5)...

    OnAmmoChanged.Broadcast(CurrentAmmo);
    OnFired();                            // let the Blueprint play VFX/SFX
}

void AWeaponBase::Reload()
{
    OnReloadStarted();                    // designer's reload animation/sound
    // After a delay, refill — timer instead of Tick (Lesson 5.3):
    GetWorldTimerManager().SetTimer(ReloadTimer, [this]()
    {
        CurrentAmmo = Stats.MagazineSize;
        OnAmmoChanged.Broadcast(CurrentAmmo);
    }, 2.0f, false);
}

The Blueprint Subclass

Now the designer's half — no C++ required. In the editor: right-click AWeaponBase in the C++ Classes folder → Create Blueprint class based on WeaponBase → name it BP_Rifle. Then they:

1. Set the Mesh's skeletal mesh to the rifle model.
2. Fill in Stats (Damage 30, FireRate 8, MagazineSize 30) on the default.
3. Set Type to Assault Rifle from the dropdown.
4. Implement OnFired in the Event Graph: spawn muzzle flash, play sound, add recoil.
5. Implement OnReloadStarted: play the reload montage.

Boundary Guidelines

Principles that keep the C++/Blueprint boundary healthy as a project grows:

💡 The guiding question: for each piece of a feature, ask "should a designer be able to change this without a programmer, and without being able to break the rules?" If yes → expose it (property or cosmetic event). If it's a rule that must always hold → keep it in C++. Draw the boundary there, and your C++ empowers designers instead of fighting them.

Hands-on Exercise & Quiz

Summary

📚 Additional Resources

• Using C++ and Blueprints Together (Epic)
• Gameplay Classes (Epic)

🚀 What's Next?

Module 6 — the heart of the course — is complete. You can now make C++ and Blueprint one seamless workflow. Module 7 takes the data-driven idea further: DataTables, DataAssets, config, saving/loading, and Subsystems — driving whole games from data.