Unreal Engine Cpp Pro

#include "ExampleActor.h"
#include "Components/BoxComponent.h"
#include "Kismet/GameplayStatics.h"

// Define a static log category for this specific file/module
DEFINE_LOG_CATEGORY_STATIC(LogExampleActor, Log, All);

AExampleActor::AExampleActor()
{
    // Default to strict settings
    PrimaryActorTick.bCanEverTick = false; 
    PrimaryActorTick.bStartWithTickEnabled = false;

    RootCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("RootCollision"));
    RootComponent = RootCollision;
    
    bIsActive = true;
}

void AExampleActor::BeginPlay()
{
    Super::BeginPlay();
    
    // Cache references here, not in Tick
    CachedPC = UGameplayStatics::GetPlayerController(this, 0);

    if (bIsActive)
    {
        UE_LOG(LogExampleActor, Log, TEXT("ExampleActor %s started!"), *GetName());
    }
}

void AExampleActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    // Clean up any strict delegates or handles here
    Super::EndPlay(EndPlayReason);
}

void AExampleActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    // Ticking is disabled by default in constructor, so this won't run unless enabled explicitly.
}


#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ExampleActor.generated.h"

// Forward overrides to reduce compile times
class UBoxComponent;

/**
 * AExampleActor
 * 
 * Demonstrates:
 * 1. Correct class prefix (A)
 * 2. UPROPERTY usage
 * 3. Soft references for assets
 */
UCLASS()
class MYGAME_API AExampleActor : public AActor
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this actor's properties
    AExampleActor();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
    
    // Called when the game ends
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    /** Component exposed to Blueprint, but immutable logic in C++ */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
    UBoxComponent* RootCollision;

    /** 
     * Soft reference to an actor class to lazy load.
     * Prevents hard reference chains.
     */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
    TSoftClassPtr<AActor> ActorTypeToSpawn;

    /** Proper boolean naming convention 'b' */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "State")
    uint8 bIsActive:1;

private:
    /** Cached reference, not exposed to Blueprints */
    UPROPERTY(Transient)
    APlayerController* CachedPC;
};


---
name: unreal-engine-cpp-pro
description: "Expert guide for Unreal Engine 5.x C++ development, covering UObject hygiene, performance patterns, and best practices."
risk: safe
source: self
date_added: "2026-02-27"
---

# Unreal Engine C++ Pro

This skill provides expert-level guidelines for developing with Unreal Engine 5 using C++. It focuses on writing robust, performant, and standard-compliant code.

## When to Use
Use this skill when:
- Developing C++ code for Unreal Engine 5.x projects
- Writing Actors, Components, or UObject-derived classes
- Optimizing performance-critical code in Unreal Engine
- Debugging memory leaks or garbage collection issues
- Implementing Blueprint-exposed functionality
- Following Epic Games' coding standards and conventions
- Working with Unreal's reflection system (UCLASS, USTRUCT, UFUNCTION)
- Managing asset loading and soft references

Do not use this skill when:
- Working with Blueprint-only projects (no C++ code)
- Developing for Unreal Engine versions prior to 5.x
- Working on non-Unreal game engines
- The task is unrelated to Unreal Engine development

## Core Principles

1.  **UObject & Garbage Collection**:
    *   Always use `UPROPERTY()` for `UObject*` member variables to ensure they are tracked by the Garbage Collector (GC).
    *   Use `TStrongObjectPtr<>` if you need to keep a root reference outside of a UObject graph,