Game Developer

A game engine is a software framework designed to provide the core technologies needed to build a game, such as a rendering engine (2D/3D), physics engine, sound, scripting, animation, and networking. We use them to avoid 'reinventing the wheel,' allowing developers to focus on gameplay and design rather than low-level technical challenges like memory management or hardware abstraction.

The primary differences are the Programming Language and Target Audience. Unity uses C# and is highly favored for mobile, 2D, and indie 3D projects due to its accessibility. Unreal uses C++ and Blueprints (visual scripting), and is known for high-end AAA graphics, photorealism (via Nanite and Lumen), and built-in professional-grade tools for large-scale environments.

I would choose Unity for Mobile games, 2D games, or AR/VR projects. It has a smaller build size, faster iteration times for small teams, a more flexible C# environment, and a massive Asset Store that speeds up development for indie creators or prototypes.

I would choose Unreal for High-fidelity AAA titles, massive open worlds, or cinematic experiences. Its native features like Nanite for infinite polygon detail, Lumen for real-time global illumination, and its robust C++ source code access make it the industry standard for projects where visual performance and complex systems are the priority.

A game loop is the central heartbeat of a game's execution. It is an infinite loop that runs continuously while the game is active, processing input, updating game logic (AI, physics, state), and rendering the final image to the screen at a specific frequency (FPS).

1. Input: Detecting user actions (keyboard, mouse, controller). 2. Update: Processing game logic, physics simulations, and state changes based on elapsed time. 3. Render: Drawing the updated scene to the display buffer.

FPS (Frames Per Second) is the number of consecutive images (frames) that the game engine renders every second. A higher FPS results in smoother movement and more responsive controls, with 30, 60, and 120 FPS being common industry targets.

Delta Time (Time.deltaTime in Unity) is the amount of time that has passed since the last frame. It is critical for ensuring that game movement and logic are frame-rate independent, meaning an object moves at the same speed whether the game is running at 30 FPS or 120 FPS.

Variable Timestep (Update) varies based on frame performance, used for visuals and input. Fixed Timestep (FixedUpdate) runs at a consistent, predefined interval (e.g., 50 times per second), making it essential for stable physics calculations to prevent objects from clipping through walls during frame drops.

V-Sync (Vertical Synchronization) matches the game's frame rate with the monitor's refresh rate to prevent Screen Tearing. It should be used in visually driven single-player games to ensure a smooth image, but it can introduce input lag, so it is often disabled in competitive FPS games.

2D development uses flat images (Sprites) on a X and Y axis, focusing on 'flat' gameplay and simple physics. 3D development uses three-dimensional geometry (Meshes) on X, Y, and Z axes, involving complex lighting, camera perspectives, and depth-based movement.

A sprite is a two-dimensional bitmap image or animation that is integrated into a larger scene. In game engines, sprites are often placed on 'sorting layers' to determine which images appear in front of or behind others.

A mesh is a collection of vertices, edges, and faces that define the shape of a 3D object. It acts as the 'skeleton' of a model, which is then covered by a material or texture to give it a visual surface.

A polygon is a flat, closed geometric shape (usually a triangle in modern rendering) formed by connecting three vertices. Polygons are the fundamental building blocks of all 3D meshes.

Polygon count is the total number of polygons in a mesh or scene. It matters because the GPU must calculate the position of every vertex; a count that is too high can lead to severe performance drops, especially on mobile or VR hardware.

LOD is a technique where multiple versions of the same mesh are created at different polygon counts. The engine automatically switches to a lower-poly version when the object is far away from the camera, saving significant processing power.

Frustum Culling disables rendering for objects outside the camera's view. Occlusion Culling disables rendering for objects that are hidden behind other solid objects (e.g., a room behind a closed door), preventing unnecessary GPU work.

Draw call batching is the process of combining multiple objects that share the same material into a single 'draw call' sent to the GPU. This reduces the overhead between the CPU and GPU, which is often the biggest bottleneck in game performance.

Static Batching combines non-moving objects (like walls) into one large mesh at build time. Dynamic Batching combines small, moving objects (like bullets) on-the-fly at runtime, provided they share the same material and are below a certain vertex count.

A GameObject (Unity) or Actor (Unreal) is the fundamental 'container' in a scene. By itself, it does nothing; it acts as a base to which you attach components (like scripts, renderers, or colliders) to give it functionality and behavior.

It is a design pattern where functionality is added to game objects through 'Composition' rather than inheritance. Instead of creating a complex 'Player' class, you attach a 'MovementComponent,' a 'HealthComponent,' and an 'InputComponent,' making the system modular and flexible.

ECS is a data-oriented architecture that separates Entities (IDs), Components (raw data), and Systems (logic). It optimizes memory layout (Cache Locality) and allows for massive parallelization on multi-core CPUs, enabling the rendering of thousands of active objects (like a swarm of units) with high efficiency.

Inheritance creates an 'is-a' relationship (e.g., an Orc is a Monster), which can lead to rigid, deeply nested code. Composition creates a 'has-a' relationship (e.g., an Orc has a HealthComponent), which is generally preferred in game dev because it allows for dynamic and modular behavior changes.

Object pooling is the practice of pre-instantiating a group of objects (like bullets or effects) and reusing them instead of destroying and creating them repeatedly. This avoids frequent Garbage Collection (GC) spikes and the high CPU cost of 'Instantiation' and 'Destroy' calls during intense gameplay.

A prefab is a reusable asset template of a GameObject or Actor, including its components, property values, and child objects. Changes made to the master prefab can be applied to all instances of it throughout the game world, ensuring consistency.

Instantiation is the process of creating a live copy of a prefab or class during runtime and placing it into the active scene (e.g., spawning an enemy or a projectile).

Serialization is the process of converting complex data structures (like an object's state or inventory) into a format (like JSON, XML, or Binary) that can be easily stored on a disk or transmitted over a network and later 'deserialized' back into the original object.

A scene (Unity) or Level (Unreal) is a container for a specific portion of the game world. It includes the environment, lights, cameras, and game objects needed for a particular part of the game (e.g., a main menu, a loading screen, or a specific level).

Scene management involves the loading, unloading, and transitions between different scenes in a game. It ensures that the memory is cleared when moving between levels and that the transition feels smooth to the player.

Additive loading allows multiple scenes to be loaded simultaneously into the current session without destroying the existing one. This is often used for 'World Streaming,' where different parts of a large map are loaded in the background as the player nears them.

Unity is a cross-platform game engine developed by Unity Technologies. It supports over 25 platforms, including Windows, macOS, Linux, iOS, Android, PlayStation, Xbox, Nintendo Switch, and WebGL, making it the most versatile engine for multi-platform distribution.

The Unity Editor is a visual workspace for assembling games. It allows developers to manipulate objects in a 3D/2D space, adjust component properties, manage project assets, and test gameplay in real-time through the 'Play' mode.

1. Scene: The workspace for visual editing. 2. Game: Shows exactly what the player sees. 3. Hierarchy: A list of all GameObjects in the current scene. 4. Inspector: Displays properties of the selected object. 5. Project: The library of all assets available for the game.

A GameObject is the base class for all entities in Unity scenes. It acts as a container for components; without components, it is just a point in space with a name and a tag.

A component is a functional module attached to a GameObject. For example, a 'MeshRenderer' allows an object to be seen, while a 'BoxCollider' allows it to interact with physics. All scripts in Unity are also components.

The Transform component is mandatory for every GameObject. It stores the object's Position, Rotation, and Scale in the scene and manages the parent-child relationships between objects.

World Space is the coordinate system relative to the fixed center of the game world (0,0,0). Local Space is relative to the object's parent. If a child object is at (1,0,0) in local space, it is 1 unit away from its parent, regardless of where the parent is in the world.

MonoBehaviour is the base class from which every Unity script derives. It provides access to essential lifecycle events like `Start()` and `Update()` and allows the script to be attached to GameObjects in the Inspector.

The Unity lifecycle is the specific order in which built-in event functions are called. It starts with Initialization (Awake, Start), continues to the Game Logic loop (FixedUpdate, Update, LateUpdate), and ends with Decommissioning (OnDisable, OnDestroy).

Awake() is called immediately when the script instance is loaded, even if the script is disabled. Start() is called only once, just before the first frame update, and only if the script is enabled. `Awake` is typically for internal references, while `Start` is for interacting with other scripts.

The standard order is: `Awake` -> `OnEnable` -> `Start` -> `FixedUpdate` -> `Update` -> `LateUpdate` -> `OnGUI` -> `OnDisable` -> `OnDestroy`.

1. Update: Called every frame (variable time). 2. FixedUpdate: Called at consistent intervals (fixed time), used for physics. 3. LateUpdate: Called every frame after all `Update` calls, used for camera following logic to ensure the target has already moved.

You should use `FixedUpdate` for any physics-related calculations, such as applying forces or modifying a `Rigidbody's` velocity. This ensures physics remains stable even if the frame rate fluctuates.

It is best used for Camera Follow scripts. If the player moves in `Update`, moving the camera in `LateUpdate` guarantees the camera won't 'jitter' because the player's final position for that frame is already set.

These are called whenever a script or its GameObject is toggled on or off. They are commonly used for subscribing and unsubscribing from events to prevent memory leaks.

This is called before the object is destroyed. It is the final opportunity to clean up resources, close network connections, or save specific state data before the object is removed from memory.

Destroy() removes the object at the end of the current frame (safest). DestroyImmediate() removes it instantly. The latter should generally only be used in 'Editor' scripting, as it can disrupt the execution of other scripts in a live game.

It is a method used to enable or disable a GameObject. Disabling an object makes it invisible and stops all its components (including scripts and physics) from running without removing it from the scene.

Disabling an object keeps it in memory so it can be re-enabled quickly (good for performance). Destroying it removes it from memory entirely; to get it back, you must 'Instantiate' it again, which is more CPU intensive.

A Prefab is a pre-configured template of a GameObject saved as an asset in the project. It allows you to create multiple instances of an object with the same settings, logic, and child structure.

Prefab nesting allows you to place one prefab inside another. This is powerful for modular design; for example, you can have a 'Wheel' prefab inside a 'Car' prefab. Changing the 'Wheel' prefab will update it inside the 'Car' and everywhere else it's used.

A Prefab Variant is a version of an existing prefab that inherits its base properties but allows for specific overrides. For example, you can have a base 'Enemy' prefab and create variants like 'Enemy_Red' or 'Enemy_Strong' without duplicating the entire asset.

`Instantiate()` creates a brand new object in the scene, which involves memory allocation and is slow. Pooling takes an existing disabled object from a list and enables it, which is significantly faster and prevents memory fragmentation.

A ScriptableObject is a data container that doesn't need to be attached to a GameObject. It is saved as a project asset and is ideal for storing large amounts of shared data, like item stats, level settings, or configuration profiles.

1. Memory Efficiency: Data is shared across all instances (if 1000 NPCs use the same SO, the data is stored only once). 2. Persistence: Data stays saved even when exiting 'Play' mode in the editor. 3. Decoupling: Separates data from logic.

`MonoBehaviour` requires a GameObject and runs logic every frame (`Update`). `ScriptableObject` exists independently of the scene and is used purely for data storage or architecture (like Event Systems).

Serialization is how Unity saves and restores data. When you mark a field as `[SerializeField]`, Unity 'packages' that data so it can be edited in the Inspector and saved within the scene or prefab file.

It is an attribute that forces Unity to serialize a private field, allowing it to be edited in the Inspector window without making it accessible to other C# scripts.

It is used on public fields that you don't want to appear in the Inspector window. This is useful for variables that must be public for other scripts but shouldn't be edited by designers.

It restricts a float or int variable to a specific range and creates a slider in the Inspector, ensuring that designers don't input invalid values (e.g., negative health).

[Header] adds a bold label above a field in the Inspector to help organize variables. [Tooltip] displays a small description when the mouse hovers over a field, providing documentation for designers inside the editor.

A public variable is visible in the Inspector and accessible by other scripts. A private [SerializeField] variable is visible in the Inspector but kept private from other scripts, which follows the principle of encapsulation.

A `UnityEvent` is a way to allow a script to call functions in other scripts through the Inspector, similar to how UI Buttons work. It is part of the `UnityEngine.Events` namespace.

UnityEvents are slower but appear in the Inspector, allowing non-programmers to link behaviors. C# events (actions/delegates) are significantly faster and more powerful but are handled strictly in code.

A coroutine is a function that can pause its execution and yield control back to Unity, then continue where it left off in the next frame or after a specific delay.

Coroutines use C# iterators. When a function returns `IEnumerator` and uses `yield`, Unity's engine handles the iteration of that object frame by frame based on the yield instruction provided.

`yield return null` pauses execution until the next frame. `yield return new WaitForSeconds(n)` pauses execution for approximately 'n' seconds of game time.

Coroutines are tied to the Unity lifecycle and run on the main thread. Async/await is a standard C# feature that can run on background threads, making it better for heavy tasks like web requests or complex data processing.

Use them for time-dependent logic that doesn't need to run every frame, such as fading out a screen over 2 seconds, waiting for an animation to finish, or spawning enemies in waves.

An online marketplace where developers can buy or download free 3D models, textures, animations, scripts, and full project templates to speed up their development process.

A component that puts a GameObject under the control of the physics engine. Once added, the object will respond to gravity, take part in collisions, and can have forces applied to it via scripts.

`Rigidbody` is for 3D physics (PhysX), handling 3 axes of movement and rotation. `Rigidbody2D` is optimized for 2D physics (Box2D), restricting movement to the X and Y plane.

A component that defines the physical shape of an object for the purpose of physical collisions. A Rigidbody cannot collide with anything unless it also has a Collider attached.

1. Primitive Colliders (Box, Sphere, Capsule): Computationally cheap. 2. Mesh Collider: Matches the exact shape of a 3D model; very expensive and should be avoided for moving objects.

A Collider acts as a solid physical wall. A Trigger (Is Trigger enabled) allows objects to pass through but calls an event script, commonly used for pick-ups or zone detection.

`OnCollisionEnter` is called when two solid colliders touch. `OnTriggerEnter` is called when a collider enters a space marked as a trigger.

These are called every physics frame as long as the objects remain in contact. They are more performance-heavy than the 'Enter' variants and should be used sparingly.

An asset used to adjust the friction and bounciness of colliding objects. For example, a 'Bouncy' material can make a ball bounce, while a 'High Friction' material makes a character stop on a slope.

Friction determines how much an object resists sliding across a surface. Bounciness (restitution) determines how much energy is retained after a collision.

A physics function that 'shoots' an invisible line from a point in a direction. It returns information about what it hits, used for shooting mechanics, line of sight, or detecting the ground.

`Raycast` stops at the very first object it hits. `RaycastAll` continues through everything and returns an array containing all objects that the ray passed through.

A LayerMask is used in raycasting to tell the ray to only look for specific 'layers' (like 'Enemies' or 'Ground') and ignore others, which improves both logic and performance.

A function that checks for all colliders within a spherical area. This is useful for explosion damage or detecting all enemies in an area around the player.

A setting for fast-moving objects (like bullets) that prevents them from 'tunneling' (passing through walls) between frames. It is more expensive than discrete detection.

Discrete checks for collisions only at fixed points in time. Continuous calculates the path an object traveled to see if it intersected with anything between those points.

A Rigidbody that is not affected by forces or gravity. It can only be moved via its transform or scripts. It is used for platforms or objects that need to move but still 'hit' other physics objects.

Dynamic is fully controlled by the physics engine (gravity, mass, drag). Kinematic ignores the engine's physics and is controlled purely by script logic.

A method to apply physical movement. Force modes include: `Force` (continuous), `Impulse` (instant blast), `Acceleration` (ignores mass), and `VelocityChange` (instant shift ignoring mass).

`AddForce` is a realistic way to move objects over time by adding momentum. Setting `velocity` directly is an instant change that can look 'snappy' and can break physics stability if not careful.

Joints connect two Rigidbodies together. A Hinge allows rotation like a door; a Fixed joint locks them together; a Spring keeps them at a distance with elastic tension.

A collection of Rigidbodies and Joints applied to a character's skeleton to simulate a limp, 'dead' body that responds realistically to gravity and impacts.

PhysX is the high-performance physics engine developed by NVIDIA that powers Unity's 3D physics simulation, including rigid body dynamics and cloth simulation.

They use completely different engines (Box2D vs PhysX). 2D physics assumes everything is a flat plane, while 3D physics involves volume and complex mesh calculations.

A global force applied to all non-kinematic Rigidbodies. By default, it is -9.81 on the Y-axis, simulating Earth's gravity, but it can be changed in Project Settings.

The interval at which physics calculations are performed (default 0.02s). It is independent of the frame rate to ensure consistent physics behavior across all hardware.

1. Use primitive colliders. 2. Use Layer Collision Matrix to ignore unnecessary checks. 3. Increase fixed timestep if high precision isn't needed. 4. Minimize use of Mesh Colliders.

They belong to different namespaces (2D vs 3D). `Physics2D.Raycast` returns a `RaycastHit2D` and works within the XY plane, while `Physics.Raycast` works in 3D space.

The 2D equivalent of `OverlapSphere`, it checks for all 2D colliders within a circular area on the XY plane.

A structure used in 2D physics to filter collision results by layer, trigger status, or normal angle, making queries much more efficient and specific.

A component that merges multiple 2D colliders (like tilemap pieces) into a single large collider to improve performance and prevent edges from catching on moving objects.

Unity's animation system, often called Mecanim, is a robust and flexible system for creating and managing animations. It supports animation retargeting, skeletal animation, state machines, and blend trees, allowing for complex character behaviors.

An Animation Clip is the smallest building block of animation in Unity. It contains the raw data for how properties (position, rotation, scale, or custom variables) change over time for a specific object.

The Animator component is attached to a GameObject to assign animations to it. It requires an Animator Controller to function and acts as the link between the model and the animation logic.

The Animator Controller is an asset that contains the state machine for a character. It defines which animation clips to play and how to transition between them based on parameters like speed or health.

It is a visual flowchart within the Animator Controller that manages the various states a character can be in (e.g., Idle, Run, Jump). Only one state can be active at a time.

A State is a specific animation being played. A Transition defines the rules (conditions) for moving from one state to another, such as playing a 'Jump' animation when a 'isGrounded' boolean becomes false.

A blend tree is used to smoothly mix multiple animation clips based on input parameters. For example, it can blend between 'Walk' and 'Run' based on a 'Speed' float, creating a natural transition rather than a sudden snap.

1D Blend Trees use a single parameter (e.g., Speed). 2D Blend Trees use two parameters (e.g., Horizontal and Vertical velocity) to blend animations for multidimensional movement like strafing.

Parameters are variables used to communicate from C# scripts to the Animator. Float/Int are for ranges, Bool is for persistent states, and Trigger is for one-time events like 'Death' or 'Attack'.

A Bool stays true or false until changed. A Trigger is 'consumed' by a transition; it acts like a button that resets itself once the state machine has moved to the next state.

These are C# methods used to update Animator parameters. `SetTrigger("Jump")` fires an event, while `SetBool("isCrouching", true)` maintains a state.

Animation events allow you to call a C# function at a specific point in an animation clip. Common uses include triggering footstep sounds or spawning a projectile exactly when a character's arm is extended.

Root motion allows the animation itself to drive the GameObject's world position and rotation. If an animation clip shows a character walking forward, the actual Transform of the object moves with it.

Root Motion is high-fidelity as it matches the foot-steps perfectly. Script-based (velocity/transform) is easier to control and tune but can lead to 'foot sliding' if the animation speed doesn't match the move speed.

Mecanim is the name of Unity's advanced animation engine. It introduced features like the Retargetable Humanoid system and the visual state machine editor.

Humanoid is for characters with a human structure, allowing for animation retargeting. Generic is for everything else (quadrupeds, machines) and is slightly more performant as it doesn't require a humanoid remapping layer.

An Avatar acts as a 'bridge' that maps the specific bone structure of a 3D model to Unity's standard humanoid skeleton, enabling different models to share the same animations.

Retargeting is the ability to apply the same animation clip to different characters, regardless of their height or proportions, provided they both use a Humanoid rig and Avatar.

IK calculates the joint rotations needed to place a specific body part (like a hand or foot) at a target position. It's often used to make a character's feet adjust to uneven terrain.

FK (Forward Kinematics): You rotate the shoulder, then the elbow, which moves the hand. IK (Inverse Kinematics): You move the hand, and the system automatically calculates the elbow and shoulder rotations.

Layers allow you to run multiple animations at once on different body parts. For example, a 'Base' layer for walking and an 'UpperBody' layer for aiming a gun, using a mask to separate them.

A mask defines which bones should be affected by a specific animation layer. This is used to prevent an upper-body 'wave' animation from overriding the character's legs during a 'running' state.

Additive animations add to the existing pose rather than overriding it. A common use is adding a slight 'breathing' or 'recoil' motion on top of any other animation state.

An Animator Override Controller allows you to swap out specific animation clips in a state machine without creating a new controller asset, ideal for characters with different 'flavors' of the same moveset.

These are third-party tweening engines for Unity. They allow you to animate properties (like UI position or light intensity) via C# code with high performance and ease of use.

Unity Animation is better for complex skeletal/character movements. DOTween is superior for UI transitions, simple object movements, and procedural effects due to its low overhead and code-based flexibility.

Procedural animation is generated in real-time through code rather than being pre-recorded in a clip. Examples include ragdolls, swaying trees, or procedural leg placement for a spider.

In 2D, animation is achieved by rapidly switching between different 2D images (sprites) to create the illusion of movement, much like a flipbook.

A sprite sheet is a single large texture containing multiple animation frames. Unity's Sprite Editor is used to 'slice' these into individual frames for use in the Animation window.

A technique where every frame of an animation is hand-drawn or uniquely rendered, providing a high level of artistic control, often used in pixel art or traditional 2D games.

uGUI is Unity's standard game UI system. It is component-based and built on top of the Canvas system, allowing for the creation of buttons, text, and menus that can exist in screen space or world space.

The Canvas is the root component for all UI elements. Any UI object must be a child of a Canvas to be rendered. It manages the sorting and rendering of UI elements to the screen.

Screen Space (Overlay/Camera) renders UI on top of the screen (like a HUD). World Space places UI inside the 3D scene (like a name tag above a character's head).

A component that controls the scale of all UI elements within the Canvas based on the screen's resolution and aspect ratio, ensuring the UI looks consistent on both small phones and large monitors.

This component belongs on the Canvas and is responsible for detecting if the user clicked or touched a UI element. It essentially 'listens' for interactions with Graphics (Images, Text).

The UI version of the Transform component. It allows for advanced positioning using anchors and pivots, which is necessary for UI that needs to stretch or align with screen corners.

Transform is for 3D positioning. RectTransform adds concepts like Anchors, Pivot, and SizeDelta, which allow a UI element to scale and move relative to its parent container's boundaries.

Anchors define where the UI element 'sticks' relative to the parent. Pivot defines the point around which the UI element rotates and scales.

Image is for Sprites and supports slicing (9-slicing). RawImage is for standard Textures and is generally used for displaying Render Textures or web-loaded images.

Text is the legacy system that uses pixel-based fonts. TextMeshPro is the modern standard that uses SDF (Signed Distance Field) rendering, providing crisp text at any zoom level.

1. Superior visual quality. 2. Better performance (SDF). 3. Advanced styling (outlines, shadows, glows). 4. Rich Text support. 5. Flexible font asset creation.

A UI component that provides interaction states (Normal, Hover, Pressed, Disabled) and an `onClick` event that can trigger C# functions when the user interacts with it.

Toggle is a checkbox used for On/Off settings. Slider allows users to select a value from a range, commonly used for volume or brightness settings.

A UI element that allows a user to select one option from a list. It expands when clicked to show all available options.

An area where the user can type text, used for player names, chat boxes, or search bars.

A component used to make a UI area scrollable, often used in inventory systems or shop menus to display more content than fits on the screen.

These components automatically position and size child UI elements into rows, columns, or grids, saving you from manually positioning every icon in an inventory.

A component that adjusts the size of a RectTransform automatically based on its content, such as a text box that expands as you type more words into it.

Ensures that a UI element maintains a specific width-to-height ratio, regardless of how the screen or parent container is scaled.

The Event System manages all user input for the UI. It bridges the gap between the platform's input (mouse/touch) and the UI elements' responses (clicks/drags).

These are events triggered by the Event System when a user interacts with a UI element. PointerDown occurs when the button is first pressed, PointerUp when released, and PointerClick when a full down-and-up cycle is completed on the same object.

It is a C# interface that allows a script to detect and respond to click events directly. By implementing `public void OnPointerClick(PointerEventData eventData)`, the script becomes a listener for that specific UI element without needing a Button component.

Button.onClick is a high-level UnityEvent that only works with the Button component. IPointerClickHandler is a low-level interface that can be used on any UI graphic (Image, Text) to detect clicks, providing more granular data like which mouse button was used.

Similar to object pooling, UI pooling reuses UI elements like inventory slots or chat messages. Instead of destroying a slot when an item is removed, it is disabled and moved to a 'pool' to be reused for the next item, avoiding expensive layout recalculations.

Optimization involves minimizing 'Rebuilds'. When one element in a Canvas changes, the entire Canvas often has to re-batch its geometry. To optimize, we separate static UI and dynamic UI into different Canvases to limit the scope of these rebuilds.

Rebatching is the process where the Canvas combines UI meshes into batches to reduce draw calls. This happens whenever a UI element is enabled, disabled, or moved. Excessive rebatching (dirtying the canvas) is a common cause of CPU spikes in mobile games.

Using one canvas is simpler but causes a full rebuild if any single element moves. Multiple canvases allow you to isolate frequently changing elements (like a health bar) from static ones (like a background), significantly improving performance through isolation.

Masking allows you to hide parts of a UI element that fall outside a specific area. It is commonly used for circular character portraits or scroll views where content should only be visible within the window.

Mask uses the GPU stencil buffer and is better for non-rectangular shapes. RectMask2D is CPU-side, faster, and more efficient for rectangular areas (like ScrollRects) because it doesn't require extra draw calls for the stencil.

1. Use TextMeshPro for crisp text. 2. Set the Canvas Scaler to 'Scale With Screen Size'. 3. Avoid 'Layout Groups' at runtime if possible (they are heavy). 4. Use small, optimized sprite atlases. 5. Disable 'Raycast Target' on non-interactive images.

The rendering pipeline is the sequence of operations that takes the 3D data of a scene and outputs it as pixels on the screen. Unity offers three: the Built-in pipeline, and the Scriptable Render Pipelines (URP and HDRP).

Unity's legacy rendering system. It is limited in terms of customization but is very stable. It is slowly being replaced by URP and HDRP for all new projects.

URP is a high-performance Scriptable Render Pipeline designed for a wide range of platforms, from mobile and VR to high-end PCs. It focuses on scalability and efficiency.

HDRP is designed for high-end hardware (PC, Consoles) where visual fidelity is the priority. It supports advanced features like ray tracing, volumetric clouds, and physically-based lighting for photorealistic results.

URP is optimized for 'performance and reach' (mobile/switch/light PC). HDRP is optimized for 'photorealism and fidelity' (PS5/High-end PC). They are not compatible, so choosing one at the start of a project is critical.

Use URP for mobile games, stylized graphics, or VR. Use HDRP for triple-A quality games where you need photorealistic lighting, complex materials, and have the hardware power to support it.

A shader is a program that runs on the GPU. It determines how pixels are colored based on light, textures, and geometry data. Shaders are the code behind the visual appearance of every object in a game.

A Shader is the actual code (logic). A Material is an instance of that shader with specific data plugged in, such as a particular texture, color, or metallic value.

A visual tool in Unity that allows developers to create shaders by connecting nodes instead of writing code (HLSL). It makes shader creation accessible to artists and designers.

Vertex Shaders process the 3D position of each vertex in a mesh. Fragment (Pixel) Shaders calculate the final color of each pixel after the geometry has been projected onto the screen.

A higher-level way of writing shaders in Unity's Built-in pipeline. It handles complex lighting calculations automatically, allowing the developer to focus on surface properties like color and shine.

Lit Shaders react to lights in the scene (shadows, highlights). Unlit Shaders ignore light entirely and simply display the texture or color, making them very cheap and perfect for UI or emissive effects.

PBR is a shading model that simulates how light interacts with materials in the real world. It uses physical properties like energy conservation and microfacet theory to achieve realistic results across different lighting conditions.

An Albedo map is the base color of a material without any lighting or shadows. In PBR, it represents the pure diffuse reflectance of the surface.

A texture that adds the illusion of high-resolution geometric detail (like bumps, scratches, or depth) to a low-poly mesh without adding extra polygons. It works by altering how light reflects off the surface.

Metallic Maps define which areas are metal (black and white). Specular Maps define the color and intensity of the reflection. Standard PBR uses either the 'Metallic' or 'Specular' workflow.

Determines how light spreads across a surface. A Rough surface (high value) diffuses light widely, looking matte. A Smooth surface reflects light sharply, looking shiny or like a mirror.

A map or effect that simulates soft shadows in crevices, holes, and areas where objects are close together. It adds depth and realism by darkening areas where light has difficulty reaching.

A map that tells the shader which parts of the material should glow or act as a light source. It is used for glowing lights on a robot, neon signs, or lava.

A single large texture that contains many smaller textures. Using an atlas reduces draw calls because multiple objects can share the same material and texture, improving performance.

The 2D equivalent of a texture atlas. Unity's Sprite Packer automatically combines individual 2D sprites into a single atlas at build time to optimize rendering.

A technique where Unity generates smaller, lower-resolution versions of a texture. The engine uses the smaller versions when an object is far away, reducing GPU memory bandwidth and preventing 'shimmering' artifacts.

Reducing the file size of textures so they fit into GPU memory. Common formats include ASTC for mobile or BC7 for PC. Choosing the right compression is the #1 way to reduce game memory usage.

Point (No filtering) looks pixelated. Bilinear smooths the texture. Trilinear smooths the transition between mipmap levels, preventing noticeable lines on surfaces as they recede into the distance.

Enhances the visual quality of textures when viewed at steep angles (like a road extending to the horizon). It preserves detail that would otherwise be blurred by standard mipmapping.

1. Directional: Simulates the sun (infinitely far away). 2. Point: Simulates a lightbulb (glows in all directions). 3. Spot: Simulates a flashlight (cone-shaped beam).

Real-time lighting is calculated every frame (expensive, allows movement). Baked lighting is pre-calculated and stored in textures called 'Lightmaps' (cheap, static only).

The process of calculating the effects of lights on static surfaces and 'baking' that information into textures. This allows for complex lighting and shadows without any runtime CPU/GPU cost.

A system that simulates how light bounces off surfaces onto other surfaces (indirect lighting). It creates realistic environments where a red wall can reflect a red tint onto a white floor.

Light probes capture baked lighting information in empty space. This allows dynamic (moving) objects to 'receive' the baked light from the environment so they don't look out of place.

Captures a 360-degree view of its surroundings and provides it as a cube map to shiny objects. This allows a metal sphere to 'reflect' the room it is in.

A panoramic texture that wraps around the entire scene, representing the distant horizon, sky, and atmosphere. It provides the background and ambient light for the world.

A component that captures the world and displays it to the screen. It defines what the player sees, the background color, the clipping planes, and the rendering technique.

Perspective mimics the human eye (objects get smaller as they get further away). Orthographic keeps all objects the same size regardless of distance, common in 2D or isometric games.

The width of the camera's 'viewing cone'. A higher FOV shows more of the world but can cause distortion (fish-eye effect) at the edges of the screen.

These define the distance range within which the camera renders objects. Anything closer than the Near plane or further than the Far plane is not drawn.

A shortcut in C# that returns the first enabled camera tagged as 'MainCamera'. In modern Unity, it is better to cache this reference instead of calling it every frame for performance.

Using multiple cameras at once. For example, one camera to render the 3D world and another to render the UI, or for split-screen multiplayer where each camera renders to half the screen.

A special type of texture that is updated at runtime by a camera. Instead of rendering to the screen, the camera renders into the texture, which can then be used on a material (e.g., for a security camera monitor).

The process of applying image filters and effects to the final rendered image before it is displayed. Effects include bloom, vignette, and depth of field.

Bloom makes bright areas glow. Color Grading adjusts the color and luminance to achieve a specific 'look' (like cinematic filters). Depth of Field blurs the background or foreground to simulate a camera lens focusing on a specific subject.

Techniques to remove 'jaggies' (jagged edges). MSAA is high quality but expensive (forward rendering only). FXAA is fast and blurry. TAA uses previous frames to smooth edges and is the standard for modern high-end games.

A component used to simulate fluid and fuzzy phenomena like smoke, fire, sparks, and leaves. It emits hundreds of small 2D or 3D images and moves them according to rules defined in its modules.

The core component in Unity's 'Shuriken' system. It manages the lifecycle, physics, and rendering of individual particles based on settings like lifetime, speed, and color over time.

Emission controls how many particles are created. Shape defines the volume they spawn from (e.g., Cone, Sphere). Renderer determines how the particles look and which material they use.

A rendering technique that draws many instances of the same mesh with the same material in a single draw call. This is essential for rendering thousands of identical objects like grass, trees, or bullets.

Static batching combines non-moving meshes into one large mesh at build time. Dynamic batching groups small moving meshes on-the-fly at runtime. Both reduce the number of draw calls sent to the GPU.

A feature in URP and HDRP that speeds up CPU rendering by caching and reusing GPU commands for objects using the same shader, even if they have different material properties.

A feature that prevents Unity from rendering objects that are completely hidden behind other solid objects (occluders). This saves GPU time in dense environments like cities or indoor hallways.

The automatic process where Unity only renders objects that are inside the camera's viewing 'frustum' (the pyramid-shaped field of vision). Anything outside this cone is not sent to the GPU.

A component attached to a GameObject that plays back an AudioClip in the 3D scene. It controls volume, pitch, and spatial settings (2D vs 3D).

A component (usually on the Main Camera) that acts as the 'ears' of the game. It receives all audio from AudioSources in the scene and outputs it to the user's speakers.

The container for audio data. It can hold a variety of formats like .wav, .mp3, or .ogg, and can be configured to be compressed in memory or streamed from disk.

2D Audio plays at a constant volume regardless of position (UI sounds, background music). 3D Audio changes in volume and panning based on the distance and angle between the AudioSource and AudioListener.

A slider on the AudioSource that determines how much the sound behaves as 2D (global) vs 3D (positional). 0 is fully 2D, and 1 is fully 3D.

The change in pitch of a sound caused by the relative motion between the source and the listener, such as the rising and falling pitch of a passing car siren.

An asset that allows you to group audio sources, apply effects (reverb, echo), and control the relative volumes of different categories like 'Music,' 'SFX,' and 'Voice.'

A specific channel within the Audio Mixer. You can route multiple AudioSources to one group to apply the same volume or effects to all of them at once.

A technique where the volume of one audio group (like music) is automatically lowered when another group (like dialogue) starts playing, ensuring clarity for important sounds.

An area in the 3D world that applies a reverb effect to any sound played within it, used to simulate different environments like caves, halls, or small rooms.

A phenomenon where sound is muffled or blocked by solid objects (like walls) between the source and the listener. It is usually implemented via raycasting and low-pass filters.

`Play()` starts the source and stops any currently playing sound on it. `PlayOneShot()` plays a sound without stopping the previous one, making it ideal for overlapping sounds like machine gun fire.

1. Use Compressed In Memory for small SFX. 2. Use Streaming for long music tracks. 3. Reduce the sample rate for sounds that don't need high fidelity. 4. Use mono instead of stereo where possible.

Streaming reads from the disk in real-time (saves RAM). Decompressed loads the full uncompressed sound into RAM (high speed, high memory usage).

Unity Audio is built-in and basic. FMOD is a specialized audio middleware that provides advanced tools for sound designers, like complex event triggering and dynamic mixing that scales across platforms.

An industry-standard audio engine used in AAA games. It allows for highly complex interactive audio systems and superior optimization compared to standard engine-native audio.

Music that changes dynamically based on gameplay. For example, adding heavy drums when the player enters combat or removing instruments when their health is low.

A setting that determines which sounds are killed first if the number of simultaneous sounds exceeds the hardware limit. Background wind should have low priority; player gunshots should have high priority.

Reusing AudioSource objects to avoid the CPU cost of creating and destroying them. When a sound finishes, the object is disabled and returned to a 'pool' for future use.

Usually implemented by detecting 'Animation Events' on the walk cycle. The script raycasts down to detect the ground's 'Tag' (Wood, Stone, Water) and plays the corresponding clip from a library.

The Input Manager is simple but restricted. The Input System is event-driven, handles multiple devices easily, supports rebindable keys, and is much more scalable for modern games.

`GetKey` returns true every frame the key is held. `GetKeyDown` returns true only for the single frame the key was first pressed.

Returns a value from -1 to 1 based on axis input (like A/D or Left/Right arrows). It includes 'Smoothing' by default, which simulates the travel time of an analog stick.

Detects mouse clicks. 0 is Left-click, 1 is Right-click, and 2 is Middle-click.

Uses `Input.GetTouch(index)` to access data from mobile screens, providing info on touch position, phase (Began, Moved, Ended), and pressure.

The ability to track multiple fingers on the screen simultaneously by iterating through the `Input.touches` array, allowing for complex gestures like pinch-to-zoom.

Sensors on mobile devices. Gyroscope measures rotation/orientation. Accelerometer measures the force of acceleration (motion/tilt).

An optional package that uses an action-based approach. Instead of checking for 'Space,' you check for the action 'Jump,' allowing the user to map that action to any key or button.

A file in the new Input System that maps physical controls (Mouse, Keyboard, Gamepad) to logical actions (Move, Fire, Interact).

A high-level component that links a specific Input Action Asset to a GameObject and handles the dispatching of events to your C# scripts.

A group of bindings for a specific hardware set (e.g., 'Keyboard&Mouse' vs 'Gamepad'). The Input System can switch schemes automatically when a device is plugged in.

Allowing the player to change their key mappings. The new Input System makes this easy by allowing you to update 'Bindings' at runtime and save them as JSON.

Unity handles most controllers (Xbox, DualShock) via a standardized map, ensuring that 'Button South' works correctly regardless of the specific controller brand.

A UI-based input method where the user drags a circle on the screen to simulate an analog stick. It usually sends values to the 'Move' action in the input system.

Using the vibration motors in controllers or mobile devices to provide physical feedback to the player, such as a rumble when they take damage.

Storing a user's input for a short window (e.g., 0.1s). If a player hits 'Jump' just before they touch the ground, the game 'remembers' it and jumps immediately upon landing.

Polling checks every frame (`Update`). Event-driven (New System) only runs your code when the input actually changes, which is more efficient and cleaner.

The new Input System tracks 'Devices' separately. You can assign 'Player 1' to the Keyboard and 'Player 2' to a Gamepad by managing `InputUser` instances.

Writing code that checks for logical actions (e.g., 'Attack') rather than specific hardware (e.g., 'Left Mouse Button'), allowing the game to run on PC and Console without logic changes.

A structure passed to event listeners in the new Input System that contains data about the input, such as its value (vector2, float) and its state (Started, Performed, Canceled).

NavMesh (Navigation Mesh) is a simplified geometric representation of the walkable surfaces in a game world. It is used by the navigation system to calculate paths for AI characters, allowing them to avoid obstacles and navigate complex environments effectively.

The NavMeshAgent is a component attached to a GameObject that allows it to move on a NavMesh. It handles pathfinding, obstacle avoidance, and movement logic, automatically calculating the best route to a target destination.

Baking is the pre-computation process where Unity analyzes the scene's static geometry to generate the NavMesh. During this process, Unity determines which areas are traversable based on settings like agent height, radius, and maximum slope.

A component used to define objects that the NavMeshAgent should avoid. Obstacles can be static or dynamic; dynamic obstacles move during runtime and force agents to recalculate their paths in real-time.

An Off-Mesh Link creates a shortcut between two disconnected parts of a NavMesh. It is used to represent actions like jumping over a gap, climbing a ladder, or dropping down from a ledge that aren't part of a continuous walking surface.

Areas allow you to classify different parts of the NavMesh (e.g., 'Water', 'Road', 'Mud'). Costs define how 'expensive' it is for an agent to move through those areas. Agents will prefer lower-cost areas (Road) over higher-cost ones (Mud) even if the path is longer.

Static obstacles are part of the pre-baked NavMesh. Dynamic obstacles (NavMeshObstacle component) exist at runtime; if 'Carving' is enabled, they cut a temporary hole in the NavMesh as they move.

Carving is a feature of the NavMeshObstacle component that creates a temporary hole in the NavMesh. When a carved obstacle is stationary, the agents treat that area as non-walkable, allowing for smarter pathfinding around moving or temporary objects.

A* (A-Star) is a popular pathfinding algorithm that finds the shortest path from a start point to a destination. It uses a heuristic to estimate the cost to the goal, balancing the distance already traveled with the estimated distance remaining.

Dijkstra's is a foundational algorithm for finding the shortest path between nodes in a graph. Unlike A*, it does not use a heuristic, meaning it explores all directions equally until it reaches the goal, making it slower but guaranteed to find the absolute shortest path.

A* uses a heuristic (an educated guess) to reach the goal faster by prioritizing nodes closer to the destination. Dijkstra explores every node in order of its distance from the start without a sense of 'direction.'

A heuristic is an estimate function (like Manhattan or Euclidean distance) used in A* to predict the cost from a given node to the goal. It helps prune the search space, allowing the AI to reach the destination with fewer calculations.

A simpler alternative to NavMesh where an AI follows a sequence of pre-defined points in space. This is often used for patrol routes, racing line markers, or scripted events where high-precision navigation isn't required.

A behavior tree is a hierarchical model used to design complex AI logic. It consists of nodes (Sequence, Selector, Task) that evaluate conditions and execute actions, allowing for modular and reactive AI behaviors like 'Patrol until enemy seen, then Chase.'

An FSM is a model where an AI can be in exactly one state at a time (e.g., Idle, Attack, Flee). Transitions occur based on events. While simple to implement, FSMs can become difficult to manage ('spaghetti logic') as AI complexity increases.

FSMs are state-centric and handle simple linear transitions. Behavior Trees are task-centric and hierarchical, making them much more scalable for complex AI that needs to prioritize multiple goals or interrupt actions.

An AI behavior that simulates the collective movement of a group (like birds or fish). It relies on three simple rules: Separation (avoid crowding), Alignment (match heading), and Cohesion (stay close to the center).

Steering behaviors are algorithms that calculate a 'steering force' to move an agent smoothly. Instead of instantly snapping to a direction, the agent gradually turns and accelerates, creating more natural, lifelike movement.

1. Seek: Move toward a target. 2. Flee: Move away from a target. 3. Arrive: Move toward a target but slow down as the agent gets closer to stop precisely at the destination.

Modern enemy AI usually combines a Behavior Tree for decision making, a NavMesh for movement, and a Perception System for sensing the player through sight and sound.

A perception mechanic that simulates an AI's eyesight. It is usually implemented using a dot product check (angle) and a distance check, followed by a raycast to see if the player is hidden behind an object.

A perception mechanic where the AI detects 'noise events' (like footsteps or gunshots) within a certain 3D distance. This allows the AI to investigate a location without actually seeing the player.

The process of adjusting AI attributes (HP, damage, accuracy, reaction time) based on the player's performance or a selected difficulty level to ensure the game remains challenging but fair.

A delay added to AI decision-making to simulate human-like behavior. Instead of reacting instantly to the player appearing, the AI might wait 0.5 seconds before it starts shooting or chasing.

The process where the AI evaluates the current world state (player distance, health, ammo) and chooses an action. Techniques include Behavior Trees, Utility AI, or GOAP.

Utility AI (or Mathematical AI) assigns a numeric 'score' to every possible action. The AI then performs the action with the highest score. For example, if health is low, 'Find Health Pack' gets a high utility score.

GOAP is an AI architecture where the agent is given a goal (e.g., 'Kill Player') and it dynamically generates a plan (a sequence of actions like Find Weapon -> Load Ammo -> Shoot) based on the current environment state.

Using Neural Networks and Reinforcement Learning to 'train' an AI through trial and error. Instead of hard-coding rules, the developer defines rewards for good behavior and penalties for bad behavior.

Unity's open-source toolkit that allows developers to train intelligent agents using Reinforcement Learning through an integration with Python and TensorFlow/PyTorch.

A subset of Machine Learning where an agent learns by interacting with its environment. It receives positive 'rewards' for achieving goals (winning a level) and 'penalties' for failures (dying), gradually optimizing its policy to maximize the total reward.

Unreal Engine (UE) is a professional-grade game engine developed by Epic Games. Significant versions include UE4 (known for Blueprints) and the current UE5, which introduced groundbreaking tech like Nanite (virtualized geometry) and Lumen (dynamic global illumination).

Blueprint is Unreal's visual scripting system. It uses a node-based interface to create gameplay logic, allowing designers to build complex systems without writing a single line of C++ code.

Blueprints are visual, easier for designers, and faster to iterate with, but have a higher performance overhead. C++ is more powerful, offers better performance, and provides deeper access to the engine's core functionality.

Use C++ for core systems, heavy math, and performance-critical logic. Use Blueprints for high-level gameplay logic, UI, prototyping, and making visual/cosmetic tweaks that designers need to access easily.

It is the specific implementation of node-based programming in Unreal. Every node represents a function or variable, and they are connected by 'wires' to define the flow of execution and data.

An Actor is the base class for any object that can be placed in a level. Unlike Unity's GameObject, an Actor can natively support networking, replication, and basic transformations.

A Pawn is an Actor that can be 'possessed' and receive input from a controller (AI or Player). A Character is a specialized type of Pawn that includes a 'CharacterMovementComponent' for complex movement like walking, jumping, and swimming.

A Character is a more complex version of a Pawn that comes pre-packaged with a collision capsule, a skeletal mesh, and most importantly, the Character Movement Component, which handles walking, physics, and networking out of the box.

A non-physical Actor that possesses a Pawn or Character to control its actions. It acts as the 'brain' of the entity.

A specific type of Controller that represents a human player. It maps player input (mouse, keys, gamepad) to actions performed by the possessed Character.

A Controller used for non-player entities. It typically uses Behavior Trees or Blackboards to make decisions and navigate the world automatically.

Components are modular pieces of functionality that can be added to Actors. Examples include 'StaticMeshComponent' for visuals and 'AudioComponent' for sound.

An ActorComponent is for data and logic (no physical presence). A SceneComponent is an ActorComponent that has a Transform (Position, Rotation, Scale) and can be attached to other physical objects.

The component used to render a piece of 3D geometry that doesn't have an internal skeleton (e.g., a rock, a chair, or a building).

Used for 3D models with an internal bone structure (Skeleton), enabling complex animations like a character running or a monster attacking.

A Level is a user-defined area of gameplay. It contains all the Actors, lighting, and world geometry for that specific part of the game.

A legacy system in UE4 for managing large open worlds. It breaks the world into smaller levels that are loaded and unloaded based on the player's distance.

A technique that allows the engine to load and unload levels in the background while the player is moving, ensuring a seamless experience without loading screens.

The modern UE5 replacement for World Composition. It treats the entire world as one large map and automatically handles loading/unloading of small grid 'cells' and Actors based on distance.

World Composition requires manual level management and file splitting. World Partition is an automated grid-based system that uses a single persistent world file, making it much easier to collaborate on massive maps.

A Blueprint Class is a template for creating new Actors. It allows you to combine a mesh, variables, and logic into a single reusable asset. For example, you can create a 'HealthPickup' Blueprint class and place 50 instances of it in your level.

The Level Blueprint is a specialized Blueprint that exists for every level. It is used for events specific to that map, such as triggering a cinematic when a player enters a room or handling unique puzzle logic that won't be used elsewhere.

Blueprint Classes are reusable templates used for actors (Enemies, Bullets). The Level Blueprint is unique to a specific level and is used to control level-wide events. You cannot spawn a Level Blueprint in another map, but you can spawn Blueprint Classes anywhere.

The Event Graph is the workspace in a Blueprint where you create the runtime logic. It uses nodes like `BeginPlay` or `Tick` as entry points to execute a chain of functions and events.

The Construction Script runs whenever an Actor is created or moved in the editor. It is used for procedural setup, such as changing a light's color based on a variable or randomly placing plants around a house during design time.

The Construction Script runs in the editor while you are building the level (before the game starts). The Event Graph runs during gameplay (after you press Play).

A fundamental node that executes exactly once as soon as the Actor is spawned or the level begins. It is the best place to initialize variables or start initial logic like spawning an AI's weapon.

A node that executes every single frame. It is used for logic that needs constant updates, like a hovering platform. However, excessive use of Tick can significantly harm performance.

Tick runs as fast as the frame rate allows (unpredictable). Timers can be set to run at specific intervals (e.g., every 0.5 seconds) and can be stopped or paused, making them much more efficient for most gameplay logic.

An Event Dispatcher is a communication tool that allows an Actor to 'shout' an event (Broadcast), and any other Actor 'listening' (Bind) can react to it. It is perfect for a Boss dying and multiple UI elements or gates reacting simultaneously.

An Interface defines a set of functions with no implementation. Different Blueprints can implement this interface to perform unique actions when called. For example, an 'Interact' interface allows a 'Door' to open and a 'Light' to toggle when the player interacts with them.

A static collection of functions that can be called from any Blueprint in the project. It is used for common logic like calculating experience points or formatting time strings that many different actors need.

A Macro is a reusable set of nodes that are collapsed into a single node. Macros can have multiple input and output execution pins, unlike standard functions.

Functions have a single execution path, can be called from other Blueprints, and can be overridden. Macros can have complex branching (multiple outputs), but they only exist within the Blueprint they are defined in (unless in a Macro Library).

Impure functions have execution pins (wires) and can change the state of the world. Pure functions (no wires) only return data and do not modify variables, typically used for math or data checking.

A small visual node used to organize 'spaghetti' wires in the Blueprint graph. It allows you to clean up the visual flow without changing the logic.

A control flow node that executes its output pins in order (0, then 1, then 2). It is used to perform multiple unrelated actions from a single event without having a long, horizontal chain of nodes.

The 'if statement' of Blueprints. It checks a boolean value and directs the execution flow down either the 'True' or 'False' path.

A data node that chooses an input based on a key (like an index or enum). It is very efficient for choosing between multiple values (e.g., choosing a mesh based on an 'EnemyType' enum).

A loop node used to iterate through an Array. For every item in the list, it executes the 'Loop Body' until the array is finished, then executes 'Completed.'

A flow control node that ensures its output logic is only triggered once. It can be reset via a separate input pin to allow the logic to run again.

A node that alternates between two execution paths (A and B). The first time it is called, it runs A; the second time, it runs B.

A node that allows execution to pass through only when it is 'Open.' It can be opened, closed, or toggled via different input pins, often used for enabling/disabling player input during a cutscene.

A node that rotates through multiple execution outputs. It can be set to loop or to trigger outputs in a random order.

A specialized node that provides time-based animation logic. It allows you to create curves (Float, Vector, Color) that change over time, perfect for smooth door rotations, light flickering, or simple UI fades.

A graph inside the Timeline that defines how a value changes from 0 to 1 (or any range). You can add 'keys' to the curve to create smooth interpolation like 'Ease-In/Ease-Out.'

A mathematical function that blends between value A and value B based on an 'Alpha' (0 to 1). If Alpha is 0.5, Lerp returns the exact middle value. It is essential for smooth movement and color transitions.

Pauses the execution of the current flow for a specified amount of time. It is 'latency-aware,' meaning it doesn't freeze the whole game, just that specific chain of nodes.

Similar to a Delay, but if the node is called again before the timer finishes, it resets back to the full duration. This is commonly used for UI elements that should hide after 2 seconds of inactivity.

Variables are properties that hold data, such as Health (Float), Ammo (Int), or Name (String). They can be private or made 'public' to be editable in the editor details panel.

Instance Editable allows the variable to be changed for each specific Actor placed in the level. Blueprint Read Only means the variable can be seen by other Blueprints but can only be changed inside its own Blueprint.

A variable setting that makes it appear as an input pin on the 'SpawnActorFromClass' node. This allows you to pass data (like Health or Color) into an Actor at the exact moment it is created.

Get reads the current value of a variable. Set overwrites the current value with a new one.

Passing by Copy sends a duplicate of the data (safe but uses memory). Passing by Reference sends a link to the original data, allowing the receiving function to modify the original value directly.

A node used to check if an object is of a specific type. For example, 'Cast to PlayerCharacter' allows you to access the specific health variable on the player actor. It is essential for Blueprint communication.

The three main ways Blueprints talk to each other are: 1. Direct Communication (Reference). 2. Blueprint Interfaces (Generic). 3. Event Dispatchers (One-to-Many).

When Actor A has a variable containing a direct reference to Actor B. This is the most straightforward method but creates 'Hard References' that can increase memory usage.

A 'Listen-and-React' system. It is best used for decoupled systems where the Actor performing the action doesn't need to know who is reacting to it.

The most modular method. It allows you to call a function (e.g., 'TakeDamage') on any Actor without needing to know exactly what class that Actor is.

A node that finds every instance of a specific class in the world and returns them as an array. It is computationally expensive and should be avoided in loops or on Tick.

UObject is the absolute base class for almost everything in Unreal Engine. It provides essential engine features like Metadata, Reflection, Serialization, and Garbage Collection.

AActor is a child of UObject that can be placed or spawned in the world. Only Actors can have components and physical transforms.

APawn is an Actor that can be possessed by a controller. ACharacter is a Pawn that includes specialized movement logic (walking, falling) and a Skeletal Mesh.

The base class for components. It handles logic that can be shared across different types of Actors. For example, a 'HealthComponent' could be added to both an Enemy and a Destructible Wall.

A macro placed above C++ variables to make them visible to Unreal's Reflection system. This allows the variable to be seen in the Editor, saved to disk, and managed by Garbage Collection.

A macro used above C++ functions. It allows functions to be called from Blueprints, treated as RPCs for networking, or used as timed callbacks.

A macro used at the top of a class definition. It tells the Unreal Header Tool (UHT) that this class is part of the engine's object system and should be included in the Reflection system.

A regular variable is unknown to the engine; it cannot be edited in the editor and can be deleted by Garbage Collection if it's a pointer. A UPROPERTY is protected and integrated into the engine's automation tools.

BlueprintReadWrite allows a variable to be both 'Get' and 'Set' in a Blueprint. BlueprintReadOnly only allows it to be 'Got' (read only), which is safer for variables like 'CurrentHealth' that should only be changed by C++ logic.

EditAnywhere allows the value to be changed in the Inspector. VisibleAnywhere shows the variable but prevents editing, typically used for components that are created in the constructor.

A string used to group variables in the details panel (e.g., Category="Combat"). This keeps the Inspector organized for designers.

Allows a private C++ variable to be visible and editable in Blueprints. This maintains good C++ encapsulation while still providing flexibility to designers.

The virtual function called when the Actor first enters the game. It is the C++ equivalent of the BeginPlay node in Blueprints.

The function called every frame on an Actor. In C++, you must explicitly enable 'bCanEverTick = true' in the constructor for this to run.

A function in the Pawn/Character class where you bind input actions (like 'Jump' or 'MoveForward') to specific C++ functions.

A function that returns a pointer to the UWorld object the Actor belongs to. This is required for spawning other Actors, setting timers, or performing line traces.

The function used to instantiate a new Actor into the world during runtime: `GetWorld()->SpawnActor<AMyActor>(Class, Location, Rotation)`.

A template class used to restrict a variable to a specific class or its children. It creates a dropdown in the editor allowing designers to pick a Blueprint Class (e.g., choosing which Bullet class a Gun fires).

Unreal's dynamic array class. It is similar to `std::vector` but integrated with the engine's reflection and memory systems.

A collection of Key-Value pairs. It is used for fast lookups, such as mapping an 'ItemName' (Key) to an 'ItemStruct' (Value).

A collection of unique elements. It is used when you need to store a list of items where duplicates are not allowed and order doesn't matter.

TArray is optimized for Unreal Engine, supports Garbage Collection, and uses Unreal's specific memory allocators. std::vector is standard C++ and should generally be avoided in Unreal gameplay code to maintain compatibility with the engine's object system.

FString is for manipulatable strings (the heaviest). FName is an immutable, case-insensitive ID used for fast lookups. FText is for user-facing text and handles localization/translation automatically.

FVector stores 3 floats (X, Y, Z) for position or direction. FRotator stores 3 floats (Pitch, Yaw, Roll) for 3D rotation.

A combination of FVector (Location), FRotator (Rotation), and FVector (Scale). It represents the complete spatial state of an object.

A struct returned by physics queries (Line Traces/Raycasts). It contains data about the collision, such as which Actor was hit, the impact point, and the surface normal.

The C++ equivalent of a Raycast. It shoots a line through the physics world and returns the first object hit that matches a specific collision channel (like 'Visibility').

Similar to a Line Trace, but instead of a line, it 'sweeps' a 3D shape (like a sphere or capsule) through the world. This is more accurate for detecting if a character can fit through a gap.

A powerful static library in C++ providing access to common game functions like spawning sounds, playing particles, getting the player character, or opening levels.

A dynamic casting function used to convert a generic pointer to a specific class. If the cast fails (the object is not of that type), it returns `nullptr` safely.

A 'Weak Pointer' that does not prevent an object from being Garbage Collected. It is used to reference Actors that might be destroyed, allowing you to check `IsValid()` before using them.

The automatic system that deletes UObjects from memory once they are no longer referenced by any UPROPERTY. It prevents memory leaks by cleaning up 'orphaned' objects.

NewObject is for creating data UObjects (Inventories, Stats). SpawnActor is for placing AActor types (Characters, Lights) physically into a world.

A namespace used inside the C++ constructor to find and load assets (like a Mesh or Material) from the project files: `ConstructorHelpers::FObjectFinder<UStaticMesh>...`.

The function used in the C++ constructor to create and attach components to an Actor, such as the camera or the visual mesh.

The .h (Header) file contains the declarations (the 'what'—variables and function signatures). The .cpp (Source) file contains the implementation (the 'how'—the actual logic code).

Declaring a class name (e.g., `class AMyActor;`) in a header file instead of including its full header. This reduces compile times and prevents circular dependency errors.

Unreal is organized into Modules (independent DLLs). A project can have multiple modules to separate core engine code from gameplay code or editor-only tools.

Hot Reload compiles and swaps code while the editor is open (can be unstable). Live Coding is the modern UE5 standard that patches binary changes into memory, providing a much faster and safer iteration cycle for C++.

A custom program that handles the complex compilation of Unreal's C++ code, making sure the Reflection system (UHT) is updated before the standard C++ compiler runs.

A specialized Blueprint used to control the animation of a Skeletal Mesh. It manages the State Machine, Blending, and Inverse Kinematics for a character.

A 3D model that contains a skeleton (bones). This allows the mesh to be deformed and moved by animations.

The data asset that defines the bone hierarchy. Multiple characters can share the same Skeleton asset, allowing them to share animations (Retargeting).

A single piece of animation data, like a 'Walk' or 'Jump' cycle, imported from an external 3D software like Blender or Maya.

An asset that blends multiple animations based on input values. For example, it can blend between Idle, Walk, and Run based on the character's 'Speed' variable.

1D blends along one axis (Speed). 2D blends along two axes (Speed and Direction), used for strafing/running in 8 directions.

Montages allow you to play a specific animation on top of a character's state machine, such as a 'Sword Swing' or 'Reload.' They support 'Sections' for looping or jumping between parts of an animation.

Slots are defined 'channels' in the Animation Blueprint (e.g., 'DefaultSlot', 'UpperBody'). They determine where a Montage will be played and blended with the base animation.

A 'marker' placed in an animation timeline that triggers an event in code. Used for playing footstep sounds or spawning particle effects at a specific frame.

Similar to a Notify, but it has a 'Begin' and 'End.' It is used for actions that last a duration, such as a character being immune to damage during a specific part of a roll animation.

A visual graph that defines the 'Logic flow' of character animations, such as transitioning from 'Falling' to 'Landing' based on the character's movement state.

A boolean check inside the State Machine that determines if a character can move from one animation state to another (e.g., IsVelocity > 0).

A specialized state that can have multiple inputs and outputs. It is used to simplify complex transition logic where one event could lead to many different animation states.

A system that allows you to separate animation logic into pieces (e.g., 'Locomotion Layer', 'Weapon Layer'), making complex Animation Blueprints much easier to manage.

A node that blends two animations together at a specific bone. This allows a character to 'Run' on their legs while playing a 'Reload' animation on their upper body.

The specific orientation of all bones in a skeleton at a single point in time. Animation Blueprints ultimately output a single 'Pose' for every frame.

Animations that store 'the difference' from a base pose. For example, a 'recoil' animation can be added on top of any other pose without overriding it.

Used to adjust character limbs based on the environment, such as making sure feet align perfectly with stairs or hands touch a door handle correctly.

A common, fast IK solver that handles three joints (like Hip, Knee, Foot). You provide a target location, and it calculates the rotations for the two bones in between.

A more advanced IK system in UE5 that can solve for the entire skeleton at once, allowing for much more realistic character reactions to complex terrain and physical interactions.

A Material is an asset that defines the visual surface properties of an object. It uses a node-based graph (HLSL-based) to calculate how light interacts with the surface using parameters like Color, Roughness, and Metallic.

A child of a base Material that allows for real-time parameter changes (like changing a color or texture) without triggering a costly recompile of the shader. This is essential for variety and performance.

A Material defines the logic and requires compiling. A Material Instance inherits that logic and only allows value changes to 'Parameters,' providing near-instant updates in the editor and better performance.

A global asset that stores a set of parameters (Scalar or Vector) that can be referenced by any Material in the game. Changing a value here updates all materials using it simultaneously, great for global weather or health effects.

A reusable snippet of a material graph that can be saved as an asset and used in multiple materials. It helps keep complex graphs organized and maintainable.

The fundamental color of the surface. In PBR, this should represent the diffuse reflectance of non-metals or the specular color of metals, free of any lighting or shadow information.

A grayscale value (usually 0 or 1) that determines if a surface behaves like a metal or a non-metal (dielectric). Metals have colored reflections and no diffuse color.

Used primarily for non-metallic surfaces to control the intensity of reflections. The default value is 0.5, representing roughly 4% reflectivity, which is accurate for most real-world non-metals.

Determines how 'smooth' or 'rough' a surface is. 0 is perfectly smooth (mirror-like), while 1 is completely matte (diffuse). It dictates the spread of specular highlights.

A texture that provides high-frequency surface detail (bumps, cracks) by perturbing the surface normals of the mesh without adding actual geometry.

An input that controls which parts of the material appear to glow. It can accept values higher than 1 to create bloom effects in the post-process.

Used in 'Translucent' materials to determine how much light passes through. 1 is fully opaque, 0 is fully invisible.

Used in 'Masked' materials. It uses a binary (cutoff) approach: a pixel is either rendered or not. This is much more efficient than Translucency for things like grass or chain-link fences.

A setting that forces the engine to render both the front and back faces of a polygon. Essential for thin objects like leaves, capes, or paper.

Determines how the material output blends with the pixels behind it. Opaque is solid, Masked is binary cut-out, and Translucent supports partial transparency (glass/water).

Defines how the material graph inputs are used to calculate the final color. Common models include Default Lit, Unlit, Subsurface (for skin), and Clear Coat (for car paint).

The most common node in the Material Editor; it takes a Texture asset and outputs its color (RGB) and Alpha (A) channels for use in the graph.

The 2D coordinate system used to map a 3D surface to a 2D texture. U is the horizontal axis, and V is the vertical axis.

A node used to access the UV maps of a mesh. It is frequently used to scale (tile) or offset textures.

A node that moves a texture across a surface over time based on a speed input. Used for moving clouds, flowing water, or conveyor belts.

A node that rotates the UV coordinates of a material, useful for spinning circular effects or UI elements.

Linear Interpolation. It blends between two inputs (A and B) based on a mask (Alpha). If Alpha is black, it shows A; if white, it shows B.

Fundamental math nodes. Multiply is often used to control intensity or tint textures. Add combines values (brightening), and Subtract removes them.

A math node that raises an input to an exponent. In materials, it is used to increase the contrast of a mask or sharpen a specular highlight.

A node that calculates a highlight based on the viewing angle. It is used to create 'rim lighting' or to make water more reflective at grazing angles.

A material input that allows the vertex positions of a mesh to be moved by the shader. Used for wind blowing through trees or ocean waves.

Information stored on the individual vertices of a mesh. Materials can use this data to blend textures (like adding moss to the top of rocks) without using unique masks.

A node that allows you to write raw HLSL (High-Level Shading Language) code directly within the material graph for advanced logic not possible with standard nodes.

The underlying language Unreal uses to communicate with the GPU. While the Material Editor is visual, it eventually compiles into HLSL code.

Niagara is Unreal's modern, highly flexible VFX system. It allows for complex particle simulations that can react to music, physics, and even other particle systems.

Cascade is the legacy system. Niagara is the replacement; it is more performant, uses a logic-based node system, and allows for GPU-driven particles and complex data sharing.

A tool used to create visual effects like fire, smoke, and explosions by managing the lifecycle of thousands of small sprites or meshes.

The component within a Niagara system that actually generates the particles. A single system can contain multiple emitters (e.g., one for the fire and one for the smoke).

A modular piece of logic applied to an emitter, such as 'Initialize Particle,' 'Add Velocity,' or 'Color over Life.'

CPU particles allow for complex interaction with game logic. GPU particles allow for millions of particles with simple logic, simulated directly on the graphics card.

Lumen is UE5's fully dynamic Global Illumination and reflections system. It calculates light bounces in real-time, eliminating the need for lightmap baking.

Nanite is a virtualized geometry system that allows for cinematic-quality 3D models with millions of polygons to be rendered directly without traditional LODs or baking normal maps.

A high-resolution shadowing method designed to work with Nanite and Lumen, providing consistent, high-detail shadows across massive environments.

An Unreal Engine framework for creating highly realistic, fully rigged digital humans in minutes, integrated directly with UE's animation and hair systems.

The high-performance physics and destruction engine in UE5, capable of simulating complex fractured geometry, cloth, and hair in real-time.

The process of using specialized tools to measure a game's performance (CPU, GPU, Memory) to identify bottlenecks and areas where the game is running slowly.

A built-in tool in Unity that provides real-time data on how much time is spent in different parts of the code, how much memory is used, and how many draw calls are being made.

A standalone profiling application for Unreal Engine that provides deep, high-frequency data collection for analyzing CPU, GPU, and Load times in great detail.

CPU profiling focuses on script logic, AI, and physics. GPU profiling focuses on rendering, shaders, and polygon counts. Optimizing the wrong one will not improve the overall frame rate.

The time it takes (in milliseconds) to process a single frame. For 60 FPS, the frame time must be under 16.6ms. This is often a more useful metric than FPS for developers.

30 FPS has a 33.3ms frame budget; 60 FPS has a 16.6ms budget. 60 FPS feels much more responsive but requires twice the optimization effort.

Common causes include too many draw calls, expensive physics calculations, memory management issues (Garbage Collection), or poorly optimized shaders.

A sudden frame drop (stutter) caused when the engine pauses the game to clear unused objects from RAM. This is why minimizing memory allocation in `Update` is critical.

1. Use Object Pooling. 2. Avoid using `new` in loops. 3. Use `StringBuilder` for string manipulation. 4. Use structs instead of classes for simple data containers.

Pre-spawning objects and toggling them on/off instead of creating/destroying them. This prevents memory fragmentation and expensive GC sweeps.

A draw call is a command sent from the CPU to the GPU to render a specific mesh with a specific set of textures and a shader. Every draw call has overhead; reducing them is a primary goal of optimization.

1. Batching (Static and Dynamic). 2. GPU Instancing. 3. Using Texture Atlases so multiple objects share one material. 4. Implementing Occlusion Culling to not draw hidden objects.

Batching is the grouping of multiple objects that share the same material properties into a single draw call. This minimizes the communication overhead between the CPU and the GPU.

A technique that draws many copies of the same mesh (e.g., grass or bullets) in a single draw call, while allowing each instance to have unique properties like position or color via a small buffer.

LOD involves creating multiple versions of a 3D model with decreasing complexity. The engine switches to lower-polygon versions as the object moves further from the camera.

The logic that calculates the distance or screen size of an object and determines which LOD mesh should be rendered. Abrupt switching can cause 'popping' artifacts, often mitigated by cross-fading.

A system that disables rendering for objects that are completely blocked by other objects (e.g., a room behind a wall). This is different from frustum culling, which only checks if an object is in the camera's field of view.

The process of discarding objects that are outside the camera's view frustum. This is performed automatically by most modern engines before the rendering stage.

A performance optimization that stops rendering or updating objects once they are beyond a certain distance from the player, commonly used for small decorative items like rocks or grass.

The reduction of texture file size using specialized algorithms (like BC7 or ASTC) to fit more visual data into GPU VRAM without significant quality loss.

Combining multiple textures into a single large texture sheet. This allows different objects to share a material and be batched together, reducing draw calls.

Reducing the complexity of a 3D model by removing unnecessary vertices, triangles, and hidden faces while maintaining the intended visual silhouette and silhouette.

The process of 'decimating' a high-poly mesh to a lower-poly version. Tools like Simplygon or engine-native decimation (Unreal's Proxy Mesh) are used to automate this.

Reducing the number of bones in a skeletal rig, especially for background characters. Fewer bones mean less CPU work for the animation skinning process.

Improving physics performance by using simpler collider shapes, increasing the fixed timestep, and disabling physics for distant or unimportant objects.

Using primitive shapes (Boxes, Spheres) or 'Convex' hulls instead of 'Concave' Mesh Colliders. Primitive shapes use significantly simpler math for collision detection.

A matrix that defines which groups of objects (Layers) can collide with each other. For example, ignoring collisions between 'Particles' and 'Dead Bodies' saves many CPU cycles.

Loading assets (levels, textures, models) on a separate background thread to prevent the main game thread from freezing (stuttering) during high-load periods.

A Unity system for managing asset loading by 'address' rather than direct reference. It simplifies memory management, remote content updates, and asynchronous loading.

Using tools to track how much RAM and VRAM is being used and which assets (textures, meshes, audio) are the largest consumers of memory.

A failure in a program to release discarded memory, causing the RAM usage to grow continuously until the game crashes. Common in C++ or when forgetting to unsubscribe from events in C#.

By taking memory snapshots at different intervals while playing. If the 'Total Allocated' memory never goes back down after a scene is unloaded, a leak is likely present.

The amount of VRAM (Video RAM) occupied by textures. Since textures are often the largest assets, optimizing their size and compression is critical for hardware compatibility.

Memory used to store vertex positions, normals, UVs, and triangle data. High-density meshes and complex character rigs consume significant mesh memory.

Reducing audio footprint by using mono instead of stereo for 3D sounds, lowering sample rates, and choosing between 'Streaming' (long files) and 'Decompressed' (short effects).

1. Use Unlit Shaders where possible. 2. Limit real-time lights and shadows. 3. Use low-poly meshes. 4. Aggressive texture compression (ASTC). 5. Minimize overdraw.

Overdraw happens when multiple layers of semi-transparent pixels (like smoke or glass) are rendered on top of each other, forcing the GPU to color the same pixel multiple times.

The speed at which a GPU can render pixels to the screen. Games with high resolution and high overdraw can become 'Fill Rate Limited,' meaning the GPU can't draw pixels fast enough.

A diagnostic view mode (especially in Unreal) that color-codes objects based on how expensive their shaders are. Green is cheap; red/white is extremely heavy.

Reducing the resolution and count of baked lightmaps to save disk space and VRAM while maintaining enough quality to avoid visual artifacts or 'light leaking.'

A networking model where one central computer (the server) manages the game state, and multiple players (clients) connect to it to send input and receive updates.

A model where players connect directly to each other without a central server. While cheaper to host, it is vulnerable to cheating and host-migration issues.

A server that has the final say on the game state. It processes all logic (like 'did the bullet hit?') to prevent clients from hacking their local game to cheat.

A technique where the client simulates its own movement locally before the server confirms it, making the game feel responsive despite network latency (ping).

When the server's update arrives, the client checks if its predicted state matches the server. If not, the client 'snaps' or smoothly interpolates to the server's authoritative state.

Server-side logic that accounts for a player's latency. For example, 'Backwards Reconciliation' allows the server to check where an enemy was when a high-ping player fired their shot.

Smoothing out the movement of other players by blending between their last known positions, preventing them from 'teleporting' between network updates.

Guessing where a player will be based on their last velocity when a network packet is lost. If the guess is wrong, the player will appear to snap back once a real packet arrives.

The frequency at which the server sends and receives updates (e.g., 20Hz, 64Hz). Higher tick rates provide a more accurate and competitive experience but use more bandwidth.

The time it takes (in milliseconds) for a packet of data to travel from the client to the server and back. Lower ping equals a more 'real-time' feeling.

When data transmitted over the network fails to reach its destination. This causes 'rubber-banding' or frozen characters in multiplayer games.

The variation in latency over time. Consistent 100ms ping is playable; ping that jumps between 20ms and 200ms (high jitter) is extremely disruptive to gameplay.

UDP is fast but unreliable (doesn't check for arrival); it is used for real-time movement. TCP is reliable but slow (re-sends lost data); it is used for chat or inventory.

Reliable packets are guaranteed to arrive in order (e.g., player joined). Unreliable packets can be lost (e.g., current rotation), as the next update will make the lost one irrelevant anyway.

A function that is called on one machine but executed on another. For example, a client calling an RPC on the server to request that their character shoots.

The automatic process of synchronizing variables and objects from the server to all connected clients, ensuring everyone sees the same game world.

Defining which machine is 'in charge' of an object. Usually, the server owns everything, but a player has 'Input Authority' over their own character.

A popular third-party networking library for Unity that provides matchmaking, lobbies, and easy synchronization of GameObjects across the internet.

An open-source high-level networking library for Unity, built as a community-driven replacement for the deprecated UNet system.

Unity's official first-party solution for building small-to-midsize multiplayer games, designed to work seamlessly with the engine's built-in components.

Replication is the process of sharing data and commands between the server and clients. In Unreal, you mark variables or functions as 'Replicated' so the server automatically sends updates to clients when those values change.

A variable in C++ (using UPROPERTY) or Blueprints that is flagged to sync from the server to clients. When the server changes a replicated variable, the engine handles the network packet delivery to ensure all clients stay updated.

1. Server: Called on client, runs on server (requesting actions). 2. Client: Called on server, runs on the specific owning client. 3. Multicast: Called on server, runs on the server and all connected clients (used for visual effects or sounds).

An optimization that determines which Actors a specific client needs to know about. If an Actor is too far away to be seen or heard, the server stops sending updates for it to that client to save bandwidth.

The high-level setting (`bReplicates = true`) that allows an Actor to exist and stay synchronized across the network. If this is false, the Actor only exists on the machine that spawned it.

GameState holds information visible to everyone (score, match timer, team objectives). PlayerState holds data specific to one player (individual score, player name, ping) that everyone else can still see.

GameMode exists only on the server and defines the 'Rules' (win conditions, which pawn to spawn). GameState exists on both server and clients to store the 'Status' of those rules.

The process of grouping players together into a game session based on criteria like skill level (MMR), geographical location, or chosen game mode.

A pre-game state where players can join a room, chat, select characters, and wait for the host to start the match before the main game world is loaded.

A Dedicated Server is a standalone program with no visuals (pure logic). A Listen Server is a game instance where one player acts as both the host and a player, which is cheaper but gives the host a latency advantage.

I would create a 'HealthComponent' with variables for `MaxHealth` and `CurrentHealth`. It would have a `TakeDamage` function that subtracts value and triggers an event (OnHealthChanged) for the UI to listen to. I'd use a 'DamageType' parameter to handle different reactions like fire or impact.

I would use a Data-Oriented approach. A ScriptableObject (Unity) or Data Asset (Unreal) defines each 'Item'. The inventory itself is an array of 'Slot' structs (ItemAsset + Quantity). This allows for easy UI binding and stack management using unique IDs.

I would define a 'SaveData' class that is serializable. When saving, I gather all necessary variables (Position, XP, Inventory) from the game, convert the class to JSON or a Binary file, and write it to disk. On load, I reverse the process and re-apply the values to the game objects.

I'd use a Node Graph or a structured JSON file. Each 'Node' contains the text, an NPC ID, and an array of 'Choices'. Each choice points to the ID of the next node. I'd include 'Condition' checks to hide choices if the player lacks a certain item or stat.

I'd use a State Machine for each quest: Unassigned, Active, Failed, or Completed. A Quest asset would contain a list of 'Objectives'. Each objective has a counter (e.g., 'Kill 10 Wolves') and listens to a global event system to update its progress.

I would use a single float variable `TimeOfDay` (0.0 to 1.0). This variable drives the rotation of a Directional Light (Sun) and interpolates the skybox color, ambient light intensity, and fog settings using a gradient or curve.

I'd use a combination of Global Material Parameters and Particle Systems. For rain, I'd trigger a screen-space particle effect and update a material parameter that increases the 'Smoothness' (wetness) of all world materials and adds a scrolling ripple texture.

I would create a 'SkillNode' class with `isUnlocked` and `prerequisites` (other nodes). The UI would visualize these nodes, and the PlayerComponent would check these booleans before allowing certain abilities to execute.

I'd use a Buffer and Timer. When a button is pressed, it is added to a queue. If the next button is pressed within the 'Combo Window' and matches a pattern in a 'ComboList' (Dictionary), the corresponding high-tier animation montage is played.

I'd use a Weight-based Randomization. Each item has a weight (Common: 100, Legendary: 1). I sum all weights, pick a random number in that range, and iterate through the list. This is much more flexible than hard-coded percentages.

I'd place a second camera high above the player looking down, using an Orthographic projection. The camera renders to a 'Render Texture,' which is then displayed in a circular UI mask on the player's HUD.

I'd use a UI element that calculates its position based on the `WorldToScreenPoint` of the target. If the target is off-screen, I use trigonometry to clamp the icon to the edge of the screen, pointing in the target's direction.

I'd use a Raycast to find a hit point. Then, I'd apply a 'Spring Joint' or a constant force toward that point. For the visuals, I'd use a 'Line Renderer' (Unity) or 'Cable Component' (Unreal) to connect the player's hand to the target.

I'd use Wall Normal detection. When the player is near a wall and presses 'Cover', the character snaps to the wall's surface. I'd use 'Line Traces' to check if the player can 'Peak' left, right, or over the top based on the wall's dimensions.

I'd use a series of 'Ledge Detectors' (tiny Raycasts/Traces) around the character's hands and head. If a ledge is found, I disable standard movement and use Root Motion animations to move the character up the wall based on player input.

I'd use a Raycast-based suspension. Instead of complex mesh collisions, I shoot four rays down (wheels). I apply an upward 'Spring Force' based on the compression of the ray and a 'Friction Force' to the Rigidbody to simulate tire grip.

In UE5, I'd use Chaos Destruction to pre-fracture a mesh into 'Geometry Collections.' When an impact occurs, I apply a 'Field' (Radial or Strain) that breaks the bond between clusters, causing the mesh to fall apart realistically.

I'd use Tile-based generation with Wave Function Collapse (WFC) or a simpler 'Drunkard's Walk' for dungeons. I use a 'Seed' for the random number generator so that specific levels can be recreated and shared by players.

I'd implement a 'StatManager' that tracks events (e.g., `OnEnemyKilled`). Achievements are assets with a 'Goal' (e.g., 100 kills). When a stat reaches the goal, the system triggers a 'Pop-up' and saves the `isUnlocked` state to the cloud profile.

I'd use a Trigger-based Event system. When the player enters a zone or performs an action (e.g., 'Open Inventory'), the system pauses the game (or slows time) and displays a 'Contextual UI' that only dismisses when the required input is detected.

I'd use a 'Telemetry' service. I send small JSON packets to a server for key 'Funnel' events (e.g., 'Started Level 1', 'Died to Boss', 'Purchased Item'). This data helps designers identify where players get stuck or frustrated.

I'd use the engine's built-in Purchasing API (like Unity IAP). I store the item catalog on a server. When a purchase is made, I validate the receipt with the App Store (Apple/Google) before granting the item or currency to the player's account.

I'd use the Server Time (not local device time to prevent cheating). I store the `lastClaimDate`. If `CurrentTime - lastClaimDate > 24 hours`, I enable the 'Claim' button and increment the 'Streak' counter.

I'd use a backend service like PlayFab or GameSparks. When a match ends, the client sends the score to the server. The server validates the score and inserts it into a sorted database, which the client can then query to show the 'Top 100' or 'Friends' ranking.

I'd use the platform's API (Steam Cloud, iCloud, Google Play). I serialize the save file and upload it whenever the game is closed or a 'Save' is triggered. I check the 'Timestamp' on launch to resolve conflicts between local and cloud files.

I'd use a Centralized Account System (like Epic Online Services). Player data is stored on my own server, not just the platform's cloud. When the user logs in via Steam or PlayStation, they link to the same 'Global ID' to fetch their progress.

I'd implement a 'SpectatorPawn' with no collision and a flight-based movement component. I'd allow the user to cycle through the 'Camera Targets' of active players, using a UI that shows the selected player's health and equipment.

Instead of recording video, I record Input and State snapshots. I store the position and actions of every Actor every few ticks. To play it back, I simply 're-run' the game logic using the recorded data to drive the Actors.

1. Server Authority: Never trust the client for health or position. 2. Sanity Checks: If a player moves 100m in 1 frame, kick them. 3. Obfuscation: Encrypt local save files and memory values using tools like 'Easy Anti-Cheat' (EAC).

I'd create a UI form that, when submitted, captures a Screenshot, the Log file, the Player's position, and the Current Scene Name. I'd send this data via an API to a service like Jira or Trello for the QA team to review.

Fortnite uses massive Server-side Optimization and Relevancy. It only replicates data for players near you. It also uses a 'Variable Tick Rate' and 'Delta Compression' for its network packets to handle the high volume of building and destruction data efficiently.

I'd use a Grid-based placement system. When a player selects a wall, a 'Ghost Mesh' snaps to the nearest grid cell. When they click, I spawn the wall Actor, which checks for 'Support' (other walls or floor) to prevent floating structures.

I'd use a 'Progression Data Asset' with 100 Tiers. Each tier has a 'Required XP' and a 'Reward' (Cosmetic ID). I'd maintain two tracks: 'Free' and 'Premium', checking the user's `hasPremiumBP` flag before granting locked rewards.

It uses Modular Skeletal Meshes. A character is split into Head, Body, and Back-bling. When a player chooses a skin, the system 'Merges' or 'Swaps' these meshes onto the base skeleton using a 'Skeletal Mesh Merge' tool to keep draw calls low.

Through World Partition and Data Layers. It breaks the map into a grid; only the cells near the player are loaded. HLODs (Hierarchical Level of Detail) replace distant groups of objects with a single low-poly mesh and texture to maintain performance.

It uses a Server-Authoritative Casting Queue. When you press 'Q', the client sends a request. The server validates if the ability is off cooldown and the player has enough mana, then broadcasts the 'Start Animation' and 'Spawn Projectile' events to all players.

I'd use a Data-Driven Component approach. Each ability is a 'SkillAsset' containing cooldowns, costs, and a list of 'Effects' (Damage, Stun, Heal). This allows designers to create new champions by mixing and matching existing effects.

I'd use a Kernel-level driver that launches at boot. It monitors the system for unauthorized memory access or DLL injection. I'd combine this with 'Fog of War' networking so the client doesn't even receive the enemy's location until they are 'visible'.

Minions follow a spline-based path down the lane. They use a simple 'Aggro Priority' (Enemy Minion > Tower > Champion). If a target enters their range, they break the spline movement to attack, returning once the target is dead.

I'd use a Texture-based Visibility Mask. Every allied unit 'paints' a radius of white onto a black 2D texture. The game uses this texture to hide/show enemy meshes and to 'Grey out' the minimap for areas with no allied vision.

Source (especially Source 2) is heavily focused on Physics and Moddability. It uses a 'Bsp' or 'Vmap' structure and has a unique 'Entity-Logic' system. Its networking is famous for 'Lag Compensation', which set the gold standard for competitive FPS games.

I'd use a Recoil Pattern Array (X, Y offsets). As the player fires, I increment an index and apply that offset to the crosshair. I'd add a 'Random Spread' factor that increases with movement and decreases when crouching.

I'd decouple all 'Abilities' from 'Hero Models'. In the lobby, I display a shared pool of Ability Assets. As players pick, I 'Inject' those specific ability components into their character instance, updating the UI dynamically to match the new skill set.

I'd use the Steamworks SDK. Users upload files via a specialized 'Publisher' tool. The game client queries the Steam API for subscribed items, downloads them to a 'Mod' folder, and dynamically loads the assets using an 'Asset Bundle' system at launch.

Source 2 uses Rubikon, a custom physics engine designed for high stability and networking. It supports complex constraints and 'Skeletal Physics', which is why Valve games have very tactile, physics-driven environments (like Half-Life: Alyx).

I'd use a Phase-based Scripting system. The Boss is an AI with a 'State Machine' (Phase 1, 2, 3). Each phase transition triggers 'World Events' (e.g., ground fire, spawning adds). I'd use a 'Combat Log' to broadcast every event for external UI mods to track.

When a player switches in the Spawn Room, I Destroy the current Pawn and spawn a new one from the selected Hero Class. I must ensure the PlayerState (Score, Ult charge) is either reset or partially carried over based on the game's balance rules.

It uses 'Prefabs and Sockets'. Designers create hand-crafted 'Rooms'. The generator picks rooms that fit together like a puzzle and populates 'Sockets' with random monster packs and loot chests to ensure the level feels high-quality but unique.

It is a legacy system where the server processes all actions in small 'Windows' (e.g., 400ms). This allowed for 'Double KOs' where two mages could polymorph each other at the same time because both actions were in the same batch.

I'd use a Server-Side Rules Engine. Each card is a 'Scriptable Object' with 'Battlecry' or 'Deathrattle' events. When a card is played, the server runs the logic, updates the 'Board State', and sends the 'Visual Instructions' (Animations) to the client.

It uses Sector-based streaming. The world is divided into sectors. As the player drives, the engine prioritizes loading the sectors in front of the vehicle. It uses 'Low-Resolution LODs' for distant buildings and only swaps to high-res when the player is close.

I'd use a global integer `HonorPoints`. Every NPC death or helpful action sends an event that modifies this value. The value is then used as a 'Multiplier' for shop prices and a 'Requirement' for certain story dialogue branches.

I'd use a 'Crime Manager'. It tracks 'Suspicion'. If a crime is witnessed, it spawns a 'Search Zone'. As the Wanted Level (1-5 stars) increases, I change the 'Spawn Table' for police (Bikes -> Cars -> Helicopters -> SWAT).

The RAGE engine is known for its Advanced Animation Synthesis (Euphoria) and its highly efficient memory streaming. It allows for incredibly detailed physics (like car deformation) while maintaining a huge, seamless world with no loading screens.

I'd use a Schedule-based AI. Every NPC has a 24-hour timeline (e.g., 8 AM: Go to Farm, 6 PM: Go to Saloon). I'd use 'Ambient Tasks' to make them interact with the world (sitting on chairs, leaning on walls) when they aren't moving.

I'd avoid standard physics and use Custom Character Controller logic. I'd implement 'Coyote Time' (jumping after leaving a ledge) and 'Jump Buffering'. The gravity would be higher when falling than when rising to make the jump feel 'snappy' and controlled.

I'd use a Recipe Dictionary. Each ingredient has 'Tags' (Heart, Stamina, FireResist). When the player cooks, I sum the tags. If the combination matches a 'Special Recipe' ID, I grant that item; otherwise, I generate a generic 'Dubious Food' based on the total stats.

It uses a Command Queue sorted by 'Speed' stat. Once both players select a move, the server (or logic) runs the moves in order, calculating damage, status effects, and 'Priority' (e.g., Quick Attack) before updating the HP bars on both screens.

It's a formula: `Knockback = ((Percentage / 10 + Percentage * Weight / 20) * (200 / (Weight + 100)) * 1.4 + 18) * Scaling`. The result is applied as a 'Velocity Launch' to the character, with 'Directional Influence' (DI) allowing the player to nudge the path.

I'd sync with the System Clock on launch. I'd calculate the 'Time Difference' since the last save to process background growth (flowers, trees). I'd use an 'Event Schedule' to determine which NPCs are awake and which shop music to play based on the hour.

It uses 'Parkour Nodes' and 'Animation Warping'. Designers mark up the world with 'Climbable' edges. When the player moves toward a wall, the system finds the nearest node and 'Warps' the hand/foot animations to snap perfectly to the bricks or beams.

I'd use an 'Area Manager' with an `owner` enum (Pirates, Rebels). The area contains a list of 'Spawn Points'. When all enemies in the area are killed, I trigger a cinematic, change the `owner` flag, and swap the NPC 'Spawn Tables' to friendly ones.

I'd use a Trigger Volume around 'Groups of NPCs'. If the player enters the volume and stops moving or matches the walk speed, the 'isHidden' flag becomes true, and the enemy AI vision checks will ignore the player.

Snowdrop (The Division/Star Wars Outlaws) is famous for its Node-based scripting and dynamic global illumination. It allows for incredibly fast world-building and high-quality destruction, with a focus on 'What You See Is What You Get' for designers.

It uses 'Archetypes'. Every NPC is generated with a 'Bio' (Name, Income, Secret). This data is purely cosmetic until the player 'Hacks' them. Their physical routine is driven by a 'World Schedule' similar to RDR2 but with more randomized 'Interactions'.

It uses a Procedural Animation system (HyperMotion). Instead of fixed clips, it blends between thousands of 'Motion Capture' frames based on ball position and player momentum, using a physics-driven 'Collision Solver' for tackles.

I'd use 'Pre-fractured States' and 'Destruction Masks'. When an explosion hits a wall, I swap the 'Healthy' mesh with a 'Broken' mesh and spawn 'Debris Particles'. For larger buildings (Levolution), I'd use an animated sequence that triggers specific physics-based rubble.

I'd use a Context-Sensitive Trace. When the ping button is pressed, I raycast. If I hit an item, I broadcast 'Loot here'; if I hit a location, 'Going here'; if I hit an enemy, 'Enemy spotted'. I'd trigger the corresponding VO (Voice Over) and UI icon for all teammates.

Frostbite (Battlefield) uses a system called 'Destruction 2.0'. It allows for 'Small-scale' (bullet holes) and 'Large-scale' (collapsing walls) destruction by using procedural deformation and real-time mesh swapping that stays synced in multiplayer.

It uses an ELO-based system (Skill Rating) combined with 'Division' tiers. It prioritizes 'Ping' (Connection quality) first to ensure smooth gameplay, then tries to find an opponent within a small Skill Rating range.

It uses a 'Decision Tree' with 'Flags'. Every choice sets a global boolean (e.g., `didSaveBaron`). Later scripts check these flags to determine which NPCs are alive, which quests are available, and which of the 36 world endings to trigger.

I'd use a 'Body Slot' system (Arms, Legs, Neural). Each cyberware is an 'Ability Component'. When installed at a Ripperdoc, it adds the component to the player and modifies their 'Stats' (e.g., Double Jump, Slow Time).

I'd use a 'Radial Menu' for selection. Each Sign (Aard, Igni) is a specialized 'Spell Actor'. When cast, it spawns the actor, which handles the specific physics force (Aard) or particle damage (Igni) and consumes 'Stamina'.

REDengine is built for Ultra-high-density environments. It uses a specialized 'World Browser' and 'Level Streaming' system that prioritizes NPC faces and clothing in dialogue while unloading high-res textures of the city background.

It uses 'Interior/Exterior Portals'. Each floor of a skyscraper is treated as a sub-level. To save performance, the engine only renders the floor the player is on and the 'LOD' version of the city outside the window.

I'd implement two features: 1. Rotational Assist: Slightly rotating the camera toward the enemy when the player is moving. 2. Slowdown: Reducing the 'Sensitivity' of the stick when the crosshair is near an enemy's hitbox.

I'd use a 'Modular Attachment' system. Each gun is a base Actor with 'Sockets' (Muzzle, Optic, Stock). Attachments are 'Data Assets' that, when added, modify the gun's 'Stats' (Recoil, Range) and 'Mesh' visually.

I'd use an 'Event Listener' in the PlayerState that counts consecutive kills without dying. When the `KillCount` reaches a threshold, it unlocks a 'Killstreak Action'. Triggering it spawns a specialized Actor (UAV, Predator Missile) and puts the player into a 'Control Mode'.

The IW engine is optimized for 'Low-Latency 60Hz' gameplay. It uses aggressive 'Client-Side Prediction' and 'Sub-tick' processing to ensure that shots feel instantaneous even in fast-paced 6v6 or 150-player scenarios.

Warzone uses a 'Proprietary Server Mesh'. It splits the massive map into 'Interest Zones'. A single server doesn't process 150 players; instead, multiple server instances handle different groups of players and 'Hand off' data as they move between zones.

A GDD serves as the 'Blueprint' for the entire team. It ensures that everyone (Programmers, Artists, Designers) is building the same game, preventing 'Feature Creep' and reducing wasted work.

Alpha means 'Feature Complete' (all mechanics are in). Beta means 'Content Complete' (all levels/assets are in). Beta is primarily for bug fixing and balancing before release.

The process of testing the game to find and document bugs. QA teams use 'Bug Trackers' and 'Reproduction Steps' to help developers fix issues before the game reach the public.

A bridge between Art and Programming. They focus on shader creation, rigging, pipeline tools, and ensuring that the art assets are optimized to run well on the target hardware.

A system that records changes to a project's files over time. It allows multiple developers to work on the same project without overwriting each other's work and provides a way to 'Revert' if something breaks.

Git is great for code and small projects. Perforce (P4V) is the industry standard for large games because it handles massive binary files (Textures, Meshes) much better than Git.

A project management method that breaks development into 'Sprints' (2-4 weeks). It allows teams to iterate quickly, test frequently, and adjust the game's direction based on playtesting feedback.

The trends include the mainstream adoption of AI-driven NPC dialogue, Cloud-native gaming, and the total shift to Virtualized Geometry (Nanite) which has removed the need for manual LOD work for artists.

VR (Virtual Reality) is fully immersive. AR (Augmented Reality) overlays data on the real world. MR (Mixed Reality) allows digital and physical objects to interact.

A persistent, shared 3D virtual space where players can socialize, play, work, and own digital assets (NFTs/Skins) that are interoperable across multiple different platforms and games.