Game Development Vocabulary

The game loop is the central execution cycle of every real-time game: Process input → Update game state → Render → Repeat. It runs continuously — ideally 60 or 120 times per second. Performance vocabulary: FPS (frames per second) — how many times the loop completes per second. Frame time — time (ms) each loop iteration takes; 60 FPS = 16.67 ms per frame. CPU-bound — the bottleneck is CPU work (logic, physics, AI). GPU-bound — the bottleneck is rendering. Delta time (dt) — elapsed time since the last frame; used to make movement speed frame-rate-independent. Fixed update vs update — physics runs on a fixed timestep; rendering runs as fast as possible. Profiler — tool that measures where time is spent each frame. In Unity: Update() runs once per frame; FixedUpdate() runs at a fixed physics timestep. In conversation: "We moved heavy AI pathfinding calculations to a separate thread to unblock the main game loop."

ECS (Entity Component System) is a data-oriented design pattern that separates data (components) from logic (systems) and identity (entities). Entity — a unique ID with no inherent behaviour; just an identifier. Component — plain data structs attached to entities (Position, Health, Velocity). No methods, just data. System — logic that processes all entities with a specific combination of components. Benefits: cache-friendly memory layout (all Position components stored contiguously), no inheritance complexity, easy to add/remove behaviour at runtime. Classic OOP problem in games: God objects — massive MonoBehaviour classes with hundreds of responsibilities. Diamond inheritance — ambiguous method resolution in deep hierarchies. Modern ECS frameworks: Unity DOTS (Data-Oriented Technology Stack), Bevy (Rust game engine), EnTT (C++). In conversation: "With ECS, adding a 'Frozen' state requires just adding a Frozen component — the movement system automatically ignores entities that have it."

LOD (Level of Detail) is a rendering optimisation: objects have multiple mesh versions at different polygon counts (LOD0 = highest quality, LOD1-LOD3 = progressively simpler). The engine transitions between them based on distance. Why it matters: rendering 1,000 fully detailed characters in a crowd scene is prohibitively expensive; with LOD, distant characters use a 200-polygon mesh that looks identical at that distance. Related rendering optimisation vocabulary: Draw call — a CPU instruction to the GPU to render a mesh; reducing draw calls is a major performance target. Batching — combining multiple draw calls into one. Culling — not rendering objects that can't be seen. Frustum culling — not rendering objects outside the camera's field of view. Occlusion culling — not rendering objects hidden behind opaque geometry. Texel density — texture pixels per world unit; controls how sharp textures look up close. Mipmapping — pre-computed lower-resolution texture versions for distant geometry. In conversation: "LOD transitions were too visible — we implemented dithered LOD cross-fades to make the pop-in less noticeable."

A navigation mesh (nav mesh) is a simplified geometric representation of all walkable surfaces in a level — stored as connected polygons — that AI agents use for pathfinding. AI pathfinding vocabulary: Pathfinding — calculating a path from point A to point B avoiding obstacles. A* algorithm — the most common pathfinding algorithm for games; finds the shortest path using a heuristic. Waypoint graph — older approach: manually placed nodes connected by edges; less flexible than nav mesh. Nav mesh agent — a game object component that uses a nav mesh to navigate automatically. Steering behaviour — how an agent moves along a calculated path (arrive, pursue, flee, flock, avoid). Baking — the pre-computation step that generates the nav mesh from level geometry. Must be re-run when static level geometry changes. Dynamic obstacles (moving characters): handled at runtime with obstacle avoidance rather than re-baking. Off-mesh links — define special traversal behaviours like jumping, climbing ladders, or opening doors. In conversation: "The AI was getting stuck in corners — the nav mesh polygon resolution was too low and didn't capture the geometry accurately."

In a server-authoritative architecture, only the server's game state is considered canonical. Clients send inputs (not direct state changes), the server simulates the result, and clients synchronise to the server's output. Why it matters for anti-cheat: if clients controlled their own position (peer-to-peer or client-authoritative), they could send fake positions — "speed hacking" or "teleporting." With server authority, position changes are validated by the server's physics. Multiplayer networking vocabulary: Client-side prediction — the client simulates the result of its own inputs immediately (no visible lag) and then reconciles with the server. Lag compensation — the server rewinds time to account for network latency when registering hits. Rollback netcode — used in fighting games; both clients simulate ahead and roll back to correct divergence. Tick rate — how many times per second the server processes inputs and sends state updates (e.g., 64 tick = CS:GO competitive, 20 tick = Fortnite). Snapshot interpolation — smooth rendering between received server snapshots. In conversation: "We increased server tick rate from 30 to 60 — the competitive players immediately noticed the improved responsiveness."

Interpolation refers to the process of calculating intermediate values between two known states. In animation, it's how the game smoothly blends between different animation frames or blend shapes to avoid a jarring visual effect – the 'jitter' Alice describes is likely caused by poor interpolation settings.

A state machine is a design pattern where an object (in this case, a character) can be in one of several discrete states. Transitions between these states are triggered by events or conditions, allowing for complex behaviour to be managed efficiently and predictably – the PR describes a system precisely like that.

A texture atlas is a common optimization technique where multiple smaller textures are combined into one larger image. This reduces the number of times the graphics driver needs to perform a 'draw call' – which significantly improves performance by minimizing overhead.

Raycasting is a fundamental collision detection technique. It involves 'casting' rays (lines) from one object towards another and determining if those rays intersect – this provides a direct way to identify overlaps between objects in 3D space.

A component-based architecture is a design pattern where objects are composed of smaller, independent components. This promotes modularity and reusability, making it easier to modify or extend the system without affecting other parts – it's a common approach in modern game development.