🔍 Lesson 2.6: Logging, Assertions & Debugging C++

UE_LOG & Verbosity

UE_LOG is Unreal's printf. It writes to the Output Log and the log file, tagged with a category and a verbosity.

// UE_LOG(Category, Verbosity, Format, Args...)
UE_LOG(LogTemp, Warning, TEXT("Player %s took %.1f damage"), *GetName(), Damage);

Custom Log Categories

LogTemp is fine for quick tests, but real projects define their own categories so you can filter your game's logs away from the engine's firehose.

Declare the category in a header (often a shared one) and define it once in a .cpp:

// MyGameLog.h — declare the category
#pragma once
#include "CoreMinimal.h"

// Args: category name, default verbosity, compiled-in max verbosity
DECLARE_LOG_CATEGORY_EXTERN(LogMyGame, Log, All);

// MyGameLog.cpp — define it exactly once
#include "MyGameLog.h"

DEFINE_LOG_CATEGORY(LogMyGame);

// Anywhere that includes MyGameLog.h:
UE_LOG(LogMyGame, Log, TEXT("Wave %d started with %d enemies"), WaveNumber, Count);

On-Screen Messages

Sometimes you want feedback right in the viewport without hunting the log. GEngine->AddOnScreenDebugMessage prints to the screen during play.

if (GEngine)
{
    // Args: key (-1 = always add new), time on screen (s), color, message
    GEngine->AddOnScreenDebugMessage(
        -1, 5.0f, FColor::Green,
        FString::Printf(TEXT("Ammo: %d"), CurrentAmmo));
}

check, ensure, verify

Assertions catch "this must be true" conditions at the exact point they break, instead of letting a bad value propagate into a confusing crash later. Unreal has three families with different behavior:

// check: an invariant that must hold — if not, we WANT to stop now.
check(MaxHealth > 0);   // a zero/negative max health is a design bug

// ensure: "shouldn't happen, but let's survive and get told about it."
if (ensure(Weapon != nullptr))
{
    Weapon->Fire();     // only runs if the ensure passed
}

// checkf / ensureMsgf: same, with a formatted message
checkf(Ammo >= 0, TEXT("Ammo went negative: %d"), Ammo);

Debug Drawing

Much game logic is spatial — a trace, a radius, a direction. Debug drawing renders temporary shapes in the world so you can see what your math is doing. Include DrawDebugHelpers.h.

#include "DrawDebugHelpers.h"

// A line from the actor forward 500 units, red, lasting 2 seconds:
const FVector Start = GetActorLocation();
const FVector End   = Start + GetActorForwardVector() * 500.0f;
DrawDebugLine(GetWorld(), Start, End, FColor::Red, false, 2.0f);

// A sphere showing an interaction radius:
DrawDebugSphere(GetWorld(), Start, 200.0f, 16, FColor::Green, false, 2.0f);

// A labeled point:
DrawDebugPoint(GetWorld(), End, 12.0f, FColor::Blue, false, 2.0f);

💡 You'll rely on this in Module 5. When we do traces and overlaps, debug drawing is how you confirm the trace actually goes where you think. It turns "why isn't this hitting?" into an obvious picture. These draws are development aids — strip or guard them out of shipping builds.

Hands-on Exercise & Quiz

void AWeapon::ApplyDamage(float Amount, AActor* Target)
{
    check(Amount >= 0.0f);
    if (!ensure(IsValid(Target))) { return; }

    UE_LOG(LogMyGame, Log, TEXT("%s took %.1f damage"),
        *Target->GetName(), Amount);

    DrawDebugSphere(GetWorld(), Target->GetActorLocation(),
        50.0f, 12, FColor::Red, false, 1.0f);

    // ... apply the damage ...
}

Summary

📚 Additional Resources

• Logging in Unreal Engine (Epic)
• Asserts: check, ensure, verify (Epic)

🚀 What's Next?

Module 2 is complete — you understand reflection, types, memory, and debugging, the foundation everything else stands on. Module 3 puts it to work: the gameplay framework, writing real Actors and Components in C++, and their lifecycles.