Game Developer Interview Prep Guide

Cover the fixed timestep accumulator pattern: accumulate elapsed time, run physics updates at fixed intervals (e.g., 60Hz), and interpolate visual positions between physics steps for smooth rendering at any frame rate. Discuss the spiral of death problem when physics cannot keep up, and how to cap accumulated time. Explain why physics must be deterministic with fixed timestep for multiplayer synchronization.

Compare traditional OOP inheritance (deep hierarchies, rigid) with ECS (Entity Component System): entities are IDs, components are pure data, and systems operate on component queries. Discuss data-oriented design for cache efficiency, archetype-based storage, and how ECS enables parallelism. Show awareness of Unity DOTS and Unreal Mass system. Address the trade-off between flexibility and complexity.

Cover the stages: vertex processing (vertex shader, transforms), primitive assembly, rasterization, fragment/pixel shader, depth testing, and blending. Discuss CPU bottlenecks (draw calls, state changes) and GPU bottlenecks (fillrate, bandwidth, shader complexity). Mention modern rendering techniques: deferred rendering, GPU-driven rendering, mesh shaders, and how ray tracing fits into the pipeline. Explain how to use GPU profiling tools to identify bottlenecks.

Cover client-server authoritative model, client-side prediction with server reconciliation, entity interpolation for other players, lag compensation with server-side rewind for hit detection, and bandwidth optimization with delta compression and interest management. Discuss the tradeoff between responsiveness and fairness. Mention rollback netcode for fighting games and deterministic lockstep for RTS games.

Profile with the engine profiler (Unity Profiler or Unreal Insights) to identify whether it is CPU or GPU bound. For CPU: check for expensive AI updates, physics overhead, or garbage collection. For GPU: check overdraw from particles, shader complexity, and draw call count. Optimization strategies: LOD systems, occlusion culling, object pooling, GPU instancing for particles, and amortizing expensive operations across frames.

Explain why brute-force O(n^2) collision checking fails at scale. Implement a quadtree that subdivides space into four quadrants, inserts objects based on their bounds, and queries for potential collisions in a region. Discuss node capacity, max depth, and handling objects that span multiple nodes. Compare with alternatives: grid-based spatial hashing (simpler, good for uniform distribution) and BVH (better for dynamic scenes).

Game bugs are often non-deterministic or visual. Describe a specific bug: a physics glitch, a memory leak causing frame drops, a desync in multiplayer, or a rendering artifact. Explain your debugging tools and process: frame debugger for rendering, memory profiler for leaks, replay system for reproducing gameplay bugs, or network packet analysis for multiplayer issues. Show systematic debugging methodology.

Discuss wave function collapse for tile-based generation, perlin noise for terrain, grammar-based generation for dungeons, and constraint satisfaction for puzzle placement. Cover seed-based determinism for shareable worlds, quality metrics to validate generated content, and human-authored rules that constrain procedural systems. Mention how designers should be able to set parameters and constraints without writing code.