The Unreal Engine Game Framework: From int main() to BeginPlay

Core technological concept: the “game loop” vs. Unreal’s framework

• In traditional game programming, the game loop handles:
  • initialization
  • per-frame input/state update/render
  • cleanup on exit
• In Unreal Engine, you typically don’t implement the loop directly. Instead, you extend engine framework classes (e.g., GameMode, Actor, Component) and override lifecycle hooks like:
  • BeginPlay
  • Tick
• The engine manages the loop internally.

---

Why Unreal’s framework matters (and where to learn it)

To understand Unreal’s runtime behavior, it helps to study the engine source code, especially how it transitions from the process entry point into gameplay code.

Unreal’s startup is described as complex (“messy complexity is inevitable”), including:

• platform abstraction / indirection
• conditional compilation for build configurations
• separate game and render threads
• object-oriented abstractions built on top of the loop

---

Engine startup flow (from launch/main to frame ticking)

1. Entry point Platform-specific main functions eventually reach a guarded main in launch.cpp.

2. Engine loop class The engine’s main loop is implemented by an Engine Loop class with phases:

   • pre-init
   • init
   • per-frame tick until exit

3. Pre-init (module loading)

   • Unreal uses a module system with configurable loading phases.
   • Low-level essential modules load first, then higher-level engine modules, and finally project/plugin modules.
   • When project/plugin modules load, Unreal:
     • registers UObject classes (for reflection)
     • creates Class Default Objects (CDOs) as prototypes
     • runs constructors with parent CDOs as templates
     • calls module startup/shutdown functions tied to module lifetime

4. Init phase

   • The “engine capital E” product side creates the runtime Engine class instance.
   • It uses config (e.g., engine config) to choose the correct engine class flavor (editor vs game).
   • It initializes the engine, fires a global delegate (“engine initialized”), then performs late module loading.

5. Ticking After initialization, the engine starts running frames (tick).

---

Loading into gameplay: Browse, maps, and URLs

• The engine class performs map/network operations via browse/load map concepts.
• URLs can represent:
  • a server to connect to, or
  • a map name to load locally
• The project default map is configured in default engine.ini; development builds can override via command line.
• During gameplay, you can browse to other maps/servers using commands (e.g., an “open” flow).

---

Key objects created before/for gameplay start

During engine initialization (before map loading), Unreal creates:

• GameInstance Exists to handle project-specific, more persistent logic (introduced in UE 4.4).

• GameViewportClient Interface for rendering/audio/input.

• LocalPlayer Representation of the user at the screen.

---

LoadMap: from map package to “actors for play”

After initialization, the engine enters LoadMap, which:

• fires a delegate that a map change is about to happen
• destroys/cleans the previous world (if one exists)
• creates a WorldContext to persistently track the currently loaded world
• loads the map package (persistent level) from a .umap asset
• loads:
  • the World
  • persistent Level
  • saved actors including World Settings

Then it brings up the world:

1. Initialize WorldContext / global GWorld reference.
2. Set world type to game, and add to the root set (prevents GC).
3. Initialize world systems (examples mentioned: physics, navigation, AI, audio).
4. SetGameMode The world requests GameInstance to create the GameMode actor.

Next: map/gameplay initialization

• Load always loaded sub-levels and required assets.
• Call “bring world up for play” via actor/component loops:

1. Register all actor components

   • set world references
   • call OnRegister
   • create render proxies for primitive components

2. GameMode init

   • InitGame spawns core server actors such as:
     • GameSession
     • GameState
     • GameNetworkManager
   • InitGameState is called

3. Second loop initializes levels and actors

   • includes pre-initialized components (earlier setup point)

4. Final loop for full actor readiness

   • Initialize components
     • activates components if configured (auto activate)
     • calls InitializeComponent when flags like bWantsInitializeComponent are set
   • Post-initialize components The earliest “fully formed” state; recommended for start-of-game actor setup

---

Gameplay framework lifetimes (process vs map lifetime)

Two major lifetimes:

1. Before LoadMap (tied to process lifetime) Example: engine, game instance, viewport, local player.

2. After LoadMap (tied to playing a specific map) Example: GameMode/GameState/PlayerController.

Map transitions:

• Seamless travel can preserve some actors.
• Plain browse to a new map/server/menu destroys the world and actors, then repeats initialization.

---

Multiplayer/login/authority model described

When starting a game, Unreal processes local players in the game instance, calling SpawnPlayer / SpawnPlayActor:

• spawns PlayerController (player representation in the world)
• PlayerController spawns PlayerState
• PlayerState is associated with GameState

Remote connections:

• GameMode handles:
  • PreLogin (approve/reject remote attempts)
  • Login (spawn PlayerController)
• After a player joins:
  • PostLogin runs
  • GameMode typically does RestartPlayer to spawn a Pawn for the controller

Key server-only vs replicated authority

• GameMode: server-only (rules/authority)
• GameSession and GameNetworkManager: server-only
• GameState: created/authoritative on the server, then replicated to clients for shared state
• GameNetworkManager config includes things like cheat detection and movement prediction

---

Pawn, possession, respawn, and spectator mode

• Pawn is the in-world controllable actor; PlayerController possesses it.
• GameMode spawns Pawns, selecting spawn points from PlayerStart actors (customizable).
• RestartPlayer supports respawning after death (PlayerController remains; Pawn is replaced).
• Spectating:
  • If configured, GameMode can avoid spawning a regular pawn and instead spawn spectator pawn(s).

---

BeginPlay routing (the end of LoadMap)

After the world is ready, BeginPlay is routed:

• engine → world → game mode/world settings → actors → components

Actors’ BeginPlay ultimately triggers:

• component BeginPlay
• Blueprint BeginPlay events

---

Class overview + recommendations (features called out)

GameModeBase vs GameMode

• GameModeBase:
  • contains essentials
• GameMode:
  • adds match flow/state management (spectating before start, match transitions, etc.)

Character / CharacterMovement

Character is described as a specialized Pawn with:

• collision capsule
• skeletal mesh
• CharacterMovementComponent

Highlights:

• out-of-the-box replicated movement + client-side prediction
• root motion consumption with replication
• navigation/pathing support (AI-controller possession on navmesh)
• many tunable movement modes/parameters

Warning:

• default Character settings may make your game “feel like an Unreal tutorial”; tune movement parameters.

---

Extensibility approaches beyond inheritance

• You can extend behavior by binding to delegates representing engine events (mentions categories such as core/object/game viewport/game/world delegates).

• Subsystems (as of UE 4.22):

  • modular feature pattern
  • define a subsystem class and Unreal auto-creates it tied to an object lifetime
  • beneficial for plugin modularity (avoids locking into a single custom GameInstance class if multiple plugins want extensibility)

---

Main speakers / sources

• Speaker: Not explicitly stated (no name given).
• Primary source: Unreal Engine (engine source code / framework and lifecycle behavior) analyzed by the video narrator.