Implementing A Robust And Flexible Game Loop Architecture

Establishing Game Loop Fundamentals

The game loop forms the core of any game engine or architecture. At its most basic, the game loop is an infinite loop that drives the update and render logic that brings a game to life on screen. Defining and properly structuring the game loop establishes fundamentals for achieving high performance, flexibility, and extensibility in a game architecture.

Defining the Game Loop and Its Core Components

The game loop consists of several key steps that execute sequentially in an endless loop:

1. Process system events and user input
2. Update game state and logic
3. Perform rendering and draw graphics/audio

This core update cycle runs continuously, driving the simulation forward, handling player interactions, and triggering screen refreshes at a target frame rate. The components within the game loop update sequence can be implemented as individual functions or steps within the loop.

Explaining the Game Loop Update Cycle

During each cycle of the game loop, several key operations take place:

1. Gather input: Mouse, keyboard, controller input is gathered and processed.
2. Update state: Based on input and predetermined logic, game entities and states are updated.
3. Perform AI: AI decisions and updates are performed based on current game state.
4. Handle physics: Collision detection, trajectory updates, particle effects are handled.
5. Render frame: Sprites, 3D models, particles, UI are redrawn to match updated state.
6. Play audio: Trigger audio playback based on current game state.
7. Repeat: The loop starts again, running continuously throughout gameplay.

The update cycle runs dozens of times per second, providing continual interactivity and fluid visuals. The key is structuring the cycle logic efficiently so updates meet timing budgets for smooth simulation and rendering.

Managing State Updates and Draw Calls

Careful orchestration of state updates and rendering within the game loop is required for optimal performance. Key considerations include separating update logic from render calls and implementing update/draw handler functions cleanly.

Implementing the Update Logic and Draw Functions

The core game loop will rely on two key handler functions – one for update logic, and one for rendering. These handlers encapsulate critical game functionality:

• Update handler: Encapsulates all game state updates, performing AI updates, physics calculations, input handling, and updating entity positions/behaviors.
• Draw handler: Encompasses all drawing to the screen, including 3D scene rendering, 2D sprite batching, particle updates, GUI/HUD draws, triggering audio, etc.

For the cleanest architecture, the update and draw handlers should reside in separate logic paths in the loop, allowing them to be modified independently and avoiding unnecessary coupling.

Separating State Updates from Render Calls

Isolating the update logic from the rendering logic enables key performance optimizations and program structure benefits:

• Avoids redundant render calls by only drawing when state changes
• Allows better granularity and profiling information
• Enables lifting render calls into separate threads via double buffering
• Decouples update state from render order requirements

This separation of concerns results in cleaner code and opportunities for targeted optimizations to either logic path.

Achieving Flexibility with a Customizable Game Loop Class

Well-designed games require maintenance over product lifetimes spanning years. Creating a solid foundation through a flexible, reusable game loop class supports extensibility and custom tailoring across projects.

Creating a Generic GameLoop Base Class

A GameLoop base class implements common functionality, default routines, and hooks to support extension. Core capabilities include:

• Initialization of critical systems/components
• Default input handling, update, and draw routings
• Frame rate tracking and time delta management
• Extensibility hooks via virtual update/draw functions

This base class encapsulates common needs to avoid duplication, while enabling overrides.

Allowing Customization through Virtual Functions

Exposing key update and draw methods as virtual functions allows the base loop behavior to be customized without heavy modification:

• virtual Update() – Override for specialized update behavior
• virtual Draw() – Override to implement custom rendering approach
• virtual ProcessInput() – Override to handle input differently

These virtuals allow game-specific subclasses to inherit convenient base functionality yet still specialize core logic easily.

Integrating with Game Time and Frame Rate Handling

Game loop execution is inherently tied to tracking elapsed time and regulating frame rates. Robust handling of variable time steps and frame rates is needed.

Linking the Game Loop to Time and Frame Rate Counters

Time and frames per second need quantified within the loop for proper regulation. This involves:

• Tracking elapsed time – Quantify DeltaTime each frame to enable variable time step computations.
• Counting frames – Update a FPS counter every second to quantify actual frame rate.

These counters feed into consistent game state updates and rendering.

Supporting Variable Time Steps and Frame Rates

Smooth simulations require responding to fluctuating DeltaTime values. Strategies include:

• Interpolation – Blend/lerp between past positions based on DeltaTime to reduce stuttering.
• Accumulators – Accumulate DeltaTime into thresholds that trigger state updates, avoiding direct frame ties.
• Dynamic slow motion – Scale DeltaTime dynamically to enable slick slow motion effects.

Supporting variable time and frames enables smoothness despite hardware inconsistencies.

Enabling Robust Multi-Threading Support

Multi-threading divides work across CPU cores for responsive and efficient execution. This requires care around shared data access.

Adding Threading for Update Calls

A common multi-threading approach separates game state updates to run concurrently across frames. This involves:

• Partitioning update logic into discrete work units
• Running update passes in parallel across worker threads
• Synchronizing thread results into primary game state

This enables update calculations to leverage multiple cores efficiently.

Ensuring Thread Safety for Shared State

Shared state access requires coordination for consistency. Techniques include:

• Worker thread input queues – divide state into jobs
• Atomic data structures – enable lock-free concurrent reads
• Lightweight mutexes – govern data structure read/write access
• Double buffering – alternate between read/write copies

These patterns prevent race conditions and ensure valid game state.

Example Game Loop Code in Unity

Unity game loops integrate with its component entity system and built-in rendering. Customizing key handlers enables specialized games.

Walkthrough of Sample Unity Game Loop Implementation

Unity loops subclass MonoBehaviour with overridden Update() and OnGUI() methods:

public class MyGameLoop : MonoBehaviour {

  void Update() {
    // Custom game state update code
  }  

  void OnGUI() {
    // Custom rendering code
  }

}

Built-in messaging invokes Update() on enabled game loop components driving state changes. OnGUI() handles drawing automatically during update/render passes.

Discussion of Key Points for Portability

For cross-project unity, key patterns to leverage include:

• Separate update behaviors into composable script components
• Wrap Unity API calls into manager classes for consistency
• Implement base classes to consolidate common functionality
• Follow MVC principles to isolate data, presentation, and logic

These designs enable portable assemblies customized via light script extensions.