The object model, asset loading, runtime execution, networking, the Gameplay Ability System, and the design tradeoffs that tie it together — with an interview drill at the end of the chapters that have one.
What the class prefixes mean and why UHT enforces them, choosing between a struct, a UObject and an Actor, and what Blueprint can actually see.
Where the Blueprint/C++ line sits, what goes wrong when everything lives in Blueprint, keeping large graphs readable, and the three ways Blueprints communicate.
Reflection macros, meta specifiers for safe well-ranged knobs, and structuring a system that is fast in code and tunable in data.
The core classes and their authority split, actors versus components, composition over deep inheritance, and GameState in depth.
Why GameState is a bulletin board and not a brain, the layered model managers actually live in, and the one case where a component on GameState is right.
The Class Default Object, the pipeline from constructor to BeginPlay, what a constructor may and may not do, how Blueprint differs, and why destroyed does not mean null.
Hard versus soft references, how hard ones get created without you noticing, what they cost transitively, and the tools for cutting coupling.
Data Tables versus Data Assets, structuring a system designers extend without code, and using structs and enums to make the surface safe.
Primary and Secondary assets, the Streamable Manager, reference-counted handles, and loading only the slice you need with Asset Bundles.
Gameplay plugins you can flip on and off at runtime, and the broker that lets a feature reach into a game that has never heard of it.
What Tick actually costs, why the Blueprint VM makes it worse, tiering tick rates for AI, and the event-driven alternatives.
Why Delay works in some graphs and not others, choosing between Tick, Timer and Delay, and what Blueprint async really means.
Unreal's observer pattern, the dynamic variant Blueprint can see, and why it's the main tool for inverting a dependency.
Where code lives versus when a system runs, the four subsystem lifetimes, the lifecycle hooks, and two gotchas that bite.
What GAS solves, the vocabulary, composing an ability from tags and effects rather than one big function, and why it's shaped for multiplayer.
Why an Actor is really several copies kept in sync, who owns which class, replicated variables and RPCs, prediction, and server-side lag compensation.
The mapping-context registration step everyone forgets, and why On Possessed beats BeginPlay for it.
Debugging a graph and its limits, Live Coding and build hygiene, and the data structures Blueprint doesn't hand you.
The U/I class split behind every C++ interface, which function specifier lets Blueprint override what, and how a call actually dispatches.
Where tags earn their keep beyond GAS, best practices for a tag hierarchy, and the decision table for tags versus enums, delegates, interfaces and subclasses.
Which UCLASS specifiers gate Blueprint visibility, why a Blueprint is a class and a Data Asset is an instance, and the ownership specifiers that decide whether a UObject property is shared or owned.