Unity NavMesh vs Apex Path vs A* Pathfinding Project
Update June 2017: Unity 5.6 comes with improved
NavMeshes! They are now component-based, allowing for multiple NavMeshes
per scene. In addition, procedurally generated and dynamically loaded
content is now supported – just generate the level and set the NavMesh
to
Bake! 😉
Hey fellow game developer, what kind of games do you want to make?
Do you dream of creating huge open worlds, full of complex and
compelling characters? Do you want to give your players whole armies to
engage in massive real-time battles? Or, alternatively, do you prefer to
work on the fast-paced action of first person shooters?
Here Enters Unity Pathfinding
The common trait of all these genres is that your AI units need to
navigate the game world. Furthermore, they need to move efficiently and with
purpose.
Further still, the computer controlled units should not get stuck,
rotate in a circle or bump foolishly into other objects! For an
immersive player experience, it is critical for all units to “stay in
character”! But how do we, as game developers, make the AI
characters react and adjust to the changing game environment?
We do it by using
Pathfinding. Pathfinding is the
collection of tools and techniques for moving units in the game world.
There are multiple ways to implement it in your game, and in this post
we’ll review the 3 most popular. We’ll compare Unity’s default NavMesh
solution with the two most popular pathfinding Unity assets – A*
Pathfinding (available
here) and Apex Path (available
here).
The Built-in Unity NavMesh Agents
Unity’s default solution is the NavMesh. We can
bake a Unity NavMesh from the geometry in our scene (
Window -> Navigation). The baking process defines the accessible areas based on the Render Meshes of the
static
Game Objects. After that we can add NavMesh Agent components to our
moveable characters and let them roam freely around the level:).
The built-in tools are free and straight-forward to set up. H
owever,
there are multiple issues with the Unity Navmesh. The first major
problem is that the mesh is baked in advance, so it can’t be changed at
runtime. In result, any shape-changing dynamic objects and obstacles
won’t work correctly.
Additionally, the Unity NavMesh can’t
handle procedurally generated game worlds. So, if your game depends on
that feature, or even if you use levels which expand gradually, you are
better off using a more capable pathfinding asset. On top of that, there
are some performance issues with dynamic obstacles and massive amounts
of units are present on the scene.
To sum up, Unity NavMesh works great for simple games without special
pathfinding requirement. Anything beyond that, and you are much better
off using a dedicated Pathfinding Unity Asset.
Pathfinding Unity Assets Comparison
As you know, the Unity Asset Store offers a treasure trove of
powerful tools enhancing the Unity platform. With regard to pathfinding,
two systems stand head and shoulders above the rest: A* Pathfinding
Project Pro and Apex Path. Both assets are popular and battle-proven;
they also integrate well with visual scripting systems like
Playmaker and AI frameworks like
Behavior Designer.
Both Pathfinding tools are capable and
would serve you well, but they do differ in several key aspects. Let’s
review their pros and cons to figure out which one is best suited for
your project.
Apex Path
Apex Path is a great looking, grid-based pathfinding library. It
contains a clean, well organized codebase and is packed with useful
features. Let’s mentions just some of them: Load
balancing, Multi-threading, Height maps, Basic Steering with local
avoidance and Patrol routes. Additionally, the developers of Apex Path
offer other (paid) modules like Apex Steer which extend the
functionality of the asset.
Its approach to pathfinding is grid-based, which means that you don’t
need to bake anything in advance. Consequently, Apex Path is suitable
for dynamically changing and procedurally generated game worlds
(although larger RTS-style worlds can hit some performance issues). It
also implements “portals” to allow units to travel between different
navigation grids.
However, the biggest strength of Apex Path – the strictly enforced
coding conventions – can sometimes become its weakness. The asset is
clearly created with great care and precision, but it enforces
a proprietary way of programming and makes you adapt to its rules. Just
as an example, you would need to use Apex Path’s custom static methods
instead of Unity’s AddComponent. At times, this level of abstraction
makes the asset look a little over-engineered. Depending on the level of
your programming abilities, and whether you would be OK with having to
learn a different way of doing things, this may or may not be an issue
for you. In any case, their support is quick and attentive, so even if
you face issues with the scripting side of things, you would be in good
hands.
To sum up, if you are looking for plug-and-play pathfinding solution
for small maps (e.g. for FPS games), and you are ready to incorporate
Apex Path in your project from the start, this is as good as it gets.
However, already advanced projects, or projects which require larger
maps, would generally be better served by other solutions.
A* Pathfinding Project Pro
A* Pathfinding (you can also see it as Astar or A Star Pathfinding)
is the benchmark for quality pathfinding in Unity. Currently in its 4th
version, Astar Pathfinding has a stellar 5 star rating on the Unity
Asset Store from over 500 reviewers. It loads extremely quickly and is,
frankly, easier to use than Unity’s default tool.
The technical details are impressive. The asset supports automatic
NavMesh generation and is fully multi-threaded. It offers a selection of
3 different navigation graphs (NavMesh, Grid and Point Graph), plus
various types of path post-processing and local avoidance in both the XZ
and XY planes. It comes with the full source code and, of course,
supports dynamic updates of the graphs at runtime.
But even after this list of accomplishments, my favorite thing about
A* Pathfinding is how easy it is to use. For example, a pathfinding call
takes just a couple of lines of code:
|
|
//The Seeker component handles requesting paths from scripts
Seeker seeker = GetComponent<Seeker>();
//Start a new path to the targetPosition, return the result to the OnPathComplete function
seeker.StartPath (transform.position,targetPosition, OnPathComplete);
|
And the good stuff doesn’t end there. Astar Pathfinding comes with 16
example scenes introducing its many features, so you can hit the ground
running. The author of the asset, Aron Granberg, is also very active and
helpful in responding to all kinds of questions about A* Pathfinding
online at forum.arongranberg.com.
Conclusion
In order to handle Pathfinding in Unity correctly, you need to use
the right tool. Hopefully now know you enough details to figure out
whether you need to use Unity’s default NavMesh, or choose a dedicated
Pathfinding asset. Good luck with the development and try to stay on the
right path! 🙂
Reference : https://ironic.games/unity-asset-store-reviews/unity-navmesh-vs-a-star-pathfinding-vs-apex-path
