Unreal Engine Cpp Pro

1---
2name: unreal-engine-cpp-pro
3description: Expert guide for Unreal Engine 5.x C++ development, covering UObject hygiene, performance patterns, and best practices.
4risk: safe
5source: self
6---
7 
8# Unreal Engine C++ Pro
9 
10This skill provides expert-level guidelines for developing with Unreal Engine 5 using C++. It focuses on writing robust, performant, and standard-compliant code.
11 
12## When to Use
13 
14Use this skill when:
15- Developing C++ code for Unreal Engine 5.x projects
16- Writing Actors, Components, or UObject-derived classes
17- Optimizing performance-critical code in Unreal Engine
18- Debugging memory leaks or garbage collection issues
19- Implementing Blueprint-exposed functionality
20- Following Epic Games' coding standards and conventions
21- Working with Unreal's reflection system (UCLASS, USTRUCT, UFUNCTION)
22- Managing asset loading and soft references
23 
24Do not use this skill when:
25- Working with Blueprint-only projects (no C++ code)
26- Developing for Unreal Engine versions prior to 5.x
27- Working on non-Unreal game engines
28- The task is unrelated to Unreal Engine development
29 
30## Core Principles
31 
321.  **UObject & Garbage Collection**:
33    *   Always use `UPROPERTY()` for `UObject*` member variables to ensure they are tracked by the Garbage Collector (GC).
34    *   Use `TStrongObjectPtr<>` if you need to keep a root reference outside of a UObject graph, but prefer `addToRoot()` generally.
35    *   Understand the `IsValid()` check vs `nullptr`. `IsValid()` handles pending kill state safely.
36 
372.  **Unreal Reflection System**:
38    *   Use `UCLASS()`, `USTRUCT()`, `UENUM()`, `UFUNCTION()` to expose types to the reflection system and Blueprints.
39    *   Minimize `BlueprintReadWrite` when possible; prefer `BlueprintReadOnly` for state that shouldn't be trampled by logic in UI/Level BPs.
40 
413.  **Performance First**:
42    *   **Tick**: Disable Ticking (`bCanEverTick = false`) by default. Only enable it if absolutely necessary. Prefer timers (`GetWorldTimerManager()`) or event-driven logic.
43    *   **Casting**: Avoid `Cast<T>()` in hot loops. Cache references in `BeginPlay`.
44    *   **Structs vs Classes**: Use `F` structs for data-heavy, non-UObject types to reduce overhead.
45 
46## Naming Conventions (Strict)
47 
48Follow Epic Games' coding standard:
49 
50*   **Templates**: Prefix with `T` (e.g., `TArray`, `TMap`).
51*   **UObject**: Prefix with `U` (e.g., `UCharacterMovementComponent`).
52*   **AActor**: Prefix with `A` (e.g., `AMyGameMode`).
53*   **SWidget**: Prefix with `S` (Slate widgets).
54*   **Structs**: Prefix with `F` (e.g., `FVector`).
55*   **Enums**: Prefix with `E` (e.g., `EWeaponState`).
56*   **Interfaces**: Prefix with `I` (e.g., `IInteractable`).
57*   **Booleans**: Prefix with `b` (e.g., `bIsDead`).
58 
59## Common Patterns
60 
61### 1. Robust Component Lookup
62Avoid `GetComponentByClass` in `Tick`. Do it in `PostInitializeComponents` or `BeginPlay`.
63 
64```cpp
65void AMyCharacter::PostInitializeComponents() {
66    Super::PostInitializeComponents();
67    HealthComp = FindComponentByClass<UHealthComponent>();
68    check(HealthComp); // Fail hard in dev if missing
69}
70```
71 
72### 2. Interface Implementation
73Use interfaces to decouple systems (e.g., Interaction system).
74 
75```cpp
76// Interface call check
77if (TargetActor->Implements<UInteractable>()) {
78    IInteractable::Execute_OnInteract(TargetActor, this);
79}
80```
81 
82### 3. Async Loading (Soft References)
83Avoid hard references (`UPROPERTY(EditDefaultsOnly) TSubclassOf<AActor>`) for massive assets which force load orders. Use `TSoftClassPtr` or `TSoftObjectPtr`.
84 
85```cpp
86UPROPERTY(EditAnywhere, BlueprintReadWrite)
87TSoftClassPtr<AWeapon> WeaponClassToLoad;
88 
89void AMyCharacter::Equip() {
90    if (WeaponClassToLoad.IsPending()) {
91        WeaponClassToLoad.LoadSynchronous(); // Or use StreamableManager for async
92    }
93}
94```
95 
96## Debugging
97 
98*   **Logging**: Use `UE_LOG` with custom categories.
99    ```cpp
100    DEFINE_LOG_CATEGORY_STATIC(LogMyGame, Log, All);
101    UE_LOG(LogMyGame, Warning, TEXT("Health is low: %f"), CurrentHealth);
102    ```
103*   **Screen Messages**:
104    ```cpp
105    if (GEngine) GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Died!"));
106    ```
107*   **Visual Logger**: extremely useful for AI debugging. Implement `IVisualLoggerDebugSnapshotInterface`.
108 
109## Checklist before PR
110 
111- [ ] Does this Actor need to Tick? Can it be a Timer?
112- [ ] Are all `UObject*` members wrapped in `UPROPERTY`?
113- [ ] Are hard references (TSubclassOf) causing load chains? Can they be Soft Ptrs?
114- [ ] Did you clean up verified delegates in `EndPlay`?
115