Index of every page on this site: llms.txt
All skills
gamedev-skills avatar

/unreal-cpp-gameplay

@c6ca6c4
Run it yourself

Unreal Engine 5 (UE 5.8) C++ gameplay code: UCLASS and UPROPERTY reflection, the Gameplay Framework, GC-safe pointers, Build.cs and command-line builds. Use for GENERATED_BODY, Live Coding, "unresolved external symbol" or UHT errors. Not for Blueprints (`unreal-blueprints`), Enhanced Input (`unreal-enhanced-input`) or packaging (`unreal-packaging`); engine source builds are out of scope.

Use this Skill: https://skilld.dev/gh/gamedev-skills/awesome-gamedev-agent-skills/unreal-cpp-gameplay

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈103 tokens for metadata: the name and description. ≈2.2k when used: this file. ≈1.2k more on demand in 1 file.

Description uses 5.1% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈412 characters, or 5.1%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Unreal C++ Gameplay

Write UE5 gameplay C++ that compiles the first time, survives garbage collection and is testable from a terminal. Targets UE 5.8.

When to use

  • Creating or fixing C++ gameplay classes (AActor, APawn, ACharacter, AGameModeBase, UActorComponent), reflection macros, or a module's *.Build.cs.
  • Diagnosing compile, UHT, linker or Live Coding problems, and crashes from freed UObjects.
  • Writing C++ automation tests and running them headless.

When not to use: designer-facing visual logic → unreal-blueprints. Input assets and bindings → unreal-enhanced-input. Behavior Trees and EQS → unreal-behavior-trees. Cooking and packaging → unreal-packaging. Building Unreal Engine itself from source is not covered; follow Epic's source-build instructions for the engine's GitHub repository.

Workflow

  1. Read the project. EngineAssociation in the .uproject gives the engine version; the Modules list and Source/<Module>/<Module>.Build.cs give module names and dependencies; existing base classes in Source/ tell you what to extend. Match the existing API macro (MYGAME_API) and folder layout (Public/, Private/).
  2. Declare reflected types correctly. The prefix matches the base (A actors, U other UObjects and components, F structs, E enums, I interfaces). GENERATED_BODY() is the first line in the body and #include "Name.generated.h" is the last include.
  3. Make every UObject pointer GC-visible. Members that hold a UObject are UPROPERTY() with TObjectPtr<T>; non-owning references are TWeakObjectPtr<T>. This is the most common source of random crashes.
  4. Create default components in the constructor with CreateDefaultSubobject, attach with SetupAttachment, and set RootComponent. Runtime components use NewObject plus RegisterComponent.
  5. Put logic where the framework expects it. Rules and default classes in the GameMode (server only), per-player state in PlayerState, input and UI ownership in the PlayerController, the body in the Pawn or Character, reusable behavior in components.
  6. Add module dependencies to PublicDependencyModuleNames (or Private... when only the .cpp files use them) whenever you include another module's headers, for example EnhancedInput, AIModule, Niagara, UMG.
  7. Build and test from the command line (see Verify). Use Live Coding (Ctrl+Alt+F11) only for function-body edits while the editor is open.

Patterns

Reflected actor with a GC-safe component

// Pickup.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Pickup.generated.h"            // last include

UCLASS()
class MYGAME_API APickup : public AActor
{
    GENERATED_BODY()
public:
    APickup();

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Pickup")
    int32 ScoreValue = 10;

    UFUNCTION(BlueprintCallable, Category = "Pickup")
    void Collect();

protected:
    UPROPERTY(VisibleAnywhere)
    TObjectPtr<UStaticMeshComponent> Mesh;  // UPROPERTY keeps it alive and visible to the editor
};

A C++ automation test

// Source/MyGame/Private/Tests/ScoreTests.cpp
#include "Misc/AutomationTest.h"

#if WITH_DEV_AUTOMATION_TESTS
IMPLEMENT_SIMPLE_AUTOMATION_TEST(FScoreAddsTest, "MyGame.Score.Adds",
    EAutomationTestFlags::EditorContext | EAutomationTestFlags::ProductFilter)

bool FScoreAddsTest::RunTest(const FString& Parameters)
{
    FScoreBoard Board;                       // plain logic: no world needed
    Board.Add(10);
    TestEqual(TEXT("score after one add"), Board.Total(), 10);
    return true;                             // failed Test* calls still mark the test failed
}
#endif

Keep testable rules in plain structs or functions so most tests need no world; use functional tests in a test map for behavior that needs actors.

Verify

Say which of these you ran and paste the relevant result lines; "it should compile" is not a check.

  1. Compile the editor target with the editor closed: Engine/Build/BatchFiles/Build.bat <Project>Editor Win64 Development -Project="<abs path>.uproject" -WaitMutex (Linux: Engine/Build/BatchFiles/Linux/Build.sh <Project>Editor Linux Development ...; macOS: Engine/Build/BatchFiles/Mac/Build.sh <Project>Editor Mac Development ...). Fix every error and every warning in files you touched.
  2. Run the tests headless: UnrealEditor-Cmd <Project>.uproject -ExecCmds="Automation RunTest MyGame;Quit" -unattended -nullrhi -nosplash -ReportExportPath="<dir>". RunTest takes a full name, a dotted prefix, Test1+Test2, or Group:<name>. Read the JSON report or the Test Completed lines in the log, and confirm the expected tests ran: a wrong filter runs nothing and still looks clean.
  3. When behavior needs a person, ask the user to open the editor, check that the new class and its properties appear, run PIE, and report the Output Log lines for your category.
  4. Optional: with Epic's unreal-mcp skill connected to a running editor, its testing toolset can discover and run automation tests and return detailed results.

Gotchas

  • "Cannot open include file ...generated.h" or UHT errors: the generated include isn't last, GENERATED_BODY() is missing, or the file was added while the editor ran and project files weren't regenerated.
  • Unresolved external symbol: the module that defines the symbol isn't in Build.cs. Find the header's path under Engine/Source/ or Engine/Plugins/ to get the module name.
  • Random crash on a pointer that "was valid": a raw UObject* member without UPROPERTY, or a container of them, so GC freed the object. IsValid() on a dangling raw pointer does not save you.
  • Live Coding after header changes: new UPROPERTYs or functions rely on Object Reinstancing, which is on by default but less reliable; pointers cached to reinstanced objects go stale. If the editor or Blueprints misbehave afterwards, close the editor and do a full build.
  • Building from the IDE or command line while the editor runs: with Live Coding active the build is refused or fights the editor's loaded modules. Close the editor first, or compile through Live Coding.
  • CreateDefaultSubobject outside the constructor: asserts. At runtime use NewObject and RegisterComponent, otherwise the component never ticks or renders.
  • Overrides that skip Super:: (BeginPlay, Tick, EndPlay, GetLifetimeReplicatedProps) silently skip engine setup.
  • GameMode logic on a client: the GameMode exists only on the server. Use GameState or PlayerState for data clients must see.

References

  • Read references/components-and-gc.md when creating or attaching components at runtime, choosing between TObjectPtr, TWeakObjectPtr, TStrongObjectPtr and FGCObject, adding USTRUCT/UENUM data, or replicating a property with OnRep_.
  • Epic docs: Gameplay Framework, Write C++ Tests, Run Automation Tests.

Related skills

  • unreal-blueprints: exposing C++ to designers.
  • unreal-enhanced-input: binding input in a C++ Pawn or Character.
  • unreal-behavior-trees: AIControllers and custom BT nodes.
  • unreal-packaging: cooking and shipping the build.

Version notes

Last verified: 2026-11-11.

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts8d3 checks · Risk SAFE
  • Gen Agent Trust Hub9d

    The skill provides patterns and workflows for Unreal Engine C++ development. It includes standard commands for building and testing code with the Unreal Engine toolset. A low-risk surface for indirect prompt injection exists because the skill processes external project files without explicit sanitization.

  • Socket8d

    No alerts

  • Snyk9d

    Risk: LOW · No issues

Signed by skilld at c6ca6c4. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated last week

README badge

README badge for gamedev-skills/awesome-gamedev-agent-skills/unreal-cpp-gameplay