# Unreal Engine Cpp Pro > Expert guide for Unreal Engine 5.x C++ development, covering UObject hygiene, performance patterns, and best practices. Use when this capability is needed. - Skill: `tomevault-io/unreal-engine-cpp-pro-2` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add tomevault-io/unreal-engine-cpp-pro-2` - Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/unreal-engine-cpp-pro-2/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - Author: tomevault-io (https://skillmd.com/u/tomevault-io) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/tomevault-io/unreal-engine-cpp-pro-2 --- # 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, but prefer `addToRoot()` generally. * Understand the `IsValid()` check vs `nullptr`. `IsValid()` handles pending kill state safely. 2. **Unreal Reflection System**: * Use `UCLASS()`, `USTRUCT()`, `UENUM()`, `UFUNCTION()` to expose types to the reflection system and Blueprints. * Minimize `BlueprintReadWrite` when possible; prefer `BlueprintReadOnly` for state that shouldn't be trampled by logic in UI/Level BPs. 3. **Performance First**: * **Tick**: Disable Ticking (`bCanEverTick = false`) by default. Only enable it if absolutely necessary. Prefer timers (`GetWorldTimerManager()`) or event-driven logic. * **Casting**: Avoid `Cast()` in hot loops. Cache references in `BeginPlay`. * **Structs vs Classes**: Use `F` structs for data-heavy, non-UObject types to reduce overhead. ## Naming Conventions (Strict) Follow Epic Games' coding standard: * **Templates**: Prefix with `T` (e.g., `TArray`, `TMap`). * **UObject**: Prefix with `U` (e.g., `UCharacterMovementComponent`). * **AActor**: Prefix with `A` (e.g., `AMyGameMode`). * **SWidget**: Prefix with `S` (Slate widgets). * **Structs**: Prefix with `F` (e.g., `FVector`). * **Enums**: Prefix with `E` (e.g., `EWeaponState`). * **Interfaces**: Prefix with `I` (e.g., `IInteractable`). * **Booleans**: Prefix with `b` (e.g., `bIsDead`). ## Common Patterns ### 1. Robust Component Lookup Avoid `GetComponentByClass` in `Tick`. Do it in `PostInitializeComponents` or `BeginPlay`. ```cpp void AMyCharacter::PostInitializeComponents() { Super::PostInitializeComponents(); HealthComp = FindComponentByClass(); check(HealthComp); // Fail hard in dev if missing } ``` ### 2. Interface Implementation Use interfaces to decouple systems (e.g., Interaction system). ```cpp // Interface call check if (TargetActor->Implements()) { IInteractable::Execute_OnInteract(TargetActor, this); } ``` ### 3. Async Loading (Soft References) Avoid hard references (`UPROPERTY(EditDefaultsOnly) TSubclassOf`) for massive assets which force load orders. Use `TSoftClassPtr` or `TSoftObjectPtr`. ```cpp UPROPERTY(EditAnywhere, BlueprintReadWrite) TSoftClassPtr WeaponClassToLoad; void AMyCharacter::Equip() { if (WeaponClassToLoad.IsPending()) { WeaponClassToLoad.LoadSynchronous(); // Or use StreamableManager for async } } ``` ## Debugging * **Logging**: Use `UE_LOG` with custom categories. ```cpp DEFINE_LOG_CATEGORY_STATIC(LogMyGame, Log, All); UE_LOG(LogMyGame, Warning, TEXT("Health is low: %f"), CurrentHealth); ``` * **Screen Messages**: ```cpp if (GEngine) GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Died!")); ``` * **Visual Logger**: extremely useful for AI debugging. Implement `IVisualLoggerDebugSnapshotInterface`. ## Checklist before PR - [ ] Does this Actor need to Tick? Can it be a Timer? - [ ] Are all `UObject*` members wrapped in `UPROPERTY`? - [ ] Are hard references (TSubclassOf) causing load chains? Can they be Soft Ptrs? - [ ] Did you clean up verified delegates in `EndPlay`? --- ## AGI Framework Integration > **Adapted for [@techwavedev/agi-agent-kit](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)** > Original source: [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills) ### Memory-First Protocol Cache workflow configurations and automation patterns. Retrieve prior pipeline designs to avoid re-building similar flows from scratch. ```bash # Check for prior workflow/automation context before starting python3 execution/memory_manager.py auto --query "automation patterns and workflow configurations for Unreal Engine Cpp Pro" ``` ### Storing Results After completing work, store workflow/automation decisions for future sessions: ```bash python3 execution/memory_manager.py store \ --content "Workflow: automated data pipeline with retry logic, dead-letter queue, and Slack alerts on failure" \ --type technical --project \ --tags unreal-engine-cpp-pro workflow ``` ### Multi-Agent Collaboration Share workflow state with other agents so they can trigger, monitor, or extend the automation. ```bash python3 execution/cross_agent_context.py store \ --agent "" \ --action "Workflow automation deployed — pipeline processing 1000+ events/day with 99.9% success rate" \ --project ``` ### Playbook Engine Combine this skill with others using the Playbook Engine (`execution/workflow_engine.py`) for guided multi-step automation with progress tracking. --- > Converted and distributed by [TomeVault](https://tomevault.io/claim/techwavedev) — claim your Tome and manage your conversions.