Description
Current Version: 2.06
Last Update: 05.06.2026
Docs:Notion
Support:DIscord
Compatible with the XAI - Multiplayer AI Creation Kit! | Fab plugin
Compatible with Unreal Engine 4.27 – 5.7
Overview
AdaptivePathfindingSystem brings smooth, adaptive, and natural AI navigation to Unreal Engine.
It adds arc-based pathfinding using a midpoint system, intuitive runtime parameters, and built-in real-time path visualization.
The system integrates seamlessly with Unreal Engine’s navigation without any low-level modifications.
What’s New in 2.03–2.04
New aps.Debug.PathMode debug draw control: 0=off, 1=lines, 2=lines+points; LowLevelArc draws the final resolved path using this mode.
Visualizer cleanup: UAPS_Visualizer now uses a single VisualizePath() (lines always, spheres only if SphereSize > 0); removed old “dynamic” API.
Detour safety: plugin-local node pool/queue moved into APSDetour namespace; low-level path code updated accordingly to avoid engine symbol conflicts.
What’s New in 2.02
- Low-level arc refactor — the curved-path logic has been rebuilt on top of a shared Detour layer with a custom A* (`FAPSNavMeshQuery`) and its own node pool/queue. This makes the system more robust and easier to extend without touching engine internals.
- Multiple pathfinding modes — `AAPS_NavigationData` now exposes `EAPSPathAlgorithm`, letting you choose between Unreal’s default engine search, APS Low-Level Arc, APS Low-Level Tiles, legacy APS Arc, or an Experimental hook per project / per NavData.
- New arc controls — `APS_MoveToInterface::GetMoveToParameters` has been extended with an arc shape mode (`SmoothCurve` or `Wavy/Humps`), so you can switch between a single smooth arc and a snake-like path with multiple humps, per behavior or per AI.
- Massive performance improvement — the new APS v2.02 arc search matches or beats Unreal’s default (~0.02 ms for 5-edge arcs, ~0.015 ms for 1-edge arcs with 100 AI), while the old APS v2.01 implementation was around ~0.85 ms per query (roughly 40× slower in our tests).
What’s New in 2.01
Extended engine support — official builds for Unreal Engine 4.27 and the full 5.0–5.7 series.
Simplified MoveTo interface — the old Quality parameter has been removed; runtime control is now driven by ArcStrength and NumMidPoints.
Multi-segment arc paths — paths can now be split into several arc segments; the first segment defines the main bend, while subsequent segments add softer curvature with controlled path length growth.
Safer visualization enum — EVisualizationMode has been renamed to EAPSVisualizationMode in UAPS_PathManager to avoid future conflicts with engine enums.
(Everything introduced in 2.0 — 3D navigation, midpoint arcs, visualization, etc. — remains available and improved by the new path logic.)
What’s New in 2.0
3D Navigation Support — the system now works not only for flat or top-down maps (like RTS games)
but also for full three-dimensional environments, handling slopes, stairs, and height differences.Arc via Mid-Point — stable curved-path generation with precise control over side and curvature (ArcStrength).
Runtime Movement Parameters — actors can specify ArcStrength, NumMidPoints, and arc shape mode, or completely override the path with a custom route.
Real-Time Visualization — instantly display AI routes during gameplay.
Extended Logs — aps.Nav.Debug outputs detailed search phases and midpoint selection.
Key Features
Multiple Pathfinding Modes
Choose between engine-only navigation, APS low-level arc paths, tile-based low-level A*, or legacy APS arc modes. The active algorithm is selected per `AAPS_NavigationData`, so you can tune behavior per project, per map, or even per NavData asset.
Arc-Based Navigation
Arc-driven pathfinding built on top of Unreal’s standard navigation system.
Control arc direction and curvature with ArcStrength
sign defines the side of the arc, magnitude defines how strongly the path bends.
Short distances automatically flatten into nearly straight lines to avoid unnecessary curvature.
Multi-Segment Curved Paths
NumMidPoints lets you control how many “bends” the final path will have.
The first arc segment applies the full ArcStrength, defining the main deviation from a straight line.
Additional segments reuse the same arc logic with reduced strength and local stretch limits, so the path becomes smoother and more organic without exploding in length or looping back on itself.
Path Smoothing & Optimization
Cleans up nearly collinear points while preserving the overall curved shape of the route.
Uses navigation raycasts to safely shortcut segments that can be traversed directly, without destroying the main arc joints.
Custom Path Override
Implement APS_MoveToInterface::FindCustomPath to supply a completely custom path (Detour, your own steering logic, influence maps, etc.).
When a custom path is provided and marked as valid, APS will use it as-is and skip its own arc construction.
Move-Time Parameters
GetMoveToParameters(float& ArcStrength, int32& NumMidPoints) allows each actor or AI controller to define its own movement style.
You can express left/right bias, stronger arcs for long-distance moves, or flatter arcs for short, precise motions by adjusting these parameters per behavior or per state.
Visualization & Debugging
UAPS_PathManager and UAPS_Visualizer can render navigation paths in real time during gameplay or PIE.
Supports multiple visualization modes through EAPSVisualizationMode (line-only, points, layered debug views, etc.), useful both for designers and programmers.
Core Functions
AAPS_NavigationData::FindPath
Replaces the default path generation with an APS-controlled dispatcher:
chooses the active path mode via `EAPSPathAlgorithm` (engine-only, low-level arc, tiles, etc.),
runs a shared low-level Detour A* where needed,
optionally warps the resulting path into an arc or “snake” while keeping it valid on the navmesh.
APS_MoveToInterface
Provides runtime path parameters (ArcStrength, NumMidPoints) or a full custom route via FindCustomPath.
Intended Use
AdaptivePathfindingSystem fits any Unreal Engine project —
from single-player titles to complex simulations and multiplayer AI frameworks.
🎮 Action / Adventure — more natural NPC movement, soft turns, and smarter obstacle avoidance.
🧠 Simulation / Sandbox — adaptive agent navigation in open, layered, or vertical environments.
🏗️ Multiplayer / Online — predictable, visually pleasing paths that still respect navmesh constraints.
🚗 Vehicles, Drones, Animals, Crowds — curved trajectories, side preference, and per-agent movement styles.
Notes
Works entirely on top of the standard Unreal Engine navigation system (Recast / NavMesh).
Implemented purely with Unreal Engine APIs, no engine source modifications required.
Officially supports Unreal Engine 4.27 and 5.0–5.7.
If you previously relied on a Quality parameter, you can now implement your own “quality” or difficulty settings in AI code and map them to ArcStrength, NumMidPoints, or custom paths via FindCustomPath.