Ue Cpp Foundations

// MyCharacter.h#pragma once#include "CoreMinimal.h"#include "GameFramework/Character.h"#include "MyCharacter.generated.h"
class UStaticMeshComponent;class UStaticMesh;
UCLASS(Blueprintable)class MYGAME_API AMyCharacter : public ACharacter{    GENERATED_BODY()public:    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats", meta=(ClampMin="1.0"))    float MaxHealth = 100.f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Stats")    float CurrentHealth = 100.f;
    UPROPERTY(Transient)    TObjectPtr<UStaticMeshComponent> CachedMesh;     // not serialized, still GC-tracked
    UPROPERTY(EditDefaultsOnly, Category="Config")    TSubclassOf<AActor> ProjectileClass;             // class reference restricted to AActor subclasses    UPROPERTY(EditDefaultsOnly, Category="Config")    TSoftObjectPtr<UStaticMesh> LazyMesh;            // path reference; load on demand
    UFUNCTION(BlueprintNativeEvent, Category="Combat")    void OnDamageTaken(float Amount);    virtual void OnDamageTaken_Implementation(float Amount);};

// MyCharacter.cpp — the only body a BlueprintNativeEvent gets in C++void AMyCharacter::OnDamageTaken_Implementation(float Amount) { CurrentHealth = FMath::Max(0.f, CurrentHealth - Amount); }

// MyTypes.h#pragma once#include "CoreMinimal.h"#include "MyTypes.generated.h"
USTRUCT(BlueprintType)struct MYGAME_API FMyWeaponStats{    GENERATED_BODY()
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Weapon")    float BaseDamage = 10.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Weapon")    float FireRate = 0.5f;};
UENUM(BlueprintType)enum class EMyWeaponState : uint8      // Blueprint-visible enums are enum class : uint8{    Idle,    Firing    UMETA(DisplayName="Firing Weapon"),    MAX       UMETA(Hidden)};

TArray<FString> Names;Names.Add(TEXT("Alpha"));Names.Emplace(TEXT("Beta"));                       // construct in placeNames.Reserve(100);                                // pre-size before a known number of Addsint32 Idx = Names.Find(TEXT("Beta"));              // INDEX_NONE if absentFString* Ptr = Names.FindByPredicate([](const FString& S) { return S.StartsWith(TEXT("A")); });Names.Sort([](const FString& A, const FString& B) { return A.Len() < B.Len(); });Names.Remove(TEXT("Alpha"));                       // order-preserving, O(n)Names.RemoveAtSwap(0);                             // O(1), reordersfor (int32 i = Names.Num() - 1; i >= 0; --i) { if (Names[i].IsEmpty()) { Names.RemoveAt(i); } }  // never mutate inside ranged-for
TMap<FName, int32> ItemCounts;int32& Count = ItemCounts.FindOrAdd(FName("Sword"));  // inserts default if absentint32* Found = ItemCounts.Find(FName("Axe"));         // nullptr if absentfor (const TPair<FName, int32>& Pair : ItemCounts) { UE_LOG(LogMyGame, Log, TEXT("%s x%d"), *Pair.Key.ToString(), Pair.Value); }
TSet<FName> Tags;Tags.Add(FName("Flying"));bool bFlying = Tags.Contains(FName("Flying"));     // hashed, no duplicates
TOptional<float> MaybeHP;float Safe = MaybeHP.Get(0.f);                     // default when unset

#include "Misc/TVariant.h"#include <type_traits>
TVariant<int32, float, FString> Value;             // first type must be default-constructible (or use FEmptyVariantState)Value.Set<FString>(TEXT("Hello"));if (const FString* Str = Value.TryGet<FString>()) { UE_LOG(LogMyGame, Log, TEXT("%s"), **Str); }
Visit([](auto& Held)                               // one generic lambda; branch with if constexpr{    using HeldType = std::decay_t<decltype(Held)>;    if constexpr (std::is_same_v<HeldType, FString>) { UE_LOG(LogMyGame, Log, TEXT("%s"), *Held); }}, Value);

// MyHealthComponent.h — delegate types are declared at file scope, above the UCLASSDECLARE_MULTICAST_DELEGATE_TwoParams(FOnMyHealthChangedNative, float /*Current*/, float /*Max*/);DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnMyHealthChanged, float, CurrentHealth, float, MaxHealth);
// in UMyHealthComponent : public UActorComponentUPROPERTY(BlueprintAssignable, Category="Health")FOnMyHealthChanged OnHealthChanged;               // dynamic: needs UPROPERTY, params need namesFOnMyHealthChangedNative OnHealthChangedNative;   // native: no reflection, cheaper to broadcast
// in AMyListenerActor : public AActorUFUNCTION()                                       // AddDynamic targets must be UFUNCTIONsvoid HandleHealthChanged(float CurrentHealth, float MaxHealth);void HandleHealthChangedNative(float Current, float Max);UPROPERTY() TObjectPtr<UMyHealthComponent> Health;FDelegateHandle NativeHandle;

// AMyListenerActor.cpp — bind in BeginPlay (after Super::), unbind in EndPlay (before Super::)Health->OnHealthChanged.AddDynamic(this, &AMyListenerActor::HandleHealthChanged);NativeHandle = Health->OnHealthChangedNative.AddUObject(this, &AMyListenerActor::HandleHealthChangedNative);// EndPlay: guard with IsValid(Health) firstHealth->OnHealthChanged.RemoveDynamic(this, &AMyListenerActor::HandleHealthChanged);Health->OnHealthChangedNative.Remove(NativeHandle);

float Health = 42.f; int32 Current = 3; int32 Max = 5;
FName   Tag(TEXT("Weapon.Rifle"));FString S    = Tag.ToString();FName   Back = FName(*S);FString Msg  = FString::Printf(TEXT("HP: %.1f (%d/%d)"), Health, Current, Max);int32 Parsed = FCString::Atoi(TEXT("42"));
#define LOCTEXT_NAMESPACE "MyGame"FText Label = LOCTEXT("RifleName", "Assault Rifle");FText Fmt   = FText::Format(LOCTEXT("HPFmt", "HP: {0}/{1}"), FText::AsNumber(Current), FText::AsNumber(Max));#undef LOCTEXT_NAMESPACEFText Other = NSLOCTEXT("MyGame", "Key", "Text");   // no #define neededFText Raw   = FText::FromString(S);                 // not localized; runtime-generated text only

// Reflected members: TObjectPtr — GC-tracked, access-tracked in the editor, used like a raw pointerUPROPERTY() TObjectPtr<UStaticMeshComponent> MeshComp;
// Legacy APIs that want raw pointersvoid FillObjects(TArray<UObject*>& Out);TArray<TObjectPtr<UObject>> Objects;FillObjects(MutableView(Objects));                       // temporary TArray<UObject*>& view; ToRawPtr(Ptr) for a single read-only copy
// Non-owning reference: TWeakObjectPtr becomes null once the object is destroyed or collectedTWeakObjectPtr<AMyCharacter> WeakTarget;if (AMyCharacter* Target = WeakTarget.Get()) { Target->OnDamageTaken(5.f); }
// Keep-alive from non-reflected code: scoped root instead of AddToRoot()/RemoveFromRoot()TStrongObjectPtr<UMyDataObject> Pinned(NewObject<UMyDataObject>());
// Plain C++ types only: never wrap a UObject in TSharedPtr/TUniquePtrstruct FMyData { int32 Score = 0; };TSharedPtr<FMyData> Data = MakeShared<FMyData>();TWeakPtr<FMyData>   WeakData = Data;                     // Pin() returns a TSharedPtr if still alive

#include "UObject/GCObject.h"
class FMyManager : public FGCObject{public:    virtual void AddReferencedObjects(FReferenceCollector& Collector) override { Collector.AddReferencedObject(ManagedObject); }    virtual FString GetReferencerName() const override { return TEXT("FMyManager"); }private:    TObjectPtr<UMyDataObject> ManagedObject;   // TObjectPtr<T>& overload; raw UObject* is deprecated};

#include "Misc/NotNull.h"
const UMyDataObject* Defaults = GetDefault<UMyDataObject>();        // class default object, read-onlyUMyDataObject*       Settings = GetMutableDefault<UMyDataObject>(); // settings-style objectsUClass* SomeClass = AMyCharacter::StaticClass();const AMyCharacter* ClassCDO = SomeClass->GetDefaultObject<AMyCharacter>();  // CDO of a runtime UClass
// TNotNull<T*>: caller cannot pass null; checked at the call site in Debug/Development, a plain pointer in Test and Shippingvoid RegisterOwner(TNotNull<AActor*> Owner);void RegisterOwner(TNotNull<AActor*> Owner){    Owner->SetActorHiddenInGame(false);   // no null check needed inside}

// MyInventorySubsystem.h#pragma once#include "CoreMinimal.h"#include "Subsystems/GameInstanceSubsystem.h"#include "MyInventorySubsystem.generated.h"
UCLASS()class MYGAME_API UMyInventorySubsystem : public UGameInstanceSubsystem{    GENERATED_BODY()public:    virtual void Initialize(FSubsystemCollectionBase& Collection) override;    virtual void Deinitialize() override;
    UFUNCTION(BlueprintCallable, Category="Inventory")    void AddItem(FName ItemID, int32 Count);private:    TMap<FName, int32> Inventory;};
// A ticking world subsystem adds these; Initialize/Deinitialize must call Super:: (the base registers the ticker)UCLASS()class MYGAME_API UMyTickableSubsystem : public UTickableWorldSubsystem{    GENERATED_BODY()public:    virtual void Tick(float DeltaTime) override;    virtual TStatId GetStatId() const override { RETURN_QUICK_DECLARE_CYCLE_STAT(UMyTickableSubsystem, STATGROUP_Tickables); }    virtual bool DoesSupportWorldType(const EWorldType::Type WorldType) const override;  // e.g. Game and PIE only};

// Access from an AActor member functionUMyInventorySubsystem* Inv = GetGameInstance()->GetSubsystem<UMyInventorySubsystem>();UMyTickableSubsystem*  Tck = GetWorld()->GetSubsystem<UMyTickableSubsystem>();APlayerController*     PC  = GetWorld()->GetFirstPlayerController();UMyUISubsystem*        UI  = ULocalPlayer::GetSubsystemFromController<UMyUISubsystem>(PC);   // null-safeUMyEngineSubsystem*    Eng = GEngine->GetEngineSubsystem<UMyEngineSubsystem>();

// MyReplicatedActor.h#pragma once#include "CoreMinimal.h"#include "GameFramework/Actor.h"#include "MyReplicatedActor.generated.h"
UCLASS()class MYGAME_API AMyReplicatedActor : public AActor{    GENERATED_BODY()public:    AMyReplicatedActor() { bReplicates = true; }    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;protected:    UPROPERTY(ReplicatedUsing=OnRep_Health)    float Health = 100.f;
    UFUNCTION()    void OnRep_Health();                 // runs on clients after Health changes};

// MyReplicatedActor.cpp#include "MyReplicatedActor.h"#include "Net/UnrealNetwork.h"          // required for DOREPLIFETIME
void AMyReplicatedActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const{    Super::GetLifetimeReplicatedProps(OutLifetimeProps);    DOREPLIFETIME(AMyReplicatedActor, Health);}
void AMyReplicatedActor::OnRep_Health() {}

DECLARE_LOG_CATEGORY_EXTERN(LogMyGame, Log, All);   // MyGame.h (module header)DEFINE_LOG_CATEGORY(LogMyGame);                     // MyGame.cppUE_LOG(LogMyGame, Warning, TEXT("HP low: %.1f"), 12.5f);

#if WITH_EDITORONLY_DATA    UPROPERTY(EditAnywhere, Category="Debug")    bool bShowDebugSpheres = false;                 // reflected editor-only data#endif#if WITH_EDITOR    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;   // editor-only code#endif#if !UE_BUILD_SHIPPING    void DrawDebugInfo();                           // Debug, Development and Test only#endif

UMyDataObject* Obj;                        // WRONG: invisible to GCUPROPERTY() TObjectPtr<UMyDataObject> Obj; // RIGHT

TArray<AActor*> Actors;for (AActor* A : Actors) { Actors.Remove(A); }                                                      // WRONGfor (int32 i = Actors.Num() - 1; i >= 0; --i) { if (!IsValid(Actors[i])) { Actors.RemoveAt(i); } }  // RIGHT