Architecture of Computer Games

• Family of game engines developed by ID Software
• Id Tech 0 - the very first game engine
• Every next game had more advanced technology
• Still, memory constraints sabotaged attempts to create data-heavy design

Hovertank 3-D

1991

Catacomb 3-D

1991

Wolfenstein 3-D

1992

Shadowcaster

1993

• I'm able to define somehow what a game is
• I know the difference between games and applications
• I know the difference between emergence and progression
• I know terms like gameplay, mechanics, system, level, simulation, bot, agent, mob, NPC
• I know game basic elements
• I know elements/entities of game mechanics
• I know a thing or two about IDTech

• Game Loop - heartbeat of all games
• Scene Manager - manages objects and structures them in a scene graph
• Resource Manager - manages assets, controls a cache
• Input Manager - handles inputs (keyboard, mouse, touch, joystick, gamepad,...)
• Memory Manager - memory allocator and deallocator
• Rigidbody Engine - event-based collision detection
• Physics Engine - handles behavior of objects based on forces and impulses
• Rendering Engine - renders the game, takes care of the rendering pipeline
• Animation Engine - handles animations
• Scripting Engine - a bridge between the engine and interpreted languages (JS, C#,...)
• Audio Engine - plays music, clips, sounds, calculates 3D sound
• AI Engine - abstract engine for AI (state machines, behavioral trees,...)
• Networking Engine - handles multipeer communication

• simple, yet the most important part of the game engine
• each turn advances the state of the game
• the loop is usually coordinated with the event loop of the platform/virtual machine
• optimal time step for rendering: 60 FPS = 16.6 ms per frame
• audio and input processing are usually separated as they require more frequent updates

• implemented by small, relatively independent jobs
• firstly used in Ultima VII (1994)

• game objects are consistent before and after every update
• they may get to an inconsistent state during update - one-frame-off lag
• possible solutions: bucket update, script execution order (Unity)

Object A reads previous state of Object B and Object B reads previous state of Object C

Detects input events from devices

Atomic events

• KEY_DOWN
• KEY_UP
• MOUSE_WHEEL
• JOYPAD_A

Compound events

• FLING
• PINCH_TO_ZOOM
• DOUBLE_TAP

Special events

• cheat codes
• fighting combos

• I know primary modules of game engines
• I know how game loop works
• I know the options of game update and inconsistencies that may occur
• I know what scene graph is and what elements it contains
• I know categories of input events and input device
• I know what dead-zone of input is
• I know the purpose of a memory manager
• I know the purpose of pool allocator
• I know the options of data loading in games
• I know the types of scripting architectures
• I know what marshalling is

• I know what game assets are
• I know the purpose of a Resource manager
• I know the difference between the use-cases of WAV and MP3/OGG formats
• I know the difference between PNG and JPEG formats
• I know what a cutscene is
• I know what a sprite is
• I know the types of textures
• I know what a tilemap is

• I know what a game model is and what is it made of
• I know the pitfalls of object-oriented architecture in games
• I know what a component is
• I know the ECS pattern
• I know messaging practices for component architecture
• I know the purpose of a message broker in games

• Process - something that requires more than one frame to finish
  • basically anything that involves animations, mini cut-scenes, delayed actions, sounds
• Chain - a set of commands, events and processes that need to be evaluated in a given order

• implementation

  • callbacks - basically in every language, very bad robustness
  • listener chaining - any language with closures (Java, JavaScript, C#,..)
  • iterator blocks - C#
  • promises and generators - JavaScript
  • coroutines - Kotlin, Ruby, Lua,...

• determines which component should be responsible for given scope/action/decision
• there is no bulletproof recipe, yet it should be unified
• if the scope affects only one entity, it should be a component attached to that entity
  • example: a worker that goes to the forest for some wood
• if the scope affects more entities, it's often a component/system attached either to an abstract entity up the scene graph (e.g. the root object)
  • example: battle formation controller, duel controller (who wins, who loses)

Individual units

Battle formation

• an object keeps shared data to support large number of fine-grained objects
• e.g. instanced rendering, geometry hashing, particle systems
• here we move a position and a tile index (Sprite) into an array

• a function that returns a value
• centralizes the knowledge of how to find an entity/attribute/component
• can be used by components to access dynamic data
• can form a hierarchy from other selectors

   1
 const getPlayer(scene: Scene) => scene.findObjectByName('player');
   2
 
   3
 const getAllUnits(scene: Scene) => scene.findObjectsByTag('unit_basic');
   4
 
   5
 const getAllUnitsWithinRadius(scene: Scene, pos: Vector, radius: number) => {
   6
 	return getAllUnits(scene).filter(unit => unit.pos.distance(pos) <= radius);
   7
 }
   8
 
   9
 const getAllExits(scene: Scene) => {
  10
 	const doors = scene.findObjectsByTag('door');
  11
 	return doors.filter(door => !door.locked);
  12
 }

• bit array that stores binary properties of game objects
• may be used for queries (e.g. find all MOVABLE objects)
• similar to a state machine but the use-case is different
• if we maintain all flags within one single structure, we can search very fast

• the most basic state of an entity
• allows us to set conditions upon which a transition to other states is possible

   1
 // stateless, the creature will jump each frame
   2
 updateCreature() {
   3
   if(eventSystem.isPressed(KeyCode.UP)) {
   4
     this.creature.jump();
   5
   }
   6
 }
   7
  
   8
 // introduction of a state
   9
 updateCreature() {
  10
   if(eventSystem.isPressed(KeyCode.UP) && this.creature.state !== STATE_JUMPING) {
  11
     this.creature.changeState(STATE_JUMPING);
  12
     this.creature.jump();
  13
   }
  14
 }

• a template that keeps attributes from which it can build new objects
• each method returns back the builder itself, so it can be chained

   1
 class Builder {
   2
   private _position: Vector;
   3
   private _scale: Vector;
   4
  
   5
   position(pos: Vector) {
   6
     this.position = pos;
   7
     return this;
   8
   }
   9
  
  10
   scale(scale: Vector) {
  11
     this.scale = scale;
  12
     return this;
  13
   }
  14
  
  15
   build() {
  16
     return new GameObject(this._position, this._scale);
  17
   }
  18
 }
  19
  
  20
 new Builder().position(new Vector(12, 54)).scale(new Vector(2, 1)).build();

• Builder builds new objects from scratch, Prototype creates new objects by copying their attributes
• in some implementations, the prototype is linked to its objects - if we change the prototype, it will affect all derived entities
• e.g. templates in Godot, linked prefabs in Unity and Unreal engine

Prefabs in Unity

• Builder assembles an object, factory manages the assembling
• Factory creates an object according to the parameters but with respect to the context

   1
 class UnitFactory {
   2
 	
   3
   private pikemanBuilder: Builder; // preconfigured to build pikemans
   4
   private musketeerBuilder: Builder; // preconfigured to build musketeers
   5
   private archerBuilder: Builder; // preconfigured to build archers
   6
  
   7
   public spawnPikeman(position: Vector, faction: FactionType): GameObject {
   8
     return this.pikeman.position(position).faction(faction).build();
   9
   }
  10
  
  11
   public spawnMusketeer(position: Vector, faction: FactionType): GameObject {
  12
     return this.musketeerBuilder.position(position).faction(faction).build();
  13
   }
  14
  
  15
   public spawnArcher(position: Vector, faction: FactionType): GameObject {
  16
     return this.archerBuilder.position(position).faction(faction).build();
  17
   }
  18
 }

• I know how chain works
• I know something about responsibility ownership in component architecture
• I know flyweight pattern
• I know selector pattern
• I know flag pattern
• I know numeric state pattern
• I know builder pattern
• I know prototype pattern
• I know factory pattern

• pulse-code modulation, a method used to digitally represent sampled analog signals
• sample - fundamental unit, representing the amplitude of an audio signal in time
• bit depth - each bit of resolution is equal to 6dB of dynamic range
• sample rate - number of samples per second: 8 kHz, 22.05 kHz, 44.1 kHz, 48 kHz
• frequency - a measure of the number of pulses in a given space of time
• frame - collection of samples, one for each output (e.g. 2 for stereo)
• buffer - collection of frames in memory, typically 64-4096 samples per buffer
  • the greater the buffer, the greater the latency, but less strain being placed on the cpu

• generator - oscillator that can make a tone, either independently or by pairing with another generator
  • synth music is a combination of generated tones, effects, filters, and recorded sound samples
• main synthesis types: additive, subtractive, FM, wavetable

• I know what PCM is and how buffer size affects the gameplay
• I know 4 basic types of synthesis
• I know basic waveforms of sound generators
• I know categories of audio assets in games
• I know features of dynamic music (looping, branching, layering, transitions)
• I know what attenuation, occlusion and obstruction in 3D sound are

• Randomness is used to vary characteristics, noise is used to vary them over time or in space
• Noise functions
  • Lattice-based
    • Perlin noise, Simplex noise, Wavelet noise, Value noise
  • Point-based
    • Worley noise (Voronoi/Cellular)

Perlin Noise

Simplex Noise

Worley Noise

• Vector - a quantity that has both a magnitude and a direction
• vector can be used to represent a point, provided that we fix the tail of the vector to the origin of the coordinate system

Addition and subtraction

• vector + vector = vector
• vector - vector = vector
• point + vector = point
• point - point = vector
• point + point = undefined

Vector addition and subtraction

Quaternions

• similar to axis + angle, but with an algebraic twist
• alternative form:
• unit-length:

• a unit quaternion can be visualised as a 3D vector + scalar

• permits rotations to be concatenated and applied directly
• permits rotations to be easily interpolated
• can perform only one full rotation between keyframes

• algorithm that decomposes a polygon-soup into a tree that contains convex sets
• first used in Doom to solve difficult rendering of circles around pillars in level 2
• very good for rendering, ray-casting and collision detection in complex indoor environments
• works only in static environments and requires a complex preprocessing stage

• hierarchical partition
• each inner node has 4 children
• overlapping solid objects are put into all children they touch
• only objects in the same leaf can be in collision
• useful for outdoor scenes
• good for object sparsely spread that do not move too fast

• implemented as an 1D/2D/3D array or a hash-table
• each cell has a list of units that are inside
• if a unit crosses the boundary of the cell, we need to move it to the other list
• good for a large amount of fast objects that are uniformly distributed
• very fast to locate an object - in sharp contrast with recursing down a quad-tree
• takes up more memory, granularity is static

• improved Dijkstra by an estimate of the cost to the target from each node
• Cost , where  is the cost-so-far and  is the heuristic estimate
• Heuristics: Euclidean, Manhattan, adaptive, dynamic,...
  • Manhattan distance will work if almost no obstacles appear

• breadth-first search ignores the cost
• Dijkstra ignores the topology of the graph
• A* considers both

• I know what purpose can serve uniform and gaussian distributions
• I know what is a loot, spinning, rarity slotting and random encounter in games
• I know something about noise functions
• I know basic vector operations: addition, subtraction, magnitude, normalization, and dot product
• I know what quaternions and Euler angles are, and what use-cases they are good for
• I know basic structures for spatial partitioning: grid, quad-tree, oct-tree and BSP
• I know basic types of navigation graphs
• I know something about pathfinding algorithms, such as BFS, Dijkstra and A*

• cheap and easy to implement
• high error and poor stability, depending
  directly on the time step

• set of algorithms and principles that help autonomous agents move in a realistic manner by using simple forces
• designed by Crag Reynolds in the early 90's
• Agent - a system situated within an envirnoment, with an ability to sense that environment
• Motion layers
  • action selection - choosing goals, strategy
  • steering - trajectory calculation
  • locomotion - way of moving, animation, articulation

• system that approximates physical phenomena in real-time
• computes dynamics of objects in virtual scene
• you have to understand your game before you decide how to add a physical simulation to it
• can improve immersion
• can support new gameplay events
• can broke the game story
• can take up significant computing resources

• a collection of point masses that obeys certain physical laws
• can model complex fuzzy shapes and dynamics
• uses Flyweight pattern (array of positions, velocities, group lists)
• particles are not only moving points! Even a tree may become a particle

• I know basic motion equations
• I know basic Euler integration methods
• I know basic types of steering behaviors
• I know object types for physics engines
• I know basic constraints, such as rope, revolute, prismatic, and cone-twist
• I know basic collision primitives
• I know SAT theorem
• I know what CCD is
• I know what particle systems are

• View volume - region of space the camera can see
• Frustum - the shape of view volume for perspective projection
• Rectangular prism - the shape of view volume for orthographic projection
• Field of View (FOV) - the angle between the top and bottom of a 2D surface of the projected world

Perspective projection

Orthographic projection

• method that calculates semi-points within the range of given points

Applications

• graphics - image resizing
• animations - transformation morphing
• multiplayer - game state morphing
• audio/video - sample/keyframe interpolation

• programs that run on the video card in order to perform a variety of specialized functions (lighting, effects, post-processing, physics, AI)

• I know the difference between model space, world space, view space, clip space and screen space
• I know what view volume and field of view is
• I know what interpolation is
• I know terms like Vertex, Fragment, Texture, Occlusion, and Culling
• I know what purpose serve vertex and fragment shader
• I know what LOD, texture mapping, texture filtering, and baking is

• IF-THIS-THEN-THAT
• AI behavior is completely hardcoded
• simple, easy to debug, easy to extend
• human player should behave as the developers expected
• good scripting behavior must cover a large amount of situations

   1
 // Doom 2: find player to chase
   2
 void A_Look (mobj_t* actor) {
   3
     mobj_t* targ;
   4
     actor->threshold = 0;   // any shot will wake up
   5
     targ = actor->subsector->sector->soundtarget;
   6
       if (actor->flags & MF_AMBUSH){
   7
         if (P_CheckSight (actor, actor->target))
   8
         goto seeyou;
   9
     } else goto seeyou;
  10
   
  11
     if (!P_LookForPlayers (actor, false)) return;
  12
     // go into chase state
  13
 seeyou:
  14
     P_ChasePlayer();
  15
 }

• the oldest and most commonly used formalism to model game AIs
• useful for entities with a small set of distinct states
  
• each entity can be in exactly one of a finite number of states at any time
• Definition
  • quadruple:
  •  is a finite, non-empty set of states
  •  is a finite set of inputs
  •  is the state-transition function
  •  is an initial state,
• can be implemented via polymorphism or a state transition table
• unmanageable for large complex systems, leading to transition explosion

• also known as statecharts
• each state can have a superstate or a set of substates
• groups of states share transitions
• usually implemented as a stack
  • push a low-level state on the stack when entered
  • pop and move to the next state when finished

• tree of hierarchical nodes that control decision making process
• originated from gaming industry since Halo 2 (2004)
• combines elements from both Scripting and HFSMs
• there is no standardized formalization
• depth-first traversal, starting with the root node
• each executed behavior passes back and returns a status
  • SUCCESS, FAILURE, RUNNING, (SUSPENDED)

• Real-time strategy is a Bayesian, zero-sum game (Rubinstein, 1994)
  
• a game where the player is in control of certain, usually military, assets, with which the player can manipulate in order to achieve victory
• goal: build up a base, gather resources, produce army, destroy the enemy
• methods: layer-based AI, rule-based AI

• I know what challenges in terms of game AI the developers face
• I know basic AI techniques, such as scripting, FSM, and HFSM
• I know something about behavior trees
• I know the definition of supervised, unsupervised, and reinforcement learning
• I know the main element and features of RTS

• each device exchanges data with each other in a fully connected graph
• used in Doom, early Command & Conquer series, Age of Empires, Starcraft
• given  peers, each must have  connections ->  in total
• methods: single master, partial authority, full replication

•  devices,  connections
• server must handle  more messages per second
• server quickly becomes the bottleneck (lack of power and bandwidth)
• Dedicated server - only runs the game state and communicates
• Listen server - server is an active participant in the game itself

• the act of transmitting a state of an object from one device to another
• each object must be uniquely identified (network ID)
• the network message contains a type of an object and all parameters required to construct it

• packets may get lost
• server keeps sending messages that have an impact on the game state until the client accepts them

• packets may arrive in a different order
• the client shouldn't apply a command message to its state before it applies all previous messages

• dealing with instant actions that affect the gameplay (e.g. instant hit in FPS)
• occurs due to the inaccuracies of dead reckoning and time dilation
• server may change a state that has already been confirmed

Wrong

Correct

• I know the difference between P2P and client-server architecture
• I know what issues networking architecture may face
• I know what types of messages can be used in multiplayer games
• I know what replication is
• I know how reliability in multiplayer works
• I know how interpolation works
• I know what server-side rewind is
• I know how games can deal with latency