Ein langfristiges Engineering-Projekt · ein neuer Standard, von Grund auf entwickelt

UE C++ Academy — kein Nachschlagewerk, sondern eine Ingenieurschule für die Unreal Engine

Jedes Thema erklärt nicht "was man benutzt", sondern "warum es existiert", "welches Problem es löst", "wie es intern funktioniert" und "wann man es nicht tun sollte". Das Ziel ist, dass nach der Lektüre eines Themas keine logische Frage offenbleibt und du lernst, selbst zu Epics architektonischen Entscheidungen zu gelangen, statt sie als Faktenliste auswendig zu lernen.

Wie jedes Thema aufgebaut ist

Ein flexibler Standard: 11 Pflichtabschnitte für jedes Thema + Abschnitte, die automatisch erscheinen, wenn das Thema sie natürlich hervorbringt — ohne künstliche Punkte wie "Auswirkung auf Multiplayer" in einem Artikel über const.

Was ist das?

Eine kurze Orientierung vor dem tiefen Einstieg.

Warum existiert es?

Problem → Ursache, keine Tatsache ohne Kontext.

Welches Problem löst es?

Ein konkretes, reproduzierbares Szenario, in dem der naive Ansatz scheitert.

Wie funktioniert es?

Randbedingungen → architektonische Lösung → Implementierung, mit Beispielen aus dem Engine-Quellcode.

Wann verwenden / nicht verwenden

Grenzen der Anwendbarkeit — ohne sie entsteht Cargo-Cult.

Beispiele

Vollständig funktionierender Code mit zeilenweiser Erklärung — Pseudocode ist verboten.

Typische Fehler

Getrennt für Einsteiger und Mid-Level-Entwickler, mit Erklärung des Fehlermechanismus.

Übung

Aufgaben, die dich zwingen, die Argumentation zu reproduzieren, nicht nur das Beispiel zu kopieren.

FAQ

Fragen, die einem aufmerksamen Leser tatsächlich kommen.

Zusammenfassung

Aussagen, die der Leser in eigenen Worten formulieren können sollte.

+ nach Bedarf

GC, Reflection, Blueprint, Multiplayer, Serialisierung, Performance — wenn das Thema sie natürlich hervorbringt.

Bevor du beginnst

Ein Kompass über den gesamten Kurs — kein einzelnes Thema, sondern eine Denkweise, die sich in jedem weiteren Thema wiederholt.

💡

Wie die Unreal Engine denkt — Engine-Philosophie

Zwölf übergreifende "Warums" (UObject, Zeiger, GC, Reflection, Component, Composition, Modules, Plugins, Subsystem, Gameplay Tags, Data Assets, Primary Assets) an einem Ort — lies diese Seite zuerst, und danach wird jedes neue Kursthema als Variante einer vertrauten Argumentationslinie erkannt, statt als neue Faktenmenge.

Referenzartikel

Der Goldstandard für Qualität und Tiefe des gesamten Projekts — es lohnt sich, hier zu beginnen, selbst wenn du bereits erfahrener Entwickler bist.

★

Wie die Unreal Engine funktioniert: keine API, sondern Engineering-Denken

Engine → Framework → warum UObject → warum Reflection → warum Garbage Collector → warum Makros entstanden → wie sich alles zu einer einzigen Kausalkette verbindet. Nach diesem Artikel werden die restlichen Kursthemen nicht als einzelne Fakten gelesen, sondern als Anwendungen derselben Denkweise.

Roadmap — 9 Level

Neun aufeinanderfolgende Level statt sechzehn getrennter Cluster — jedes weitere Level wird durch das vorherige erklärt, nicht für sich allein. Die einzige Ausnahme ist Level 5: Seine sechs angewandten Systeme sind parallel, nicht sequentiell.

Level 0 — Wie Unreal denkt

Warum der Rest des Kurses existiert: wann Epics Dokumentation noch ausreicht, wann es Zeit ist, den Engine-Quellcode zu öffnen, und wie man sich physisch in .h/.cpp-Dateien zurechtfindet, noch bevor man weiß, was ein UObject ist.

Epic-Dokumentation: wann sie ausreicht Wie man eine Engine-.h-Datei liest Wie man Engine-.cpp liest Public/Private/Classes Wie man einer Abhängigkeit folgt

Level 1 — Objektsystem

Baut auf Level 0 auf — danach wird jedes UCLASS()/UPROPERTY() als konkrete Folge von Reflection, Garbage Collector, Package und CDO erklärt, nicht als magische Syntax.

UObject: Objektarchitektur Class Default Object (CDO) UObject::Outer Reflection Garbage Collector UPROPERTY UFUNCTION UINTERFACE EObjectFlags FName / FString / FText UPackage Asset Registry UStruct: die gemeinsame Basisklasse dahinter TSubclassOf<T> Cast<> vs dynamic_cast NewObject / CreateDefaultSubobject UObject im Speicher

Level 2 — Laufzeitobjekte

Baut auf dem Objektsystem auf — zuerst der Actor und seine Komponenten, und erst wenn die Frage "wie speichere ich die Liste der Komponenten" natürlich aufkommt, die Werkzeuge: TArray/TMap und die zwei sich nicht überschneidenden Zeigerwelten.

Actor-Lebenszyklus UActorComponent Transform und RootComponent Tick SpawnActor und Destroy Owner und GetOwner() TArray TMap und TSet TSharedPtr / TWeakObjectPtr / GC TSoftObjectPtr World Context Object TActorIterator Kollisionsarchitektur Line Trace, Sweep, Overlap Chaos Physics und Gameplay

Level 3 — Gameplay-Framework

Baut auf Level 2 auf — das vollständige Set der Framework-Rollen (Pawn/Controller/Character/GameMode/GameState/GameInstance/Subsystem) und Delegates als Werkzeug, bevor AI/UI/GAS sich stillschweigend darauf verlassen.

UWorld Pawn / Controller / PlayerState ACharacter vs APawn GameMode und GameState UGameInstance Subsysteme Delegates: Single/Multicast/Dynamic PlayerController von innen ULocalPlayer und GameViewportClient UGameplayStatics

Level 4 — Daten

Baut auf UObject und Soft References auf — wie man wachsenden Content als Daten beschreibt, nicht als Code, bevor GAS und AI darauf aufgebaut werden.

UDataAsset UDataTable UAssetManager FGameplayTag UPrimaryDataAsset UPROPERTY(Config) UDeveloperSettings

Level 5 — Systeme

Sechs parallele angewandte Systeme, keine Reihenfolge — die Abfolge zwischen 5.A–5.F ist nicht strikt, jedes baut nur auf den Levels 0–4 auf (und Network Prediction in GAS zusätzlich auf Level 6, Multiplayer).

5.A — Input

Wie die Gameplay-Absicht von der physischen Taste getrennt wird: Input Actions und Mapping Contexts statt fest codierter Action/Axis Mappings.

Enhanced Input EnhancedInputLocalPlayerSubsystem

5.B — UI

Wie man eine Oberfläche mit UMG baut, den Screen-Stack und Fokus mit CommonUI verwaltet und die direkte Verbindung zwischen Widget und Spielobjekten mit MVVM aufbricht.

UMG: UUserWidget CommonUI MVVM Slate: was hinter UMG steckt UUserWidget-Lebenszyklus CommonInput

5.C — Gameplay Ability System

Ein Fähigkeiten-Framework auf Basis von UFUNCTION: Networking, Abbruch, Ressourcenkosten und Effekt-Kompatibilität in einer zusammenhängenden Lösung — bis hin zur Network Prediction an der Schnittstelle zu Multiplayer.

GAS: warum ein Framework auf UFUNCTION AttributeSet GameplayEffect GameplayAbility: Lebenszyklus GameplayTags in GAS Network Prediction in GAS Execution Calculation GameplayModMagnitudeCalculation GameplayCue

5.D — KI

Wie die Entscheidung "was soll der NPC tun" als Baum wiederverwendbarer Knoten ausgedrückt wird, wie Tasks und Baum Daten über einen gemeinsamen Speicher austauschen, und wie man deklarativ den besten Punkt in der Welt findet.

Behavior Tree Blackboard Environment Query System AIPerceptionComponent NavMesh und Navigation System Smart Objects

5.E — World Streaming

Wie eine Spielwelt, die physisch nicht als Ganzes in den Speicher passt, in Teilen geladen wird: manuell, automatisch per Raster und mit logischen Ebenen obendrauf.

Level Streaming World Partition Data Layers PCG Framework Instanced Foliage HLOD Nanite Lumen

5.F — Animation

Wie die Logik der Skelett-Pose in ein eigenes Objekt mit eigenem Graph ausgelagert wird, wie Einmal-Aktionen über kontinuierlichem Blending abgespielt werden, und wie sich die Pose zur Laufzeit an die Geometrie anpasst.

UAnimInstance UAnimMontage Inverse Kinematik Animation State Machine Blend Space Linked Anim Layers Motion Warping Root Motion Anim Thread

Level 6 — Multiplayer

Baut auf UPROPERTY und Owner/GetOwner() auf — Server und Client sehen denselben Actor unterschiedlich, und das reicht aus, um zurückzukehren und Network Prediction aus Level 5 wirklich abzuschließen.

Grundlagen

Replikation: Rollen und Authority RPC: Server/Client/NetMulticast Network Relevancy Network Dormancy

Fortgeschritten

UActorChannel Net Driver Property Replication von innen Replication Graph Fast Array Serializer Client-Side Prediction außerhalb von GAS Listen vs Dedicated Server Seamless Travel

Level 7 — Engine-Interna

Ein völlig neues Level — was mit dem Projekt zwischen "Code schreiben" und "Spieler startet die exe" passiert: Header Tool, UnrealBuildTool, Modules, Plugins, Serialisierung, Cook, Runtime Loading, Threads und Speicher-Allokatoren.

Grundlagen

Kompilieren: von .cpp zum Spiel ★ flaggschiff UnrealBuildTool Modules und .Build.cs Plugins und .uplugin FArchive: Serialisierung Cooker Runtime Loading Game Thread und Task Graph FMalloc: Speicher-Allokatoren

Fortgeschritten

UBT: der Kompilierungsgraph UnrealHeaderTool von innen Build.cs und Target.cs Die vollständige Kompilierungs-Pipeline Innerhalb von .generated.h Hot Reload vs Live Coding Packaging: Build+Cook+Stage+Package Wie ein Plugin in den Speicher geladen wird FMemory und GMalloc Alignment und Cache Lines TArray von innen TMap / TSet von innen

Level 8 — Produktion

Ein völlig neues, den Kurs abschließendes Level — wie man nicht nur Code schreibt, sondern bestehenden Code diagnostiziert und repariert, das Frame-Budget einhält, Fortschritt speichert und ein Projekt strukturiert, das mehr als einen Entwickler überlebt.

Debugging

UE_LOG Visual Logger Gameplay Debugger DrawDebug* Unreal Insights stat-Befehle

Optimierung

Tick und Timer optimieren AsyncTask und ParallelFor Profiling als Denkweise

Speichern

USaveGame

Architektur

Architektur großer Projekte

Profiling (Fortgeschritten)

Trace von innen Eigener Trace-Kanal CSV Profiler Gameplay Debugger über das Netzwerk LLM: Low Level Memory Tracker GPU-Profiling Analyse eines einzelnen Frames

Architekturmuster

Composition vs Inheritance Subsystem Pattern Observer via Delegates Factory Pattern: SpawnActor Command Pattern in GAS Dependency Injection in Unreal

Nachwort — durchgängige Artikel

Kein neuer Stoff, sondern eine Prüfung, ob du das System als Ganzes siehst: Fünf Artikel verbinden alles bisher getrennt Gelernte zu durchgängigen Geschichten — vom Tastendruck bis zum Frame auf dem Bildschirm, vom Prozessstart bis zum vollständigen Spiellebenszyklus.

✦

Nachwort — Engineering Flows

Baut auf dem gesamten Kurs als Ganzes auf — jeder Artikel verfolgt einen durchgängigen Pfad durch Ereignisse, die in den Levels 0–8 getrennt behandelt wurden, und fügt sie zu einer am Quellcode überprüfbaren Chronologie zusammen.

Vollständiger Spiellebenszyklus Der vollständige Asset-Pfad Der vollständige Input-Pfad Der vollständige Frame-Pfad Der vollständige Replikationspfad

Alles zusammen anwenden

9 Level isoliert zu durchlaufen reicht, um jede Idee zu verstehen — nicht aber, um zu spüren, wie Dutzende solcher Ideen in einer lebenden Klasse koexistieren. Die zweite, parallele Schiene des Kurses — derselbe Charakter, der mit dem Fortschritt durch die Level wächst.

🎮

Abschlussprojekt: AAcademyCharacter vom Actor bis zu GAS und Animation

Ein kontinuierlich wachsendes Projekt statt sechzehn paralleler Meilensteine — fast jedes Level fügt ein reales, funktionierendes Stück desselben Survival-Spiels hinzu: von einem nackten Actor und Components über Enhanced Input, DataAsset-Items, UMG/MVVM, Multiplayer, GAS-Fähigkeiten und KI-Gegner bis hin zu Speichern und Profiling, mit der zwingenden Bedingung, dass Entscheidungen aus früheren Schritten nicht stillschweigend überschrieben werden, sondern nur durch explizites Refactoring — genau wie in einem echten Projekt.

Wie das alte Projekt genutzt wurde

Das vorherige Projekt (der Ordner eine Ebene höher) wurde nicht gelöscht und dient weiterhin als Referenzmaterial — eine Quelle für Ideen, fertige Erklärungen und Codebeispiele. Kein Artikel hier ist eine Kopie: Jedes Thema wurde neu analysiert, überprüft, ergänzt und auf den oben beschriebenen gemeinsamen Standard gebracht.