Unreal Clarity

An unofficial Unreal Engine 5 wiki for the questions the official reference doesn't answer.

The official reference tells you a node exists. It rarely tells you:

• what the call actually does, in terms of real engine objects,
• whether it can fail, when, and what failure looks like,
• who owns what — the connections between actors, components, controllers, and pawns that every node silently assumes you already understand,
• how the return type relates to your classes ("it returns a Pawn — is my Character one of those?"),
• which of the five similarly-named nodes you actually want.

Every page here must answer those questions. That's the whole idea.

The goal: cover the beginner core — the nodes and concepts a first project actually touches — well enough that, for your first months of Unreal, you can read this wiki instead of the official reference rather than alongside it. Pages are written in the order they're most likely to help a beginner; the roadmap is that queue.

If you have a task in mind before you know which node you need, start with I want to.... It maps common beginner goals to the existing pages in a useful order.

Start here

If you're new to Unreal, read these concept pages first — they're the missing manual that makes every API page suddenly make sense:

• The gameplay class hierarchy — what UObject, AActor, APawn, ACharacter actually are, which one you subclass, and what "Cast To" really does.
• Ownership and lifetime — the four different things Unreal calls "ownership," and why GetOwner means different things in different places.
• Possession — Controller vs Pawn, who receives input, and why Animation Blueprint preview is not your live possessed pawn.
• Construction Script vs BeginPlay - what runs in the editor, what runs during gameplay, and why property edits rerun one but not the other.
• The frame: Tick, timers, and timelines - what actually runs every frame, what timers schedule, and when a Timeline is the better tool.
• Collision presets, channels, and responses - object types, trace channels, Block vs Overlap vs Ignore, and why both components' settings matter.
• Line Trace vs projectile vs overlap weapon hits - choose instant traces, moving projectiles, overlap volumes, blocking hits, or thick/multi traces before wiring weapon damage.
• First weapon fire pattern and impact cleanup - place input, cooldowns, ammo, muzzle transforms, hit detection, damage, feedback, cleanup, and multiplayer authority in the right owner.
• Accessed None trying to read property - how to read the warning, find the empty reference, and decide whether to fix the assignment or guard an optional value.
• Breakpoints and watch values - how to pause the right Blueprint instance, step execution, and inspect pin values without guessing.
• The Blueprint survival kit: functions, events, macros - the month-one map for choosing functions, custom events, macros, collapsed graphs, structs, enums, and arrays.
• Blueprint variables and references - value variables, object/class/asset references, instance editable setup, Expose on Spawn, SaveGame flags, and travel-safe reference rebuilding.
• Arrays, Sets, Maps, and ForEach - ordered lists, unique membership, key-value lookup, empty containers, stale references, and loop cost.
• Structs, Enums, and Switch on Enum - bundled values, named states, Make/Break/Set Members, and enum-driven graph flow.
• Data Tables vs Data Assets - spreadsheet-like rows, authored data assets, row structs, stable IDs, and moving duplicated tuning data out of Blueprint defaults.
• Data Table row names, row handles, and stable IDs - table-scoped row identity, handle contents, display-name separation, SaveGame IDs, reimport validation, and explicit rename migrations.
• Soft Object/Class References and async loading - path-based asset/class identity, pending and loaded states, async completion, blocking-load hitches, cooking, retention, and Asset Manager boundaries.
• Actor, Scene, and Primitive Components - the component family tree, root components, transform hierarchy, and why meshes/collision/cameras/audio live as actor parts.
• Actor Components as reusable gameplay - health, inventory, team, interaction, and other reusable state without copying variables into every actor.
• HealthComponent and damage response pattern - reusable health state, clamping, invulnerability, OnHealthChanged, OnDeath, UI refresh, and server-owned damage response.
• Death and defeat cleanup flow - one-shot death gates, input/AI/collision/timer cleanup, death cameras, respawn, score credit, and stale-reference prevention.
• Status effects and damage-over-time with timers - poison, burn, slow, stun, timed buffs, stack/refresh rules, timer handles, UI icons, save/load, and server authority.
• Score, objectives, and win/loss state - place score, match phase, objective progress, end screens, SaveGame results, and multiplayer-visible state in the right owner.
• Objective and Wave Manager Actors - coordinate generators, waves, checkpoints, room puzzles, placed references, reset/save rules, and public GameState summaries without a hidden god graph.
• Small Inventory Architecture - split item definitions, world pickups, inventory entries, equipped actors, UI, and SaveGame data.
• Add, Remove, Stack, and Broadcast Inventory Changes - build deterministic AddItem/RemoveItem rules, stack handling, full-inventory results, and one event-driven UI refresh.
• Equip, Use, and Drop Item Flow - move items between bag data, live equipped actors, use effects, and dropped world pickups without stale references.
• UMG Inventory Slots, ListView/TileView, and Drag/Drop - choose manual slots, ScrollBox, ListView, or TileView, and keep drag/drop payloads from becoming inventory authority.
• Cast, Interface, or Dispatcher? - the decision rule for Blueprint communication, coupling costs, and the health-bar update pipeline.
• Updating a Widget: Bindings vs Events - why bindings can become per-frame polling, and how to push health-bar updates from gameplay events instead.
• Buttons, Progress Bars, and basic UMG events - button click/press/release events, progress percent ranges, text updates, and why widgets should request actions through owned references.
• Widget Component and World-Space Widgets - actor-attached UMG widgets, World vs Screen space, draw size, pivots, redraw cost, occlusion, facing, lifetime, and local multiplayer display.
• Widget Interaction Component - virtual pointer traces for world widgets, simulated key/pointer input, hover/focus identity, debug lines, and server validation boundaries.
• Crosshair, reticle, and interaction prompts - local HUD reticles, camera traces, prompt data contracts, priority rules, input-device text, stale-target cleanup, and server interaction requests.
• Nameplates, floating health bars, and damage numbers - actor labels, PlayerState names/teams, HealthComponent bars, pooled damage numbers, projection, visibility rules, and replicated-state display.
• HUD state from replicated and local data - combine local HUD, pawn/body state, PlayerState, GameState, RepNotify, respawn rebinding, scoreboards, owner-only data, and split-screen context.
• Gameplay Tags, Actor Tags, and Component Tags - plain actor tags, component tags, Gameplay Tag containers, and why tags classify objects but do not provide behavior.
• Material Instances and Dynamic Material Instances - parent materials, authored instances, runtime dynamic instances, parameter names, material slots, and local visual changes.
• Physical Materials for surface-specific feedback - surface types, hit-result physical materials, simple vs complex collision, and mapping surfaces to footsteps, decals, and VFX.
• Why won't my character face where it's moving? - controller yaw, movement-oriented rotation, and why camera direction is not always body direction.
• Character Movement Component: the knobs that matter - Max Walk Speed, acceleration, braking, jumping, air control, and why multiplayer can correct local movement changes.
• Runtime Character Speed: Sprint, Slows, and Safe Restoration - one-owner speed calculation for sprint, crouch, overlapping slows and buffs, multiplayer authority, and velocity-driven animation.
• Spring Arm + Camera - camera boom distance, collision pull-in, control rotation, lag, and why skipping the arm makes third-person cameras clip through walls.
• Input Actions & Input Mapping Contexts - the Enhanced Input split between actions, mapping contexts, modifiers, triggers, and local-player setup.
• Started, Triggered, Ongoing, Canceled, Completed - which Enhanced Input event pin to bind for press, release, hold, tap, and axis values.
• GameMode & friends, single-player edition - default pawn/controller/HUD setup, map overrides, spawn flow, and what belongs in each framework class.
• Level Blueprint vs Actor Blueprint vs Manager Actors - choose the right Blueprint home for one-map scripts, reusable actors, components, framework classes, and map-specific managers.
• Game Instance - runtime data and managers that survive Open Level, plus why actor references and SaveGame are separate problems.
• Options/settings screen architecture: draft, Apply, Cancel, and Defaults - separate editable, applied, and persisted values; route each setting to its real owner; and make previews, rollback, dirty state, async save, local-user scope, and multiplayer boundaries explicit.
• Blueprint World Context: what the hidden pin chooses - how static library nodes select one play world, why the pin defaults to self, and how wrong contexts hide inside multi-client PIE.
• World vs relative transforms - world space, parent-relative offsets, attachment transforms, and the Sweep pin on location-setting nodes.
• Lerp, FInterp To, and moving things smoothly - fixed-alpha blends, per-frame Interp To, Timelines, Delta Seconds, and why Lerp-from-current eases forever.
• Behavior Trees and Blackboards for Blueprint Beginners - AIController-owned trees, blackboard facts, selectors, sequences, tasks, decorators, services, and the pawn/body split.
• Move To Task, Decorators, Services, and Observer Aborts - Behavior Tree movement requests, branch eligibility, services, blackboard observers, and why transitions feel instant or stuck.
• Simple Patrol, Chase, Attack, and AI Debugging - a beginner enemy loop that remembers a target, patrols, chases, attacks, gives up, and is debugged across pawn, controller, tree, blackboard, NavMesh, and perception.
• Gameplay Debugger and AI Debugger for Blueprint Beginners - read the apostrophe debugger's NavMesh, AI, Behavior Tree, Blackboard, EQS, and Perception categories before rewriting AI logic.
• Visual Logger, EQS Debugger, and ShowDebug Boundaries - choose Print String, live debugger overlays, Visual Logger timelines, EQS query previews, or showdebug output for the specific evidence you need.
• Level streaming basics - persistent levels, streamed sublevels, Load/Unload Stream Level, and when streaming keeps state that Open Level would destroy.
• Multiplayer roles - which machines have GameMode, GameState, PlayerState, PlayerController, Pawn, UI, and GameInstance, plus where replicated variables usually belong.
• Replication basics - what Replicates enables, replicated variables and RepNotify, server-spawned actors, RPC ownership, relevancy, and why widgets do not replicate.
• Blueprint Custom Events as RPCs - turn Custom Events into Run on Server, Run on Owning Client, or Multicast messages without confusing ownership, reliability, or return values.
• RepNotify variables and local presentation - use replicated state to drive local UI, audio, materials, and VFX without trying to replicate widgets or cosmetic components.
• GameState and PlayerState in practice - put match timers/objectives in GameState and public per-player score, team, ready state, and loadout summaries in PlayerState.
• Has Authority / Switch Has Authority / Is Locally Controlled - separate server authority, owning-client local control, and net mode before branching damage, input, UI, and replicated spawns.
• Multiplayer PIE debugging basics - run server/client PIE windows, pick the right debug world/object, and label prints before blaming replication.
• Replicating Actor Components - replicate reusable health, inventory, team, status, and interaction components without bypassing actor ownership or server authority.
• Replicate Movement vs replicated variables - separate actor/root movement replication from health, ammo, movement mode, visual offsets, and other gameplay state.
• Actor relevancy, owner-only, and dormancy basics - understand why replicated actors, variables, and multicasts reach some clients but not others.
• Reliable vs unreliable RPC budget - choose Reliable, Unreliable, replicated state, or prediction without turning every network message into backlog.
• Network Emulation for beginner replication checks - add latency and packet-loss tests after the basic server/client flow already works.
• Animation State Machines and transition rules - animation states, one-way transitions, AnimBP variables, preview-vs-runtime debugging, and where locomotion logic belongs.
• Blend Spaces in Animation Blueprints - 1D speed blends, 2D direction/speed blends, Aim Offsets, axis ranges, and why the AnimBP must feed the input values.
• Animation Notifies and Notify States - one-frame animation events, timed notify windows, footsteps, melee windows, montage callbacks, and why Delay is the wrong timing source.
• Animation threading and Property Access - game-thread Event Graph work, worker-thread-friendly animation reads, Property Access snapshots, thread-safe functions, and migration from the old Try Get Pawn Owner pattern.
• Cached poses and Layered Blend Per Bone - Save/Use Cached Pose reuse, upper-body layers over locomotion, branch filters, blend depth, curves, root-motion settings, and slot-order traps.
• Montage slots layered over locomotion - Slot nodes as montage insertion points, full-body vs upper-body actions, slot names/groups, sections, notifies, root motion, and multiplayer triggers.
• Root Motion vs Character Movement - capsule-first movement, animation-root movement, mesh drift, root locks, movement modes, AI movement, and multiplayer correction boundaries.
• Aim Offsets and look/aim variables - additive aim Blend Spaces, yaw/pitch ownership, clamping/smoothing, layer order, weapon trace alignment, and replicated remote aim.
• Sound Attenuation and spatialized audio - distance falloff, spatialization, focus, occlusion, listener position, and why world sounds can still feel flat.
• Sound Cue vs MetaSound vs Sound Wave - choose simple clips, Sound Cue randomization/variation, or MetaSound procedural/parameter-heavy audio without overbuilding.
• Nav Link Proxy and navigation modifier boundaries - connect nav islands, mark costly/blocked areas, adjust agent assumptions, and debug broken Move To paths at the navigation-data layer.
• EQS query basics after the first Behavior Tree - use generators, contexts, tests, filters, scores, Blackboard results, and the EQS Testing Pawn after basic patrol/chase works.
• StateTree vs Behavior Tree for Blueprint beginners - choose Behavior Trees, StateTree, simple enum states, or EQS without migrating a working first enemy by habit.

API pages

• AI
  • AI Move To & the NavMesh - AIController movement requests, NavMeshBoundsVolume setup, Acceptance Radius, and success/fail pins.
  • Seeing the player: Pawn Sensing & AI Perception - first-enemy sensing, sight cones, forgetting targets, AI Perception stimuli, and where the beginner boundary stops.
  • Run Behavior Tree, AIController Setup, and Blackboard Keys - starting a Behavior Tree from the AIController, reading the Boolean return, and setting blackboard keys from perception.
  • Get Random Reachable Point in Radius - random reachable NavMesh destinations, success Boolean handling, nav filters/agents, patrol use, and Move To follow-up failures.
  • SetFocus / SetFocalPoint / ClearFocus - Actor tracking versus fixed focal points, focus priority ownership, Control Rotation, body turning, Behavior Trees, and server-side AI.
• Audio
  • Play Sound 2D / Play Sound at Location / Spawn Sound Attached - UI sounds, fixed world sounds, attached audio components, unstoppable fire-and-forget loops, and the not-replicated trap.
  • Audio Component controls: Play, Stop, Fade, Volume, and Sound - live sound handles, Stop, Fade In/Out, Set Sound, volume multipliers, Auto Destroy, and owner-lifetime traps.
  • Sound Class / Sound Mix: category volume, Push/Pop, and overrides - category hierarchy, active mix ownership, runtime class overrides, stacking, preview/persistence, and local-output multiplayer boundaries.
• Actor
  • Get Actor Of Class / Get All Actors Of Class - what "first actor" really means, why repeated searches cost, and the reference-passing alternatives beginners should learn first.
  • Get All Actors with Interface / Get All Actors with Tag - setup-time world searches by contract or plain actor tag, empty-array failures, and why managers/events usually beat repeated scans.
  • Actor Has Tag / Component Has Tag / Get Components by Tag - plain-Name matching, Actor-vs-component storage, component class filters, empty results, Gameplay Tag boundaries, and local runtime changes.
  • Get Component by Class / Get Components by Class - Actor-local component discovery, subclass matching, singular ambiguity, empty results, runtime additions, Child Actors, and caching boundaries.
  • Get Owner / Set Owner - actor Owner links, component-owner lookalikes, owner-only networking, RPC permission paths, and why Owner is not attachment.
  • Event BeginPlay / Tick / EndPlay / Set Actor Tick Enabled - runtime setup, per-frame work, cleanup, Delta Seconds, and tick toggles.
  • Destroy Actor / Set Life Span - latent actor destruction, stale references, cleanup, replicated removal, and lifespan timers.
• Character
  • Jump & Launch Character - normal jump requests, held jump release, double-jump settings, launch velocity, and XY/Z override flags.
  • Crouch / Un Crouch / Can Crouch - next-update stance requests, capsule and mesh offsets, blocked uncrouch, input patterns, crouched speed, and built-in replication.
• Blueprint Communication
  • Blueprint Interfaces - interface messages, Does Object Implement Interface, silent no-op behavior, and when a contract beats a cast.
  • Event Dispatchers - Bind vs Assign vs Call, broadcaster/listener direction, binding lifecycle, and why dispatcher calls can appear to repeat.
• Collision
  • On Component Begin / End Overlap - trigger setup, duplicate component-pair events, and the settings that decide whether overlap notifications fire.
  • Get Overlapping Actors / Components / Is Overlapping Actor - current tracked overlap state, actor-vs-component scope, empty results, occupant sets, event re-checks, and local multiplayer boundaries.
  • Event Hit - blocking contact, hit-result fields, physics hit notifications, and why hits can repeat.
  • Break Hit Result - status flags, Location vs Impact Point, Normal vs Impact Normal, optional object and surface fields, and why breaking a struct does not validate it.
  • Line Trace By Channel - start/end math, trace channels, hit results, debug drawing, and ignoring yourself.
  • Line Trace For Objects / Multi Line Trace For Objects - Object Type masks, single-vs-multi results, unselected occluders, custom object channels, de-duplication, and channel-trace boundaries.
  • Sphere Trace, Capsule Trace, and Multi Trace basics - thick swept queries, hit arrays, duplicate filtering, and melee/shotgun trace patterns.
  • Set Collision Enabled / Response / Profile Name - runtime component collision modes, response-channel edits, profile changes, actor-wide collision gates, and visibility traps.
  • Get / Set Generate Overlap Events / Set Notify Rigid Body Collision - overlap-pair notification gates, current-contact refresh, swept-versus- simulated hit paths, multi-body scope, and local authority limits.
  • Get Actor Bounds / Get Component Bounds / Get Local Bounds - Actor aggregation, one-component world boxes/spheres, Static Mesh local Min/Max, half-extents, rotation inflation, cached-bound timing, and broad-phase versus exact collision use.
• Components
  • Activate / Deactivate / Set Active / Is Active / Set Component Tick Enabled - generic component active state, activation events, Reset semantics, Auto Activate, tick capability/start settings, specialized behavior, and replication boundaries.
  • Destroy Component and runtime Component lifetime - immediate teardown versus later garbage collection, owner-only Blueprint calls, End Play cleanup, attachment survival, component origins, stale references, and replicated lifetime boundaries.
  • Get Anim Instance / Set Animation Mode / Set Anim Instance Class - live transient Anim Instances, component-owned modes/classes, reinitialization, Skeleton compatibility, timing, and local lifetime.
• Development
  • Print String and the Output Log - screen vs log output, the Key anti-spam pin, value conversion, and why prints are development-only debugging.
• Game
  • Get Player Character / Pawn / Controller - what player index 0 means, what each getter returns, and why they are not NPC or multiplayer shortcuts.
  • Get Game Mode / Game State / Player State - framework getters, server-only GameMode, replicated GameState, PlayerState lists, casts, and client-safe UI lookup paths.
  • Open Level - full map travel, by-name vs object-reference destinations, travel options, and why old-world actors do not survive.
  • Load Stream Level / Unload Stream Level - latent sublevel load/unload requests, visible-vs-loaded state, persistent-level ownership, and streaming vs Open Level.
  • Create Local Player / Get Num Player Controllers - local players, split-screen controller counts, owning-player UI, and why local multiplayer is not network multiplayer.
  • Set Game Paused - pause/unpause return values, what game pause does and does not stop, and the widget/input bundle a pause menu still needs.
  • Spawn Actor from Class - what the node creates, why it can return None, and what the Owner and Instigator pins actually mean.
  • Construct Object from Class - plain runtime UObject instances, declared versus real class type, Outer containment/context, initialization, strong references, and the replication/SaveGame boundary.
  • Get Instigator / Get Instigator Controller - responsible-Pawn attribution, live Controller lookup, spawn-time setup, failure, damage credit, and authority boundaries.
  • Projectile Movement Component and first projectile actor - updated components, initial speed/velocity, local direction, gravity, bounce, homing, collision, and cleanup for spawned projectiles.
  • Add Component by Class / Child Actor Component - runtime component creation, component ownership, returned component references, and authored child actors.
  • Player Start, Restart Player, and checkpoints - GameMode spawn selection, PlayerStart markers, checkpoint IDs, respawn, and pawn/UI rebinding.
  • Set View Target with Blend - controller-level camera view switching, CameraActor blends, and why view target is not possession.
  • PlayerCameraManager and Camera Shake - local camera shakes, returned shake instances, stopping effects, split-screen targets, and multiplayer presentation.
  • Event AnyDamage / Apply Damage - the damage sender/receiver flow, the server-only event, and why health is still your Blueprint's job.
  • Apply Point Damage / Apply Radial Damage / Damage Type - point-hit data, radial radius/prevention rules, damage return values, and how Damage Type classes should be used.
• SaveGame
  • Save Game: Create / Save / Load Game to Slot - SaveGame objects, slot names, user index, manual copy-in/copy-out, and why live actor references are not durable save data.
  • Does Save Game Exist / Delete Game in Slot / Async Save Game to Slot - slot existence checks, delete results, async completion, UI gating, and overlapping save/load request traps.
• Settings
  • Get Game User Settings / Load / Apply / Save / Reset and dirty state - the process-global local-machine settings object, requested versus live state, lifecycle call side effects, runtime dirty checks, persistence limits, command-line overrides, and custom-class boundaries.
  • Game User Settings: resolution, fullscreen, VSync, frame limit, scalability, and benchmark - requested, current, and last-confirmed video modes; output versus scene resolution; quality presets and custom mixes; safe timed rollback; and benchmark population versus application.
• Input
  • Add Mapping Context - applying Enhanced Input contexts to the local player, priority, removal, and respawn/possession traps.
  • Input Action Event and Enhanced Input Action Values - binding action lifecycle events, reading bool and axis values, and separating local input ownership from authoritative multiplayer logic.
  • Enhanced Input Modifiers: Negate, Swizzle, Scalar, and Dead Zone - modifier ordering, WASD axis construction, analog dead zones, response curves, and per-player runtime settings.
  • Enhanced Input User Settings: map, unmap, reset, apply, and save - per-local-player profiles, stable mapping identity, registration, failure tags, rebuild timing, resets, Apply hooks, and persistence.
  • showdebug enhancedinput and Input Debugging - a repeatable ladder across contexts, priorities, values, trigger states, Blueprint instances, UI focus, pause, PIE clients, and stale mappings.
  • Set Input Mode & Show Mouse Cursor - Game Only vs Game and UI vs UI Only, cursor visibility, focus, pause menus, and restoring gameplay input on close.
  • Enable Input / Disable Input / Set Ignore Move and Look Input - actor input stack registration, controller movement/look gates, stacked ignore calls, and Enhanced Input separation.
• Math
  • Get Forward Vector & Find Look at Rotation - direction vectors, actor vs control/camera forward, spawning in front, and yaw-only look-at rotation.
  • Vector Length / Vector Length XY / Normalize - 3D and ground magnitude, safe direction vectors, units, diagonal input, and squared-distance comparisons.
  • Distance (Vector) / Get Distance To / Distance Squared - point versus Actor-pivot distance, missing-Actor zero fallback, 3D/XY policy, squared thresholds, and surface/path boundaries.
  • Dot Product, Angle, and Facing Checks - normalized alignment, front/behind and field-of-view tests, signed movement components, coordinate spaces, traces, and AI perception.
  • Clamp / Map Range Clamped / Normalize To Range - limiting versus remapping, bounded and unbounded ratios, reversed/equal ranges, UI percentages, dead zones, and integer conversion.
  • Break/Make Vector and Rotator / Transform Location / Inverse Transform Location - struct pins, local/world point conversion, position versus direction, inverse transforms, sockets, and non-uniform scale.
• Movement
  • Is Falling / Movement Mode / On Movement Mode Changed - falling as a mode rather than a velocity direction, full mode/custom-mode reads, landing timing, animation caching, and network-role observations.
  • Disable Movement / Set Movement Mode / Stop Movement Immediately - disabled mode versus a zero-velocity stop, safe restoration, AI path cancellation, separate motion owners, and server authority.
• Niagara
  • Spawn System at Location / Attached - world-space and attached Niagara spawns, returned components, auto-destroy, pooling, and multiplayer VFX state.
• Pawn
  • Possess / Un Possess / Get Controller - controller-to-pawn links, authority-only possession, unpossessed pawns, AI/player controllers, and view-target lookalikes.
  • Spawn Default Controller and Auto Possess AI - default AIController creation, placed-vs-spawned auto-possession, and proving an enemy has a controller before debugging movement.
  • Get Control Rotation / Get Base Aim Rotation / Get Player View Point - controller intent, Pawn aim policy, player/AI viewpoints, yaw-only movement, camera traces, split-screen, and remote-network limits.
  • Add Controller Yaw/Pitch Input / Set Control Rotation - incremental local-player look input, absolute Controller rotation, device/time scaling, pitch limits, facing, and network ownership.
  • Add Movement Input - world direction, Scale Value, Character vs raw Pawn behavior, and why the node can fire without visible movement.
• Physics
  • Add Impulse / Add Force - one-shot impulses, continuous forces, mass flags, Simulate Physics prerequisites, and Character knockback lookalikes.
  • Set Simulate Physics / Is Simulating Physics / Set Enable Gravity - component/body selection, attachment handoff, gravity, collision, sleep, welding, ragdolls, and server-owned physics transitions.
  • Physics Handle: Grab / Set Target / Release - component/body acquisition, location/rotation constraints, target updates, tuning, collision, release cleanup, and server authority.
  • Get / Set Physics Linear and Angular Velocity - one-body linear and angular motion, world-space units, Bone Name selection, direct replacement versus addition, zero/no-op failures, teleport/constraint interactions, and server authority.
• List View
  • ListView / TileView: Set List Items, entry lifecycle, and refresh - virtualized item objects versus pooled entry widgets, replacement and incremental mutation, assignment/release events, deferred refresh, and full regeneration.
• User Interface
  • Create Widget + Add to Viewport - widget creation, owning player, Z-order, keeping references, and why player UI should usually be owned by the controller or HUD path.
  • Remove from Parent and widget lifetime - removing widgets from parent/viewport, stored references, Construct and Destruct timing, input restore, and dispatcher cleanup.
  • Project World Location to Widget Position and off-screen markers - player-local UMG coordinates, DPI-safe placement, pivots, edge clamping, safe zones, occlusion, split-screen, and pooled marker updates.
  • Set Visibility: Hidden, Collapsed, and hit testing - widget painting, layout space, parent/child hit testing, focus, animations, bindings, disabled state, and local-player ownership.
  • Set Text, Format Text, and Text vs String vs Name - direct Text Block updates, binding replacement, typed formatting, localization, conversions, rich text, and client-local presentation.
  • Slider / Check Box / Combo Box String: values, setters, and change events - domain and normalized Slider values, three-state Check Boxes, stable Combo Box option IDs, programmatic event differences, and guarded draft requests for mouse, keyboard, and gamepad users.
  • Input Key Selector: selected chord, capture events, cancel, and conflict handoff - one-key chord capture, selection-state versus candidate events, cancel and focus policy, modifier limits, and transactional conflict handoff.
  • Canvas Panel Slots: Anchors / Offsets / Alignment / Size to Content - parent-owned slot types, fixed versus stretched offsets, layout pivots, desired-size ownership, Canvas layers, DPI, and safe runtime access.
  • Set Position / Desired Size / Alignment in Viewport - root viewport slots, explicit size and pivots, DPI coordinate ownership, layout timing, responsive anchors, safe zones, and split-screen placement.
  • Set Keyboard Focus / Set User Focus / Set Is Enabled - keyboard versus player-specific focus, focus eligibility and navigation, ancestor-disabled state, modal recovery, and local-player ownership.
• Rendering
  • Set Actor Hidden In Game / Set Visibility - actor-wide hiding, component visibility, and why invisible is not disabled, destroyed, or non-colliding.
  • Spawn Decal at Location - impact decals, hit Impact Point and Impact Normal, lifespan cleanup, and why decals are visual feedback only.
• Transformation
  • Attach Actor To Component - attach rules, sockets, root components, and why physics can fight a held item.
  • Get Actor / Component Location, Rotation, and Transform - root-derived Actor transforms versus exact component world/relative snapshots, pivots, scale, attachment, and invalid targets.
  • Get Socket Location / Rotation / Transform / Does Socket Exist - component-owned sockets and bones, transform spaces, plausible missing-name fallbacks, current animation pose, attachments, and muzzle/grip patterns.
  • Set Actor Location / Rotation / Transform - direct root-component placement, Sweep, Teleport, movement lookalikes, and actor-vs-component transform choices.
  • Set World / Relative Location / Rotation / Scale / Transform - exact Scene Component targets, world-versus-parent space, target-only translation sweep, mobility, physics ownership, and replication limits.
• Animation
  • Animation Montages / Play Montage - slots, sections, callback pins, failed playback, and when one-shot actions belong outside the locomotion state machine.
  • Calculate Direction - world Velocity relative to a chosen yaw, signed strafe angles, the backward seam, idle gating, and thread-safe Animation Blueprint use.
  • Time Remaining / Relevant Anim Time Remaining / Automatic Rule - named versus most-relevant asset-player clocks, seconds and ratios, looping/blended-player traps, crossfade lead, and automatic transitions.
  • Try Get Pawn Owner — the page that started this wiki.
  • Event Blueprint Update Animation — the Animation Blueprint's per-update data gathering event.
• Utilities
  • Array Get / Length / Last Index / Is Valid Index - zero-based slots, copy/reference reads, empty and out-of-range behavior, object validity, random selection, and shrink-safe iteration.
  • Array Add / Add Unique / Insert / Remove / Find / Contains - mutation and search return values, equality rules, index shifts, missing-item results, and safe removal while iterating.
  • Set Array Elem / Resize / Clear / Append Array - replacement versus growth, default-filled gaps, shrinking/clearing, Append copy and alias boundaries, struct write-back, and notifications.
  • Set and Map Add / Find / Contains / Remove / Clear - unique membership, key replacement, missing lookup results, hashing, value-copy writeback, unstable order, and persistence boundaries.
  • Get Data Table Row / Row Found / Row Not Found - typed row lookup, success/failure execution paths, wildcard output resolution, schema changes, import keys, and packaged-build failures.
  • Get Class / Class Is Child Of / Is Valid Class - object-vs-class references, runtime class inspection, equality-inclusive inheritance checks, class validity, defaults, and unloaded-class limits.
  • Cast To X — why a Blueprint cast is a type check, not a conversion.
  • Delay, DoOnce, Gate, Sequence, and latent flow - latent pauses, remembered flow-control state, reset paths, and when to use timers or explicit variables instead.
  • Is Valid — the object-reference guard that checks both None and destruction state.
  • Get Game Time / Unpaused Time / Real Time / World Delta Seconds - pause, global-dilation, per-world, frame-delta, travel, precision, and authoritative multiplayer clock boundaries.
  • Set Timer by Event / Clear Timer by Handle - timer handles, looping callbacks, clearing/replacing timers, and why timers are not background threads.
  • Timelines / Add Timeline / Play / Reverse / Finished - authored curve playback, Update and Finished pins, Play/Reverse modes, looping, pause, and actor lifetime.
  • Get Velocity — actor velocity, ground speed, and the Vector Length XY animation idiom.

Want a page that doesn't exist yet?

See the roadmap — and add the official doc link plus the questions it failed to answer. That's all a new page needs to get started.

---

Not affiliated with Epic Games. Unreal and Unreal Engine are trademarks of Epic Games, Inc.