LCM Nav3D - API Reference

The classes, functions and properties you can reach from Blueprint, the Details panel, a Behaviour Tree, a StateTree or a Mass config.

Internal C++ - solver internals, replication contracts, subsystems with no Blueprint surface - is deliberately not listed. If a type is not here, you are not expected to call it.

Classes

LcmAIPerceptionBridge

Mirrors UAIPerceptionComponent-sensed actors into a decaying threat tracker for the tactical EQS surface.

Functions

• HandleTargetPerceptionUpdated - Bound to the paired UAIPerceptionComponent's OnTargetPerceptionUpdated.
• GetTrackedThreats - Current tracked-threat actors (post-decay).

Properties

• DecayWindowSeconds - Seconds a lost-sight threat stays queryable before it decays out.
• PerceptionComp - The paired perception component (found on the owner at BeginPlay).

LcmBTDecorator_ChunkLoaded

Decorator that passes only when the SVO chunk containing the queried world position is currently loaded (cheap single-endpoint hash lookup, no path probe).

Properties

• QueryLocationKey - Blackboard key holding the world position to probe. Accepts Vector or Object (Actor location is used in the latter case).
• bRequireFullResolution - When true (default), only fully-resolved chunks (promoted to full resolution) satisfy. When false, any loaded chunk does.

LcmBTDecorator_HasLineOfSight

Decorator that passes when the agent has volumetric line of sight to the target via the Lazy Theta* LOS walker, honouring AgentRadius through the JFA clearance gate.

Properties

• TargetKey - Blackboard key for the LOS target. Vector = world location, Object = AActor (its current location is used).
• AgentRadius - Agent collision radius for the JFA clearance gate. Higher = more conservative (rejects narrow gaps).

LcmBTDecorator_IsInCover

Decorator that passes when the agent is in cover relative to a threat: its leaf SweepPenalty is at or below MaxSweepPenalty AND the threat's line of sight to it is blocked.

Properties

• ThreatKey - Threat key. Vector = world location, Object = AActor.
• MaxSweepPenalty - Highest SweepPenalty (0.255) the agent's leaf may carry to count as safe. Default 32 ≈ "lightly swept, mostly safe".
• AgentRadius - Agent collision radius for the LOS walker's clearance gate.

LcmBTDecorator_PathLengthBelow

Decorator that passes when the true-3D LCM Nav3D path distance from the agent to the goal is below MaxLengthCm (uses the synchronous tactical-library path probe; do not run per-frame).

Properties

• GoalKey - Blackboard key for the goal endpoint. Vector = world location, Object = AActor (its current location is used).
• MaxLengthCm - Maximum allowed path length, in centimetres, for the decorator to pass.
• AgentRadius - Agent collision radius (cm) used by the path probe's clearance gate.

LcmBTDecorator_ThreatVisibleViaPerception

Decorator that passes when AIPerception currently perceives a hostile AND the agent has clear volumetric LOS to it (the "can-shoot-now" gate).

Properties

• ThreatKey - Optional explicit threat key. When unset (NAME_None), the decorator uses AIPerception's closest currently-perceived actor.
• AgentRadius - Agent collision radius (cm) used by the LOS walker's clearance gate.

LcmBTService_NavigationLoad

Service that each tick writes the navigation manager's SVO streaming stats into a blackboard key so designers can gate expensive LCM Nav3D queries on idle streaming.

Properties

• LoadedChunkCountKey - Int blackboard key receiving the count of currently loaded SVO chunks.

LcmBTService_PathProgressMonitor

Service that each tick writes a Euclidean approach-progress fraction (1 - dist/initial_dist) and remaining distance to the goal into blackboard keys.

Properties

• GoalKey - Blackboard key for the goal. Vector = world location, Object = AActor (its current location is used).
• ProgressKey - Float blackboard key receiving the progress fraction (0.1) toward the goal.
• RemainingCmKey - Float blackboard key receiving the remaining straight-line distance (cm) to the goal.
• GoalChangeTolerance - Distance (cm) the goal must move before the progress baseline is re-anchored.

LcmBTService_SquadSnapshot

Service that each tick aggregates perceived allies within SquadRadius and writes ally count, squad centroid, and cohesion radius into blackboard keys.

Properties

• AllyTag - Tag filter - only perceived actors with this tag count as ally.
• SquadRadius - Radius (cm) around the agent within which allies are counted.
• bIncludeSelf - When true, the agent itself is included in the squad aggregate.
• NumAlliesKey - Int blackboard key receiving the number of allies in the squad.
• CentroidKey - Vector blackboard key receiving the squad's centroid (average ally position).
• CohesionRadiusKey - Float blackboard key receiving the cohesion radius (max ally distance from the centroid, cm).

LcmBTService_ThreatFieldSampler

Service that each tick samples the SVO SweepPenalty risk field at the agent's location, writing the threat level and an "in threat zone" flag (level >= AlertThreshold) into blackboard keys.

Properties

• ThreatLevelKey - Int blackboard key receiving the current SweepPenalty (0.255).
• InThreatZoneKey - Bool blackboard key receiving Level >= AlertThreshold.
• AlertThreshold - SweepPenalty value (0.255) at or above which the agent counts as in a threat zone.

LcmBTTask_ChunkPrewarm

Task that proactively forces SVO chunk generation at a target location and waits (up to TimeoutSeconds) for the chunk to become ready before succeeding.

Properties

• TargetKey - Blackboard key for the location whose chunk to prewarm. Vector = world location, Object = AActor (its current location is used).
• bRequireFullResolution - When true, the task waits for the chunk to be fully resolved (post-promotion); when false, any loaded chunk satisfies.
• TimeoutSeconds - Maximum time (seconds) to wait for the chunk before the task fails.

LcmBTTask_DynamicObstaclePush

Task that steers the agent down the SweepPenalty gradient (away from rising threat) until it clears the obstacle or times out.

Properties

• PushSpeed - Movement speed (cm/s) while pushing away from the obstacle.
• ProbeStep - Step distance (cm) used to sample the SweepPenalty gradient around the agent.
• ExitThreshold - SweepPenalty value (0.255) at or below which the agent is considered clear and the task succeeds.
• MaxDuration - Maximum time (seconds) to push before the task succeeds and yields.

LcmBTTask_EvadeCBS

Task that retreats from the threat gradient using context-based steering (CBS) over SVO danger sampling, blending an anti-threat direction with ray-evaluated safe headings until clear or timed out.

Properties

• EvadeSpeed - Movement speed (cm/s) while evading.
• ProbeStep - Step distance (cm) used to sample the SweepPenalty gradient around the agent.
• ExitThreshold - SweepPenalty value (0.255) at or below which the agent is considered safe and the task succeeds.
• MaxDuration - Maximum time (seconds) to evade before the task succeeds and yields.
• AgentRadius - Agent collision radius (cm) used when evaluating SVO danger for the CBS rays.
• LookAheadDistance - Distance (cm) ahead along each CBS ray over which SVO danger is sampled.
• NumCBSRays - Number of context-based-steering rays cast around the agent to select a safe heading.

LcmBTTask_FindCover

Behavior Tree task that locates a navigable SVO leaf with line-of-sight blocked from the blackboard enemy actor (i.e. cover). Returns Succeeded once a valid cover location is written back to the blackboard, or Failed if no cover within SearchRadius qualifies.

Properties

• EnemyKey - The Blackboard Key for the Enemy actor (Who are we hiding from?)
• SearchRadius - Search Settings (Exposed to Behavior Tree)
• CoverHeightOffset - Vertical offset (cm) added to candidate cover positions so the pawn stands above the cover floor rather than embedded in it.
• bPrioritizeClosest - When true, the closest qualifying cover position wins. When false, the search picks the first qualifying candidate (lower latency).

LcmBTTask_FlyTo

Behavior Tree task that flies an AI pawn from its current position to a blackboard target via the LCMNav3D pathfinder. Owns one async path request token (re-issued on dynamic replanning), runs per-tick steering (configurable flight style + avoidance style + wall avoidance + swarm separation), and finishes the task on arrival within AcceptanceRadius.

Functions

• OnPathFound - The Callback function for Async Pathfinding

Properties

• AcceptanceRadius - Settings exposed to the Behavior Tree Node
• FlightSpeed - Cruise speed of the pawn along the path, in cm/s.
• QueryOptions - Per-request pathfinding options (solver choice, smoothing, heuristic mode, Filter Class, Require Complete Path). Forwarded as-is into FindPathAsync. An empty Filter Class uses the AI controller's Default Navigation Filter Class.
• TimeoutSeconds - Report Failed after this many seconds of flight. 0 (default) = no limit.
• SeparationRadius - How close is "too close" to another agent? (e.g. 150 units)
• SeparationWeight - How hard should we push away from neighbors? (0.0 = No push, 2.0 = Strong push)
• bUseFlightMovementComponent - Delegate locomotion to a ULcmFlightMovementComponent on the pawn (for ultra-realistic 6-DOF drone/bird/fish dynamics). When ON and the pawn has an enabled component, this task only produces the guidance velocity (pure-pursuit + avoidance + arrival slowdown) and the component owns position + orientation. OFF (default) = the built-in kinematic integrator below. The kinematic-only knobs below (accel/banking/flight style) hide when this is ON - the component owns them via its FlightConfig.
• MaxAcceleration - How fast can we accelerate? (Higher = Snappier, Lower = Drifty/Heavy) [Kinematic only - owned by the flight component when delegating.]
• BankingAmount - How much do we bank into turns? (Visual only) [Kinematic only.]
• MaxBankingAngle - Max banking angle in degrees (e.g., 45 degrees) [Kinematic only.]
• DecelerationDistance - Distance to start slowing down (Arrival behavior). Still used when delegating - it shapes the guidance target speed near the goal.
• FlightStyle - Choose how this agent moves [Kinematic only - the component's FlightConfig has its own model/style when delegating.]
• AvoidanceTimeHorizon - How many seconds into the future do we look? (Standard: 2.0s)
• CollisionMargin - Radius multiplier for safety (e.g. 1.2 = Avoid by 20% extra margin)
• AvoidanceStyle - Choose how this agent avoids neighbors
• WallCheckDistance - WALL AVOIDANCE How far to check for walls? (e.g. 150 units)
• WallPushForce - How hard to push away from walls? (Must be strong!)
• PathCenteringForce - PATH CORRECTION How hard to pull agents back to the center line? (e.g. 500) 0 = Free drift (current behavior) 1000 = Strict line following (Train on tracks)
• bEnableGoalPrediction - When true, AND r.LcmNav.Chase.Enable != 0, the task resolves moving Object-key goals through FLcmGoalProvider and uses constant-velocity lead prediction (linear-extrapolation intercept) as the planner goal. When false, the legacy snapshot behavior is preserved bit-identically.
• LeadSecondsCap - Upper bound on lead time (seconds). Forwarded as LeadSecondsCap to FLcmGoalProvider::GetLeadPosition. Clamps blow-up when the target is receding faster than the agent can close. Override at runtime via r.LcmNav.Chase.LeadSecondsCap (>= 0). Typical 0.5 to 2.0.
• DriftReplanCm - Distance (cm) between the last-planned goal and the current lead position that triggers an automatic replan. Override at runtime via r.LcmNav.Chase.DriftReplanCm (>= 0).
• bForceEnableChase - Per-task override for the r.LcmNav.Chase.Enable CVar gate. When true, chase activates from bEnableGoalPrediction alone - you don't need to know the CVar exists. Default false preserves the legacy two-gate behavior (CVar AND bEnableGoalPrediction) bit-identically. The CVar is retained as a project-wide kill switch / debug toggle.

LcmBTTask_FollowFlowField

Task that computes an LCM Nav3D path to the goal and follows its waypoints (LinearDirect steering) until arrival or timeout.

Properties

• GoalKey - Blackboard key for the goal. Vector = world location, Object = AActor (its current location is used).
• MoveSpeed - Movement speed (cm/s) along the followed path.
• WaypointAdvanceRadius - Distance (cm) within which the current waypoint is considered reached and the next is selected.
• ArrivalRadius - Distance (cm) from the goal at which the task succeeds.
• AgentRadius - Agent collision radius (cm) used by the path probe's clearance gate.
• MaxDuration - Maximum time (seconds) to follow the path before the task fails.

LcmBTTask_FollowTarget

Task that holds a 3D offset from a moving target: escort, wingman, overwatch drone. It does not terminate on arrival the way a move task does, because the slot it is holding keeps moving.

The agent matches the target's velocity and corrects the residual offset error on top of that, so a follower that is tracking well sits on its slot rather than trailing behind it by a fixed lag. The target's velocity is measured from its observed motion, so it works for a target moved by any means, including one with no movement component.

The slot is re-checked as the target moves and pulled in toward the target if it would otherwise sit inside geometry: a leader hugging a wall does not drag its escort into that wall.

Properties

• TargetKey - Blackboard key for the target to follow. Object = AActor (the useful form), Vector = a fixed point, which reduces the node to a hold.
• Offset - The slot to hold, in the frame chosen by Frame. Default is 400 cm behind and 200 cm above.
• Frame - How Offset is interpreted. World = fixed world axes, so the slot never rotates. Leader Rotation = the offset rotates with the target's actor rotation, for a wingman that stays on one wing through a turn. Leader Velocity = the offset is built from the target's direction of travel, which is the right choice when the target's own rotation is not meaningful. The travel frame is held through the target's stops rather than collapsing.
• MaxSpeedCmS - The follower's own top speed (cm/s). A target faster than this will out-run the follower.
• CorrectionGain - How hard (1/s) the follower corrects offset error on top of matching the target's velocity.
• SlotDeadbandCm - Inside this distance the follower stops correcting, so a formation settles instead of hunting.
• AgentRadiusCm - Agent radius used when checking the slot for clearance.
• bRequireLineOfSight - Require the slot to see the target; a blocked slot is pulled in until it can.
• MaxDurationSeconds - Ceiling (seconds) on the escort, after which the task succeeds. 0 = follow until something else stops it.
• bSucceedWhenInFormation - Succeed once the slot has been held continuously for FormationHoldSeconds. Off by default. Useful for a "form up, then advance" sequence.
• FormationToleranceCm - How close to the slot counts as in formation.
• FormationHoldSeconds - How long the slot must be held before succeeding.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_Hover

Task that holds a position, optionally facing something, optionally for a fixed time.

Hovering is not the same as commanding zero velocity. A body with momentum that is told to stop coasts until drag absorbs it, which for a winged agent can be a long way. This task holds a point, so the agent returns to it.

Properties

• Anchor - Where It Started holds wherever the agent was when the task began. Explicit Point holds the point named by AnchorKey.
• AnchorKey - Blackboard key giving the anchor when Anchor is Explicit Point. Vector = world location, Object = AActor.
• HoverDurationSeconds - How long to hover before succeeding. 0 = hover until the parent aborts or a decorator exits.
• AgentRadiusCm - Agent radius used when checking an authored anchor.
• FaceTargetKey - Optional blackboard key to face while hovering. Leave unset to hold rotation.
• FaceTurnRateDegPerSec - Turn rate (deg/s) used when facing.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_Land

Task that brings the agent down to a landing point, proving the descent corridor is clear as it goes. LandTarget chooses how the landing point is found: an authored world height, the surface directly below, or a search for a flat enough site nearby.

If the SVO is not resident under the agent (a streaming gap), the task waits rather than failing, because landing in the wrong place is worse than pausing.

Properties

• LandTarget - How the touchdown point is chosen. Explicit Z descends to the authored TouchDownZ. Surface Below traces down and lands on whatever is actually there. Landing Site searches within SiteSearchRadiusCm for a site no steeper than MaxSlopeDegrees.
• TouchDownZ - Target world Z height (cm), used when LandTarget is Explicit Z.
• DescentRate - Vertical descent speed in cm/s.
• TouchDownTolerance - Distance (cm) above the touchdown point at which the agent counts as landed.
• MaxDescentCm - How far down (cm) to look for a surface. Beyond this the task reports no surface and fails.
• AgentRadiusCm - Agent radius used to size the descent corridor test and the site search.
• SiteSearchRadiusCm - Radius (cm) searched for a landing site when LandTarget is Landing Site.
• MaxSlopeDegrees - Steepest surface (degrees from horizontal) still accepted as a landing site.
• MaxDurationSeconds - Ceiling (seconds) on the whole descent. 0 disables. Guards against a descent that never progresses.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_LookAt

Task that rotates the agent to face a target, easing in, and succeeds once it is pointing within AcceptableErrorDegrees.

The alignment test is a true 3D angle, so a target directly above or below the agent is handled correctly. See the note under LcmBTTask_TurnInPlace for why this matters and when the engine's stock rotation task is the better choice.

Properties

• TargetKey - Blackboard key for what to face. Vector = world location, Object = AActor.
• InterpSpeed - Smoothing rate for the eased turn. Higher is faster.
• TurnRateDegPerSec - When above 0, turn at this constant rate instead of easing. Takes precedence over InterpSpeed.
• AcceptableErrorDegrees - Angle within which the agent counts as facing the target.
• MaxDuration - Ceiling (seconds) on the turn.
• bFailOnTimeout - When true, reaching MaxDuration fails the task. Default false, so a turn that runs out of time still succeeds and the tree continues.
• bRequireLineOfSight - Require sight of the target. During a streaming gap the task waits rather than failing.
• bHoldStation - Hold position while turning, so the agent does not drift during the turn.
• AgentRadiusCm - Agent radius used for the line of sight check.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_MoveToAndFace

Task that moves the agent to a destination and then turns to face something once it arrives. The two halves are one task on purpose, so the turn is guaranteed to follow the arrival.

If no separate face target is set, the agent faces its destination. This is the "arrive at the perch and look at the door" node.

It is not a replacement for LcmBTTask_FlyTo: it plans one route on entry and follows it. Use FlyTo for long range travel with replanning and avoidance, and this for the last leg.

Properties

• MoveTargetKey - Blackboard key for where to move to. Vector = world location, Object = AActor.
• FaceTargetKey - Blackboard key for what to face on arrival. Leave unset to face the destination.
• MoveSpeed - Movement speed (cm/s).
• ArrivalRadius - Distance (cm) within which the destination counts as reached.
• bNavigateToTarget - Plan a route to the destination instead of moving in a straight line.
• MaxMoveSeconds - Ceiling (seconds) on the move half. Reaching it fails the task.
• FaceAcceptableErrorDegrees - Angle within which the agent counts as facing the face target.
• FaceTurnRateDegPerSec - Turn rate (deg/s) for the facing half.
• MaxFaceSeconds - Ceiling (seconds) on the turn.
• bFailOnFaceTimeout - When true, a turn that runs out of time fails the task. Default false, so the move still counts.
• bRequireLineOfSight - Require sight of the face target before the turn counts as done.
• AgentRadiusCm - Agent radius used for routing and sight checks.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_OrbitTarget

Task that circles the agent around a target, holding OrbitRadius while moving tangentially at OrbitSpeed.

Properties

• TargetKey - Blackboard key for the orbit centre. Vector = world location, Object = AActor (its current location is used).
• OrbitRadius - Distance (cm) the agent maintains from the target while orbiting.
• OrbitSpeed - Tangential movement speed (cm/s) around the orbit.
• bClockwise - When true, orbit clockwise (viewed from above); when false, counter-clockwise.
• bMatchTargetZ - When true, the agent matches the target's world Z height while orbiting; when false, it holds its own height.
• AgentRadiusCm - Agent radius used when testing each step of the orbit for clearance.
• MaxDurationSeconds - Ceiling (seconds) on the orbit. 0 = orbit until something else stops it.
• Revolutions - Stop after this many full turns. 0 = never stop on revolutions.
• bRequireLineOfSight - Require sight of the orbit centre. Sight lost for longer than LostPatienceSeconds fails the task.
• LostPatienceSeconds - How long (seconds) sight of the centre may be lost before the task fails.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_Patrol

Task that moves the agent through a list of waypoints in order, pausing at each, optionally looping. By default it routes between waypoints through the navigation data rather than flying the straight line, so a patrol whose waypoints are separated by geometry follows the building instead of passing through it.

While dwelling at a waypoint the agent holds station, so a body with momentum stays on the waypoint rather than drifting off it.

Properties

• Waypoints - Ordered list of patrol waypoints, in world coordinates.
• MoveSpeed - Movement speed (cm/s) between waypoints.
• ArrivalRadius - Distance (cm) within which a waypoint counts as reached.
• DwellSeconds - Time (seconds) the agent dwells at each waypoint before advancing.
• bCycle - When true, the patrol loops back to the first waypoint after the last; when false, it ends.
• bNavigateBetweenWaypoints - Plan a route for each leg instead of moving in a straight line. Defaults on. When no route can be planned (for example the navigation data is not resident yet) the leg falls back to the direct line and the next leg is planned again, so a patrol never freezes waiting for data.
• FaceTravelRateDegPerSec - Turn rate (deg/s) used to face the direction of travel. 0 leaves rotation alone.
• MaxDurationSeconds - Ceiling (seconds) on the whole patrol. 0 = patrol until something else stops it. Worth setting when bCycle is on, since a cycling patrol has no natural end.
• AgentRadiusCm - Agent radius used when planning legs.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_TakeOff

Task that climbs the agent to a target altitude, proving the air above it is clear as it goes.

The ascent corridor is re-tested while climbing rather than only at the start, because a climb that has been stopped by a ceiling and a climb that is merely slow look identical from the outside. If the SVO is not resident the task waits rather than reporting a blocked climb.

Properties

• TakeOffTarget - Height Above Start climbs TargetHeightCm above wherever the agent began, which is the natural form for "get off the pad". Absolute Z climbs to the world height in TargetZ.
• TargetHeightCm - Height (cm) to climb above the start, when TakeOffTarget is Height Above Start.
• TargetZ - World Z height (cm) to climb to, when TakeOffTarget is Absolute Z.
• AscentRate - Climb speed in cm/s.
• ArrivalTolerance - Distance (cm) below the target height at which the climb counts as done.
• MaxDurationSeconds - Ceiling (seconds) on the climb. 0 disables.
• AgentRadiusCm - Agent radius used to size the ascent corridor test.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmBTTask_TurnInPlace

Task that rotates the agent toward a target at a constant rate, without translating, and succeeds once it is pointing within AcceptableErrorDegrees.

Why not the stock UBTTask_RotateToFaceBBEntry? For a walking agent, use it. For a flying one, note two things about it. Its success test uses a 2D angle that ignores the Z axis entirely, so a target directly above the agent reads as already faced. And it applies rotation through the AIController focus system, which drops pitch unless the pawn opts in with bUseControllerRotationPitch. On a volumetric agent that combination means the stock task can report success while pointing level at a target overhead. This task measures the real 3D angle and applies pitch.

Properties

• TargetKey - Blackboard key for what to face. Vector = world location, Object = AActor.
• MaxRotationRateDegPerSec - Constant turn rate in deg/s.
• AcceptableErrorDegrees - Angle within which the agent counts as facing the target.
• MaxDuration - Ceiling (seconds) on the turn.
• bFailOnTimeout - When true, reaching MaxDuration fails the task. Default false.
• bRequireLineOfSight - Require sight of the target. During a streaming gap the task waits rather than failing.
• bHoldStation - Hold position while turning.
• AgentRadiusCm - Agent radius used for the line of sight check.
• bUseFlightMovementComponent - Route movement through LcmFlightMovementComponent when the pawn has one.

LcmDynamicObstacleComponent

Marks an actor as a dynamic LCMNav3D obstacle.

Two operating modes, selected by r.LcmNav.DynObs.EventDriven:

1. EVENT-DRIVEN (default, EventDriven=1) -- binds to RootComponent->TransformUpdated. Per-event the component unions the new bounding box into a pending dirty region and arms a one-shot coalesce timer (r.LcmNav.DynObs.CoalesceMs, default 33 ms = one frame at 30 fps). On timer expiry the union of old-footprint + all coalesced new-footprints is flushed in a single UpdateDynamicObstacle call. Component tick is disabled in this mode. Zero CPU cost when the actor is stationary; instant response (within one coalesce window) when it moves.

2. POLLING (EventDriven=0) -- legacy behavior: TickComponent at 10 Hz polls GetActorLocation and fires only when displacement exceeds UpdateDistanceThreshold (default 50 cm). Provided for deterministic tests where event jitter would perturb traces.

Functions

• RemoveTrackedComponent - Runtime/BP removal of a previously added sub-component. Components listed in TrackedComponents (the designer list) are not affected.
• AddTrackedComponent - Runtime/BP registration of an obstacle sub-component (e.g. a child mesh attached after BeginPlay). Idempotent; rebinds immediately.

Properties

• UpdateDistanceThreshold - [Polling mode only] How far does the object need to move before triggering an SVO rebuild? Keep around half your MinVoxelSize (~50 cm). Ignored when r.LcmNav.DynObs.EventDriven=1 (event-driven mode uses a coalesce timer instead of a distance threshold).
• TrackedComponents - Designer-facing list - pick the collision/mesh components that actually represent this obstacle. Empty = whole actor (legacy).

EnvQueryContext_LcmKnownThreats

EQS context exposing tag-marked threat actors as query targets for tactical tests.

Properties

• ThreatTag - Actors carrying this tag are treated as threats.

EnvQueryContext_LcmThreatsFromAIPerception

EQS context exposing the querier's AI-perception-tracked threats as query targets.

EnvQueryGenerator_LcmHemisphericalRing3D

Hemispherical-ring shell of unblocked 3D points around a context.

Properties

• GenerateAround - Context the shell is centred on (the target; defaults to the querier).
• RadiusMin - Inner radius of the sampling shell (cm).
• RadiusMax - Outer radius of the sampling shell (cm).
• NumRadialSteps - Number of concentric radial steps between RadiusMin and RadiusMax.
• NumInclinationRings - Number of inclination (polar/elevation) rings from horizon to pole.
• NumAzimuthSectors - Number of azimuth (longitudinal) sectors around each ring.
• bUpperHemisphereOnly - Restrict to the upper hemisphere (high-ground / perch queries).

EnvQueryGenerator_LcmPointsAlongPath

Unblocked points sampled along the LCM Nav3D path from one context to another.

Properties

• FromContext - Path start (defaults to the querier).
• ToContext - Path goal (set this to your destination context).
• AgentRadius - Agent capsule radius used to plan the LCM Nav3D path that is sampled (cm).
• Spacing - Distance between consecutive sample points along the path (cm).

EnvQueryGenerator_LcmPortalProximity

Candidate points at macro-graph portal centres near a context (chokepoints).

Properties

• GenerateAround - Context the portal search is centred on (defaults to the querier).
• Radius - Only portals within this radius of the context are emitted (cm).

EnvQueryGenerator_LcmPointsInSVOVolume

Generates uniform-density candidate points in an AABB, filtered to unblocked SVO volume leaves.

Properties

• GenerateAround - Context the sampling volume is centred on (defaults to the querier).
• HalfExtent - Half-extent of the sampling AABB (cm).
• Spacing - Grid spacing between candidate points (cm).

EnvQueryTest_LcmLineOfSight3D

Visible to the context via true-3D SVO line of sight. Boolean.

Properties

• Context - Context to test visibility against (defaults to known threats).
• AgentRadius - Agent capsule radius used for the volumetric SVO LOS sweep (cm).

EnvQueryTest_LcmReachability3D

An LCM Nav3D path exists from the context to the item. Boolean.

Properties

• Context - Context the path is planned from (defaults to the querier).
• AgentRadius - Agent capsule radius used when testing for a valid LCM Nav3D path (cm).

EnvQueryTest_LcmPathDistance3D

LCM Nav3D path distance (NOT euclidean) from the context to the item. Float (cm).

Properties

• Context - Context the path distance is measured from (defaults to the querier).
• AgentRadius - Agent capsule radius used to plan the path that is measured (cm).

EnvQueryTest_LcmThreatExposure

Summed SweepPenalty along the item→threat segments. Float (lower = safer).

Properties

• Context - Threat context whose members the exposure is summed against (defaults to known threats).
• NumSamplesPerSegment - Number of sample points evaluated along each item->threat segment.

EnvQueryTest_LcmCoverScore3D

Fraction of context threats the item is occluded from. Float (higher = better cover).

Properties

• Context - Threat context the item must be occluded from to count as cover (defaults to known threats).
• AgentRadius - Agent capsule radius used for the occlusion LOS sweep to each threat (cm).

EnvQueryTest_LcmHeightAdvantage

Vertical advantage of the item over the context (high ground). Float.

Properties

• Context - Context the item's vertical advantage is measured against (defaults to known threats).

LcmFlightMovementComponent

Opt-in pawn movement component that turns nav guidance velocities (RequestVelocity from FlyTo tasks) into realistic 6-DOF flight/swim motion via ULcmFlightDynamics, sweeps the transform, and broadcasts the anim state. Inert until bEnabled is set.

Functions

• RequestVelocity - Feed the guidance command for this frame (world-space desired velocity). Persists until replaced or cleared, so a slower controller tick still produces continuous motion.
• GetRigidState - The full 6-DOF integrator state from the last step.
• GetFlightState - The animation / secondary-motion drive signals from the last step.
• ClearGuidance - Stop consuming guidance and coast (dynamics still decelerate the body).

Properties

• bEnabled - Master opt-in. Default false → the component is inert (base behaviour), guaranteeing byte-identical motion to before it was added.
• FlightConfig - Body/aero/control tuning. The LocomotionModel + Archetype selectors live at the top of this struct and drive which parameters are shown (only the selected model/archetype's fields appear).
• bBroadcastAnimState - Each tick, push the flight state to the pawn's AnimInstance (and the owner) if it implements ILcmFlightAnimInterface. Default on; costs nothing unless an implementer exists.
• RigidState - Persistent integrator state, seeded from the pawn at BeginPlay and re-synced from the updated component each tick (so external teleports and swept-collision corrections are respected).
• FlightState - Last-step anim outputs.
• PendingDesiredVelocity - Latest guidance command and whether one is active.
• bHasGuidance - True when RequestVelocity was called since the last tick - gates the dynamics step so an unfed component coasts instead of integrating stale guidance.

LcmFlyToLocationAsyncAction

The LCM Fly To Location latent Blueprint node: flies a pawn to a point or an actor through LCM Nav3D and fires On Success or On Fail, like AI Move To. No Behavior Tree, StateTree or AI Controller needed. Runs the StateTree Fly To task's own code (FLcmSTTask_FlyTo::EnterFlight / TickFlight / ExitFlight), so the pawn flies exactly as under that task. One active request per pawn; a newer one aborts the older. See Tutorial 13.

Functions

• FlyToLocation - Fly a pawn to a location, or to an actor (following it if it moves). Inputs: Pawn, Destination, Target Actor, Acceptance Radius, and advanced Filter Class, Chase Moving Target, Flight Speed, Timeout Seconds.
• StopFlyTo - Stop whatever LCM Fly To is flying this pawn (On Fail, Aborted). The pawn holds where it is.
• IsFlyToActive - True while an LCM Fly To is flying this pawn.
• Cancel - Cancel this request (On Fail, Aborted).

Properties

• OnSuccess - Arrived. Carries the result (Success) and where the pawn was.
• OnFail - Did not arrive. Carries the result (NoPath, Failed, Aborted, TimedOut, InvalidRequest) and where the pawn was.

LcmFlyingPawn

Note: APawn already inherits from INavAgentInterface - re-listing it here triggers C4584 (duplicate base class). We just override the virtuals.

Properties

• CollisionSphere - Root sphere collision component for the flying pawn.
• MovementComponent - LCM Nav3D-aware floating movement component driving the pawn along nav paths.

LcmGameplayAbility_RequestPath

GameplayAbility wrapper around the LCM Nav3D async path request, gating it through the standard GAS cost/cooldown/cancellation pipeline (budget via ULcmNavAttributeSet) and broadcasting the resulting path on completion.

Functions

• OnApexPathFound - Async FindPathAsync callback (game thread): populates the result, broadcasts OnPathReady, and ends the ability.

Properties

• StartLocation - Path-search start.
• GoalLocation - Path-search goal.
• QueryOptions - Forwarded to FindPathAsync verbatim.
• BudgetCost - Cost in PathRequestBudget consumed per activation. Default 1. Reduce for "cheap" replans (e.g. drift-triggered) and raise for expensive cross-chunk queries.
• OnPathReady - Fired on completion (success or failure). Subscribers should receive PathPoints by-const-ref.

LcmMassCrowdSpawner

World-Partition-safe Mass spawner: never streams out, so its crowd's lifetime is not tied to the player's distance from the spawn point (fixes the "all agents disappear when the player leaves the area" WP trap).

Properties

• SpawnBatchPerFrame - Opt-in startup smoothing. Spawn at most N entities per frame instead of the whole crowd in one frame. 0 (default) = stock engine behaviour. A large one-frame spawn (e.g. 6000 agents) hitches startup ~70 ms; spreading it (e.g. 500) smooths that frame-pacing spike. Only applies when "Auto Spawn On Begin Play" is enabled. NOTE: this does NOT fix the editor's "Handled ensure: CurrentPhase==." Mass phase-manager spam - that is an engine-level startup race (observed on 5.2) (fires with 2 agents, on finite maps, independent of spawn load; handled + compiled out of Shipping), not a spawn-frame cost.

LcmMassFlowSteerTrait

[DEPRECATED - M3, 2026-07-03] Legacy flow-field crowd trait. Superseded by the unified ULcmMassNavAgentTrait ("LCM Nav3D Agent") with NavMode=FlowField, which composes a byte-identical archetype. Kept fully functional; prefer the unified trait for new content. Authoring trait for a flow-field-steered crowd agent.

Properties

• GoalMode - FixedLocation (use Goal) or TaggedActor (chase an actor by tag - the crowd follows it as it moves; the shared field re-solves on the move).
• Goal - Shared crowd goal (world space, FixedLocation mode). All agents with this goal share one field.
• TargetActorTag - Tag of the moving target actor (TaggedActor mode).
• bChaseLead - Lead the moving target by its velocity (intercept ahead of it).
• LeadSecondsCap - Upper bound on lead time (s).
• MaxSpeed - Movement speed (cm/s).
• AgentRadius - Collision radius (cm) - also the minimum agent size for field generation.
• AvoidanceRadius - Neighbours within this distance contribute local avoidance steering (cm).
• AvoidanceStrength - Weight of avoidance vs flow-following (0 = off, 1 = balanced).
• MaxAcceleration - Max acceleration (cm/s²). Smooth ease in/out; 0 = instant (legacy floaty). Applies only to PhysicsWeighted flight (LinearDirect is instant).
• MaxTurnRateDeg - Max turn rate (deg/s). The key knob: smooth banking turns vs robotic snapping. Applies only to PhysicsWeighted flight (LinearDirect is instant).
• ArriveRadius - Arrival / slow-down radius around the goal (cm).
• FlightStyle - LinearDirect (instant) vs PhysicsWeighted (turn-rate + acceleration inertia).
• AvoidanceStyle - None / Reactive (boids) / Predictive (ORCA, smooth mutual passing) / CBS.
• AvoidanceTimeHorizon - ORCA time horizon (s) - Predictive avoidance only.
• LaneBias - Lateral lane-spread strength (0 = off). r.LcmNav.Mass.FlowLaneBias (>=0) overrides.
• LaneDensityNorm - Neighbour count at which lane spreading saturates.
• bAnticipatory - ANTICIPATORY navigation: route the crowd around where moving obstacles are HEADING (their predicted swept path), not just where they are now - so it goes OVER a side gap that is about to close instead of squeezing into it. Costs a little more (predicted-occupancy stamping + slightly more re-solving) and can detour a touch wider. Off = today's reactive field. (r.LcmNav.Mass.Anticipatory overrides this: 0 forces off, >=1 forces on.)
• AnticipatoryStrength - How wide a berth to give predicted obstacle occupancy (higher = earlier / wider detour).

LcmMassGoalTrait

Authoring trait: assign a fixed-location or tagged-actor goal to a Nav3D Agent so it auto-paths there (requires the "LCM Nav3D Agent" trait too).

Properties

• GoalMode - FixedLocation (use GoalLocation) or TaggedActor (path to an actor by tag).
• GoalLocation - World location goal (FixedLocation mode).
• TargetActorTag - Tag of the target actor (TaggedActor mode). First actor with this tag wins.
• RepathToleranceCm - Re-issue the path if the resolved goal drifts more than this (cm).
• ArrivalToleranceCm - Treat the agent as "arrived" within this distance; stop re-pathing (cm).
• ReissueIntervalSeconds - Minimum seconds between path re-issues per agent (anti-flood safety).
• bEnableGoalPrediction - [Chase] Lead a moving TaggedActor target by its velocity so agents intercept rather than trail. TaggedActor mode only. Master kill switch: r.LcmNav.Mass.Chase.Enable.
• LeadSecondsCap - [Chase] Upper bound on lead time (s). Override fleet-wide with r.LcmNav.Mass.Chase.LeadSecondsCap (>=0).

LcmMassNavISMRenderTrait

Authoring trait: drop on the Mass config, set a mesh, get instanced visuals.

Properties

• Mesh - Mesh drawn (instanced) at each agent's transform.
• UniformScale - Uniform scale applied to each instance.

LcmMassNav3DTrait

[DEPRECATED - M3, 2026-07-03] Legacy path-based agent trait. Superseded by the unified ULcmMassNavAgentTrait ("LCM Nav3D Agent") with NavMode=PathFollowing, which composes a byte-identical archetype. Kept fully functional so existing configs (DA_MassAgent_Apex) keep working; prefer the unified trait for new content.

Authoring trait: attaches the path nav fragments and exposes radius/speed, pathfinding, and natural-movement settings.

Properties

• AgentRadius - Collision radius forwarded to the solver (cm).
• MaxSpeed - Maximum movement speed for the steering processor (cm/s).
• MobilityClassIndex - Mobility-class index (reserved for per-class cost rules; 0 = default).
• AvoidanceRadius - Neighbours within this distance contribute local avoidance steering (cm).
• AvoidanceStrength - Weight of avoidance vs path-following (0 = off, 1 = balanced).
• PathSolver - Any-angle LazyThetaStar (smooth) vs grid-locked AStar (square turns).
• SmoothingMode - Curved (CatmullRom) / shortcut (Linear) / raw staircase (None).
• MaxAcceleration - Max acceleration (cm/s²). Limits speed change so agents ease into motion.
• MaxTurnRateDeg - Max turn rate (deg/s). The key knob: replaces robotic square turns with smooth arcs. Lower = wider, lazier turns; 0 = instant snapping (legacy).
• LookAheadDistance - Pure-pursuit look-ahead distance (cm). Larger = smoother cornering.
• ArriveRadius - Arrival / slow-down radius around the goal (cm).
• FlightStyle - LinearDirect (magic/biological - instant) vs PhysicsWeighted (inertia).
• AvoidanceStyle - None / Reactive (boids) / Predictive (ORCA, smooth passing) / CBS.
• AvoidanceTimeHorizon - ORCA time horizon (s) - used only by Predictive avoidance.
• LaneBias - Density-aware lateral lane-spread strength (0 = off).
• LaneDensityNorm - Neighbour count at which lane spreading saturates.
• bObstacleReactivity - Re-plan when a moving obstacle invalidates the route this agent is following. Global kill switch: r.LcmNav.Mass.ObstacleReactivity.

LcmMassNavAgentTrait

[M3] Unified authoring trait: one trait, a NavMode selector. PathFollowing composes the path archetype (NavAgent + PathRequest + PathResult); FlowField composes the flow archetype (FlowField state + a const shared config fragment). Mode-specific properties hide via EditCondition on NavMode.

Properties

• NavMode - Movement policy. PathFollowing = per-agent A* path; FlowField = shared crowd steering field. Drives which fragments + config + tag the trait adds.
• Compute - Compute selector governing both modes. This release solves on the CPU, so Auto and CPU behave identically; the selector is retained for forward compatibility.
• AgentRadius - Collision radius (cm).
• MaxSpeed - Maximum movement speed (cm/s).
• AvoidanceRadius - Neighbours within this distance contribute local avoidance steering (cm).
• AvoidanceStrength - Weight of avoidance vs path/flow following (0 = off, 1 = balanced).
• MaxAcceleration - Max acceleration (cm/s²). 0 = instant.
• MaxTurnRateDeg - Max turn rate (deg/s) - replaces robotic square turns with smooth arcs. 0 = instant.
• ArriveRadius - Arrival / slow-down radius around the goal (cm). NOTE: the legacy traits defaulted differently per mode (path 80 / flow 150); this unified default is 100 - set explicitly if migrating a config that relied on the old default.
• FlightStyle - LinearDirect (instant, no inertia) vs PhysicsWeighted (turn-rate + accel inertia).
• AvoidanceStyle - None / Reactive (boids) / Predictive (ORCA) / CBS. NOTE: the legacy Flow Steer trait defaulted to Predictive (ORCA); this unified default is Reactive (matching the legacy path trait) - pick Predictive explicitly for smooth mutual passing in dense flow crowds.
• AvoidanceTimeHorizon - ORCA look-ahead horizon (s) - Predictive avoidance only.
• LaneBias - Density-aware lateral lane-spread strength (0 = off).
• LaneDensityNorm - Neighbour count at which lane spreading saturates.
• MobilityClassIndex - Mobility-class index (reserved for per-class cost rules; 0 = default).
• PathSolver - Any-angle LazyThetaStar (smooth) vs grid-locked AStar (square turns).
• SmoothingMode - Curved (CatmullRom) / shortcut (Linear) / raw staircase (None).
• LookAheadDistance - Pure-pursuit look-ahead distance (cm). Larger = smoother cornering.
• bObstacleReactivity - Re-plan when a moving obstacle invalidates the route being followed.
• FlightConfig - Body / aero / control tuning for the 6-DOF model - the SAME model as the pawn Lcm Flight Movement Component. The LocomotionModel + Archetype selectors are at the top of this struct and drive which parameters show; default LocomotionModel = Kinematic → the crowd moves exactly as before until you opt in.
• FlightDynamicsLODDistance - Dynamics LOD distance (cm): beyond this from the viewer, agents use the cheap kinematic integrator (full 6-DOF only near camera) - the scale knob for large crowds. 0 = always full. Kill switch: r.LcmNav.Mass.FlightLOD.
• bAnticipatory - Route around where moving obstacles are HEADING (predicted swept volume).
• AnticipatoryStrength - Detour strength around predicted occupancy (higher = wider berth).
• bAvoidThreats - Route the crowd AROUND actors tagged "ApexThreat" (danger zones). NOTE: agents DETOUR around threats, which can slow arrival - measured -30% threat crossings but 13-25% fewer arrivals on tight corridors. Enable for threat/danger gameplay.
• ThreatDetourStrength - Threat detour strength (higher = wider berth around danger zones).
• bIncrementalField - [Perf] D* Lite INCREMENTAL corridor field for large / churn-heavy crowds (re-cost only changed cells; safe full-rebuild fallback). Shared per goal.
• bAsyncFlowSolve - [Perf P2] Solve the flow field on a WORKER thread (removes solve spikes from the frame; the field publishes a frame later). Recommended for large crowds.

LcmMassPerceptionTrait

Authoring trait: makes an LCM Nav3D Mass agent both a senser and a perceivable (faction-based SVO-LOS perception), exposing sight/FOV/eye-height settings.

Properties

• FactionId - Faction id (different factions are mutually hostile / perceivable).
• SightRadius - Maximum sight distance (cm).
• FOVDegrees - Full field-of-view angle (degrees).
• EyeHeightOffset - Eye height offset from the agent origin (cm).
• AgentRadius - Agent radius for the SVO LOS walk (cm).
• PerceptionIntervalFrames - Perceive once every N frames (LOD throttle).

LcmMassRepresentationTrait

Preconfigured UMassVisualizationTrait: LOD-switched crowd rendering that draws the instanced static mesh at all visible LODs by default (no "see nothing" trap), and self-provides the LOD-collector + actor fragments so it works as one trait.

LcmNavAreaModifier

A cost-area volume (box, sphere or capsule). Every LCM Nav3D planner prices routes through it: travel inside costs the area's Default Cost times the distance, and each entry pays its Fixed Area Entering Cost. An agent's navigation query filter can override either per class, or exclude the class. See Tutorial 10.

Functions

• NotifyAreaChanged - Call after changing Area Class, Cost Multiplier, Shape, Priority or the box extent at runtime. Moving the actor needs no call.
• SetAreaVelocity / ClearAreaVelocity / GetAreaVelocity - The velocity planners assume for a Movable volume. Only needed when it is teleported, or not attached to the thing that carries it.
• RegisterWithApex - Makes the volume visible to planners. BeginPlay calls it when Auto Register is on.
• GetCostMultiplier - This volume's own Cost Multiplier (ignores Area Class and filters).
• GetBounds - World-space box enclosing the volume's real, rotated shape.

Properties

• AreaClass - Stock NavArea class this volume belongs to. Its Default Cost and Fixed Area Entering Cost apply here. Empty = use Cost Multiplier on its own.
• CostMultiplier - Used only when Area Class is empty. 1.0 = no effect; 2.0 = twice as dear; 0.5 = preferred lane. Default 2.0.
• Shape - Box, Sphere (radius = extent X) or Capsule (along local Z).
• Priority - Where volumes overlap, the highest Priority decides the cost. An area the agent's filter excludes always wins.
• bMovable - Tick when the volume moves. Planners replan as it moves, and route caches that depend on static areas alone are kept.
• PredictionSeconds - For a Movable volume: how far ahead agents plan for its motion. Default 1.5 s.
• bPatrol, PatrolOffset, PatrolSpeed - Move the volume back and forth on its own.
• BoundsBox - The volume's extent. Use the editor gizmo to size it.
• bAutoRegisterWithApex - Register on BeginPlay. Default on.
• AreaTag - Optional designer label.

LcmNavArea_Storm, _PreferredLane, _TollGate, _Territory, _Restricted, _NoFly

Ready-made NavArea classes: x5 travel, x0.5 travel, +2000 to enter, free until a filter prices it, free until a filter excludes it, and impassable for everyone.

LcmNavFilter_Prey, LcmNavFilter_Civilian

Ready-made navigation query filters: Territory x10, and Restricted excluded.

LcmNavAreaQueryLibrary

Blueprint function library exposing the LCM Nav3D nav-extension registry so designers can query cost overlays and registered NavLinks from BP graphs.

Functions

• GetRegisteredLinkCount - Count of currently-registered NavLinks.
• GetRegisteredAreaCount - Count of currently-registered NavArea modifiers.
• GetCostMultiplierAt - Travel multiplier at a world position, under each area's own defaults. Returns 1.0 when no area applies. Where areas overlap, the highest Priority wins.
• GetCostMultiplierAlongPath - The route's length-weighted travel multiplier, under each area's own defaults.
• GetCostMultiplierAtForFilter - The same at a point, as a given navigation query filter sees it. bIsExcluded is true when the filter (or a null area) forbids the point.
• EvaluatePathCostForFilter - Prices a waypoint chain as one agent pays for it: length, length weighted by travel cost, entering costs, and whether it crosses an excluded area.
• GetPathCostBreakdown - Totals plus one entry per area crossed, for a route and a filter.
• GetNavLinkTraversalCostAlongPath - The summed TraversalCostCm of the NavLinks a route uses.
• GetAllLinkEndpoints - All registered link endpoints as FVector pairs (Start, End). Useful for debug visualisation.
• FindNearestNavLink - Finds the nearest registered NavLink to WorldPos within MaxDistanceCm. Returns nullptr if none.

LcmNavAttributeSet

GAS attribute set surfacing per-agent path-request budgets so projects can throttle expensive LCM Nav3D queries through the standard GameplayEffect pipeline.

Functions

• OnRep_PathRequestBudget - RepNotify for PathRequestBudget; mirrors the replicated change to GAS.
• OnRep_MaxPathRequestBudget - RepNotify for MaxPathRequestBudget; mirrors the replicated change to GAS.

Properties

• PathRequestBudget - Current path-request budget. Consumed by 1 per successful ULcmGameplayAbility_RequestPath activation. Default 5.
• MaxPathRequestBudget - Hard cap clamp for regen. Default 5.

LcmNavigationInvokerComponent

Attach this to the Player or VIPs. The SVO Manager will only generate voxel data for chunks within this radius.

Properties

• GenerationRadius - How far around this actor should we build navigation data? E.g., 10000 = Build chunks within a 100m radius.

LcmNavigationManagerSVO

LCMNav3D world singleton - the central navigation manager actor. Spawns the four subsystem components (ULcmSVOStreamingComponent, ULcmSVOGenerationComponent, ULcmPathfindingComponent, ULcmSVORenderComponent); owns the SVO data containers (FiniteData for finite worlds, ActiveVirtualChunks for infinite worlds); owns FLcmMacroGraph + FLcmPortalBuilder; hosts the multicast RPCs for dynamic-obstacle invalidation and flow-field-ready notifications. Exactly one instance per UWorld; auto-discovered via UGameplayStatics:: GetActorOfClass.

Functions

• UpdateDynamicObstacleReplicated ------------------------------------------------------------------------ Server-authoritative entry: applies the dynamic-obstacle update locally AND multicasts it to all connected peers (clients + listen-server). Safe to call from any context -- becomes a no-op + warning when called on a client (clients route writes through the server). The flow-field-ready signal is a multicast-only callback path. The flow-field buffers are NOT replicated -- this RPC informs peers that a goal at (GoalLocation, ChunkKey) is reachable on the server, so they can prewarm their own local generation or trigger gameplay.
• UpdateDynamicObstacle - Call this when a large object moves to update the nav graph locally.
• ToggleDrawDebugVolumes - Flips bDrawDebugVolumes via SetDrawDebugVolumes. Convenience entry for a single-key toggle binding.
• SetMacroTopologyCell - [Procedural Topology] Called by your procedural-generation system (or World Partition minimap scanner) to mark a coarse cell blocked/unblocked.
• SetDrawDebugVolumes - Runtime show/hide for the SVO debug voxel volumes. Sets bDrawDebugVolumes and ALWAYS rebuilds the render proxy. The scene proxy captures the flag at build time (FLcmSVOSceneProxy::bForceDraw), so a rebuild is required for BOTH show and hide - toggling the bool alone does nothing. Bind to a key for in-game/PIE show/hide.
• Multicast_UpdateDynamicObstacle - Server-only entry: multicasts a dynamic-obstacle update to every connected client so each peer's ALcmNavigationManagerSVO replays UpdateDynamicObstacle(Bounds) locally (RCU clone is identical on every host). Clients that fire this directly are warn-and-ignored.
• Multicast_FlowFieldReady - Server-only entry: multicasts a "flow-field finished generating" notification to clients so they can prewarm a local sample for the given goal + chunk. The flow-field buffers are NOT replicated; clients regenerate on demand using shared cache keys.
• ForceRedrawSVO - Keep the core function so Blueprints can still call it at runtime if needed
• FindPath - Calculates a path from Start to End using the SVO. Returns true for a complete route, and also for one that stops short of the goal (part of the way not streamed in yet).
• FindPathDetailed - Find Path that says what it found: Complete, Partial (stops short of the goal; follow it and plan again from its end) or Failed.
• GetLastPathResult - Complete, Partial or Failed, for the last Find Path call.
• GetLastPathCostFailure - Why the last Find Path failed, if cost areas refused it: Goal In Excluded Area, or No Route Under Filter.
• SetCostView - Switches the Cost View at runtime (Off, Regions, Heat).
• FindCover - Find a hidden spot safe from the Enemy.
• DrawDebugSVO - Visualizes the octree in the viewport (Green = Free, Red = Blocked). One-shot manual call: flushes prior persistent lines and draws with a 10 s lifetime. The per-frame Tick path uses DrawDebugSVOTick instead.
• DrawDebugNeighborsAt - Visualizes neighbors of the node at the specific location (for debugging connectivity).
• DrawDebugInfiniteWorld - Renders the real-time state of the infinite world systems.
• DebugDrawFlowField - Flow Field Debug Visualization Generates a temporary Flow Field to the TargetLocation and draws it as a 3D Vector Heatmap. Green = Low Cost (Near Target), Red = High Cost (Far from Target).
• BuildSVOInEditor - Editor-time SVO build (button in the Details panel). Populates FiniteData from live collision geometry WITHOUT entering PIE, so the stock UE EQS Testing Pawn - and any LCM Nav3D EQS query built from the generators & tests - resolves the SVO and renders true-3D candidate points in the editor viewport, exactly the in-editor workflow Recast navmesh gives for 2.5D EQS. Finite mode only; warns + no-ops while playing (the SVO already bakes on BeginPlay) and in infinite-world mode (which streams chunks at runtime). Press once, then drop an EQSTestingPawn. // Editor-time SVO build. Surfaced as the prominent "Build SVO" button in the // editor module's banner (FLcmNavManagerDetails); BlueprintCallable so it can // also be triggered from script. Intentionally NOT a CallInEditor button - that // rendered a detached row below the property sections instead of in place.
• BuildSVO - Clears old data and builds a new SVO from scratch (Finite Mode only).

Properties

• bIsInfiniteWorld - World Type. OFF = a single fixed-bounds SVO built for the whole level (best for arenas / linear levels). ON = a streamed, unbounded world using Hierarchical HPA* (chunks generate on-demand around invokers). Drives the Generation Strategy below.
• GenerationMode - Auto-derived from the World Type - NOT set by hand. An infinite world always uses the Hierarchical HPA* strategy (macro routing + on-demand chunk streaming), the only infinite mode; a finite world is always Static Finite. Shown read-only so it can never be set to a value that contradicts the World Type (e.g. infinite + Fixed Bounds, which would silently break streaming). Tick "Infinite World" above to switch strategy.
• bAutoBuildOnPlay - Should the SVO automatically build itself when the game starts? (Finite mode only)
• WorldExtent - The total size of the navigable world (Cube width). Only used for Finite worlds.
• ChunkSize - Size of each chunk in World Units (e.g., 50,000 for 500m chunks). Must match World Partition Grid.
• MinVoxelSize - The smallest possible voxel size. Recursion stops here. (e.g., 100 = 1 meter)
• ClearancePadding - The padding added to voxel collision checks. Set this to your largest agent's radius.
• ObstacleQueryChannels - Physics collision channels to treat as solid walls.
• AllowedObstacleClasses - If empty, ALL overlapping geometry is voxelized. If populated, ONLY these actor classes are voxelized.
• CoarseCellSize - The size of a single topological macro-cell. 2500 units (25 meters) is the AAA standard for coarse LOD pathfinding.
• bUseFlowFields - When true, the request classifier can elect the flow-field path instead of per-agent A* for swarms of ≥ FlowFieldThreshold agents sharing a goal. Off by default; opt-in for swarm gameplay.
• FiniteObstacleUpdateInterval - [Perf fix, 2026-06-07] FINITE mode: minimum seconds between dynamic- obstacle SVO applications. In finite mode every UpdateDynamicObstacle deep-clones the ENTIRE world SVO (RCU copy-on-write) - with event-driven obstacle components flushing every ~33 ms per moving actor, that was a clone storm ("massive fps drop while anything moves"). Updates arriving inside the window are UNIONED and applied as ONE clone+swap at the trailing edge, so the final state always lands. 0 = legacy immediate behaviour. Infinite mode is unaffected (per-chunk updates are cheap by construction).
• FlowFieldThreshold - Minimum number of agents sharing a goal before the classifier elects the flow-field path instead of per-agent A* (requires bUseFlowFields).
• FlowFieldClusterCellSize - Voxel-quantization grid size (cm) used to bucket flow-field goal positions into cache keys. Two requests whose goals fall into the same cell share a cached flow field. Larger values → more sharing (cheaper) but coarser direction snapping.
• bUseGPUVoxelization - Uses Compute Shaders for lightning-fast voxelization. Disable only if targeting low-end mobile.
• MaxGenerationsPerFrame - How many chunks can we voxelize per frame? (1 is usually best to avoid Game Thread stutters).
• MaxFlowSolvesPerFrame - [Perf P3a] Cap goal-anchored flow-field solves STARTED per frame (spreads the GT cost so a burst cannot spike the frame). 0 = unlimited. r.LcmNav.Mass.MaxCorridorSolvesPerFrame overrides (>=0).
• MaxPathRequestsPerFrame - [Perf] Max PathFollowing path requests dispatched per frame (spreads a spawn burst across frames; requests are async). r.LcmNav.Mass.MaxPathsPerTick overrides (>=0).
• MaxRequestsPerFrame - How many paths can we calculate per frame? (50 is a safe number to keep FPS high).
• bChunkQuantizedMacroCache - Share one cross-chunk macro route across a crowd heading to the same goal, instead of recomputing the identical chunk-level route per agent. This is the big win for LARGE Mass/AI crowds in infinite/hierarchical worlds: it removes the per-agent macro-pathfinding cost that otherwise spikes the game thread when many agents spawn or replan at once (measured ~30x cheaper request processing, worst-frame 97ms -> 12ms at 2000 agents). The macro route is chunk-level; each agent's exact start/end are still applied per agent, so paths stay correct. Leave OFF to reproduce legacy bit-exact pathfinding (e.g. for deterministic benchmarking). Runtime override: r.LcmNav.MacroCache.ChunkQuantized (force-on). Infinite/hierarchical only.
• bDrawDebugVolumes - If true, automatically renders the voxel grid when generation finishes.
• bDrawInfiniteWorldDebug - If true, draws Invoker Bubbles, the Generation Queue, and loaded chunks in real-time.
• bDrawPathfindingDebug - Master switch for Agent Flight Paths and Waypoints.
• CostView - Draws the cost areas while playing: Regions, or Heat (the octree tinted by price).
• CostViewFilter - Whose eyes the Cost View looks through: a navigation query filter class.
• DebugRedrawCoalesceSeconds - Minimum time between debug-mesh redraws (coalesce cadence). Forwarded to the SVO debug renderer; higher = fewer rebuilds when many obstacles move at once.
• MacroGraph - A lightweight map of every chunk in the world (HPA*).
• RenderComponent - The Central Renderer used to draw the SVO via the GPU Render Thread.
• DynamicMacroTopology - [Procedural Topology] Thread-safe map of the global layout of massive blocking geometry (coarse-grid coordinate -> blocked). Populated by SetMacroTopologyCell.
• StreamingComponent - SUBSYSTEM COMPONENTS
• GenerationComponent - SVO voxelization scheduler subsystem. Pulls pending chunk-generation requests off the manager's queue and dispatches CPU/GPU voxelization.
• PathfindingComponent - Pathfinding request queue + dispatcher subsystem. Routes async FindPathAsync calls to the CPU worker pool, per the request options.

LcmNavLinkComponent

3D vertical NavLink component (subclass of UNavLinkCustomComponent) with designer-set world-space LinkStart/LinkEnd for ladders, shafts, and teleporters that Recast's surface-projected links cannot represent.

Functions

• IsVerticalLink - True iff this link spans more than MinVerticalCm along Z - the 3D-advantage case (ladders, jump shafts).
• GetLinkSpanCm - Convenience: distance(LinkStart, LinkEnd) - useful for designers comparing the link's geometric length vs its travel cost.

Properties

• LinkStart - World-space start point. For ladders/teleporters this is the bottom (or originating end if not vertical).
• LinkEnd - World-space end point. For vertical ladders this is the top.
• bBidirectional - When true (default), the link can be traversed Start→End AND End→Start. Set false for one-way patterns (teleporter, drop-down, etc.).
• bAutoRegisterWithApex - Auto-register with the LCM Nav3D link registry on BeginPlay so v2 solver integration discovers the link without extra code.
• TraversalCostCm - Traversal cost (cm-equivalent) added to the path through this link. Default 0 = no penalty (geometric distance counts as-is).

LcmNavVolume

Defines the playable area for offline SVO generation. Acts as the master bounds for slicing and baking ALcmNavigationChunk actors.

Functions

• BakeNavigationData - Editor-only one-shot bake. Slices the volume bounds into the configured chunk grid, voxelizes each chunk on the game thread, and writes a ULcmSVODataAsset per chunk into OutputAssetPath. Pairs with the runtime ALcmSVOStreamingProxy actor that loads each asset on level streaming.

Properties

• ChunkSize - Edge length (cm) of a single bake chunk. Must match the runtime manager's ChunkSize when bSnapToGlobalGrid is true.
• MinVoxelSize - Smallest voxel produced by SVO subdivision (cm). Tighter values produce finer paths but inflate the SVO node count cubically.
• ClearancePadding - Inflation (cm) applied to obstacle SAT collision checks at bake time. Set to the radius of your largest agent so the SVO carves out enough clearance for them.
• bSnapToGlobalGrid - If true, forces chunks to align to a global 3D grid (Required for World Partition). If false, spawns exactly ONE chunk that perfectly matches this volume's bounds (Best for Arena/Linear games).
• BakeObstacleChannels - Physics collision channels treated as solid obstacles at bake time. Empty means "all overlapping geometry".
• BakeAllowedClasses - Whitelist of actor classes to voxelize. If empty, all overlapping geometry on the configured channels is included.
• OutputAssetPath - Content path under which ULcmSVODataAsset outputs are written by BakeNavigationData. Per-chunk assets get a _X_Y_Z suffix.

LcmSmartObjectBehaviorDef_CoverPocket

SmartObject behaviour definition for a designer-placed cover pocket, validated at claim time by SweepPenalty + threat-hint LOS with a FindBestCover fallback when the placed pocket has gone hot.

Properties

• DwellSeconds - Time the pawn stays in cover before considering the state complete. 0 = stay forever (use a parent transition condition to exit).
• MaxAcceptableSweepPenalty - Highest SweepPenalty (0.255) the slot leaf may carry to count as safe. Above this the StateTree task triggers the FindBestCover fallback. Default 32 = "lightly swept, mostly safe".
• bUseThreatHint - Direction hint (world-space) to validate cover against. The pocket is only valid if LCM Nav3D LOS from this point to the slot is blocked AND SweepPenalty is below the cap.
• ThreatHintLocation - World-space point the cover is validated against; the pocket is valid only if LCM Nav3D LOS from here to the slot is blocked.
• FallbackSearchRadiusCm - When the placed pocket fails validation, the task searches within this radius for a procedural cover via FindBestCover. 0 disables fallback (failure makes the task return Failed).
• AgentRadius - Agent radius for the LOS walker's clearance gate.

LcmSmartObjectBehaviorDef_PatrolWaypoint

SmartObject behaviour definition for one patrol waypoint; designers chain placed waypoints via NextWaypointTag to author a patrol route as content.

Properties

• DwellSeconds - Dwell time at this waypoint before moving to the next.
• NextWaypointTag - GameplayTag of the next smart object in the chain. Empty = end-of- chain; the parent state machine drops out of patrol on Empty.
• bChainCycles - When true, the patrol restarts at the chain's head when the chain ends. When false, the pawn lingers at the final waypoint.
• bUseFacingHint - Optional facing yaw to assume at this waypoint (degrees). When unset (kept default), keeps the inbound flight rotation.
• FacingYawDeg - Yaw (degrees, world-space) the pawn faces at this waypoint when bUseFacingHint is set.

LcmSmartObjectBehaviorDef_Perch

SmartObject behaviour definition for a volumetric perch: fly here, hover or stand, and dwell - a 3D-only smart-object pattern LCM Nav3D's free-space SVO supports where surface-projected Recast navmesh cannot.

Properties

• DwellSeconds - How long the pawn dwells at the perch after arrival.
• RequiredClearanceCm - Agent collision radius the perch must accommodate. Read at claim time by FLcmSTTask_UseSmartObject. Note: at production chunk sizes the underlying voxel clearance field is not populated, so this threshold does not currently reject anything. Treat it as authoring intent recorded for future use, not as an active gate, and size perches so that any agent you send to them fits.
• bUseFacingHint - When true, the pawn rotates to face FacingHint after arrival. When false, the pawn keeps its inbound flight rotation.
• FacingYawDeg - Yaw the perched pawn should face (degrees, world-space). Bound only when bUseFacingHint is true.
• FacingInterpSpeed - Per-tick speed at which the pawn aligns to FacingYawDeg during dwell.

LcmSVODataAsset

A lightweight, streamable asset that holds pre-calculated SVO navigation data. Designed to be loaded asynchronously by World Partition.

Properties

• ChunkCoordinate - The mathematical grid coordinate this chunk belongs to
• ChunkBounds - The physical world bounds of this chunk
• SerializedSVOData - The raw, compressed binary data of the SVO tree
• SerializedMacroNode ------------------------------------------------------------------------ Optional macro-graph slice for this chunk: the just-finalized FLcmMacroNode (PortalEdges + InternalEdges + WorldCenter) captured after BuildTruePortals + PrecomputeIntraChunkEdges complete during the bake. Serialized via FLcmMacroNodeArchive (magic 'LCMN', V1). Empty array = legacy bake - streaming proxy falls back to UpdateMacroNode + GeneratePortalsForChunk (fallback portals only; the runtime BuildTruePortals + intra-chunk-edge precompute still runs separately when neighbors load). Non-empty = the cold-build work is skipped and the precomputed macro node is injected directly into Manager->MacroGraph.Nodes[ChunkCoordinate]. Independent from SerializedSVOData - backward-compatible addition; older baked assets deserialize with this field empty.

LcmTacticalQueryLibrary

Static Blueprint-callable wrappers for LCMNav3D tactical primitives.

All functions are pure CPU and synchronous - they execute on the calling thread (Blueprint VM thread, BT service tick, EQS test evaluation, etc.) and return immediately. None of them dispatch GPU work or async jobs. Designed to be called at EQS-test frequency (tens to hundreds per query per frame) without budget concerns.

Functions

• IsSegmentLOSClear - Tests whether a straight line from Start to End is clear of unblocked SVO leaves for an agent of the given radius. Wraps the same Lazy Theta* neighbour-graph LOS walker used by any-angle pathfinding. Returns false if the SVO at Start cannot be resolved (out of bounds or unloaded chunk).
• IsReachableSync - Cheap reachability test - returns true iff a path from Start to Goal exists. Implemented by calling the underlying A* with early-out; faster than FindApexPathSync when you don't need the waypoint list.
• IsPositionBlocked - Returns true iff WorldPos resolves to a blocked SVO leaf (or to no leaf at all - out-of-bounds and unloaded chunks both report blocked by default for tactical-query safety). Pair with GetSweepPenaltyAt when you need to distinguish "blocked" from "merely risky".
• GetSweepPenaltyAt - Reads the SweepPenalty byte at WorldPos. Higher values indicate the voxel was recently swept by a dynamic obstacle's predicted hull - a heuristic measure of "how dangerous is this position right now?". Returns 0 when the position resolves to a chunk that hasn't been loaded, when the voxel itself is blocked (treated as max danger by default in path costing - caller may want to treat blocked separately via Is Position Blocked), or when no dynamic obstacle has touched it. Value range: 0 (clear). 255 (maximum recent threat).
• FindBestCover - Wraps LcmSVOPathSolver::FindBestCover. Finds the best cover position for AgentLocation against ThreatLocation within SearchRadius (cm), preferring positions with line-of-sight broken to the threat. @param OutCoverLocation receives the best cover position when the function returns true. When the function returns false, this is left at ZeroVector.
• FindApexPathSync - Synchronous "is there a path from Start to Goal" probe. Wraps the same A* core that FindPathAsync uses but runs on the calling thread for use inside EQS tests that need to score candidates by LCM Nav3D-path distance (NOT euclidean) before the agent commits. Returns true when a path was found; OutPath receives the waypoint sequence. Returns false when start or goal don't resolve to a loaded chunk, when their containing voxels are blocked, or when no path exists between them. Pay-as-you-call cost - typical short-range paths complete in <0.1 ms, long-range cross-chunk paths in 1-5 ms. If you only need the boolean "is reachable?" answer without the waypoint sequence, prefer IsReachableSync (cheaper - bails as soon as goal is popped).