Navmeshes for precise movement, blazing speed and low memory footprint.
Navmesh based graphs are built like a mesh based on triangles where each triangle specifies an area where an AI can walk. This allows for very precise movement and very low memory footprint when the game contains even just a few more open areas since navmesh graphs can describe large areas with very few triangles.
Grid Graphs for flexibility, ease of use and fast updates. Perfect for TD games for example.
Grid Graphs are, as the name implies, built by arranging nodes in a grid like pattern. Nodes are sampled at grid coordinates and placed in the world. Grid Graphs allow for fast updates due to their regular structure. For TD or RTS games, or any other games which require frequent updates to the graphs to account for e.g user placed buildings, this graph is really useful.
Point Graphs for customization and flexibility. Simply throw some points at it and let it construct a graph out of them.
Point graphs can be constructed out of any list of points you can throw at it. For example you can use all children of a specific transform object, or all objects with a specific tag.
Automatically generate navmeshes from world geometry with the click of a button.
Work that could take hours using manual navmesh building can be done in a few seconds using the integration of Recast into the A* Pathfinding Project. Navmeshes can even be recalculated in-game on all platforms allowing for great flexibility. Navmeshes in many pathfinding systems are totally static due to the usually high cost of recalculating them. This constraint is not in the A* Pathfinding Project. Navmesh cutting can be used to modify the navmesh at runtime, and when using a tiled recast graph you can recalculate smaller pieces of the navmesh with a lower performance hit. Recast graphs can handle huge worlds, users have used it in games with terrains up to 8 times 8 kilometers with great success.
A complete local avoidance system based on RVO (reciprocal velocity obstacles) is included. It allows crowd simulation of hundreds of agents at the same time (thousands on many computers). The local avoidance is no harder to use than to use the unity character controller, it is designed to be a drop in replacement for it.
Release to any platform which Unity supports.
Tested on OSX, Windows, Linux, WebGL, Android and iPhone, but I can't see any reason it should not work on other platforms as well. It does work on Windows 8/10 and Windows Phone, however there are a few extra steps that need to be taken (detailed in the documentation) for it to pass WACK (for the Windows Store). Users have also tested it on PlayStation Vita and WiiU.
Using the system might seem hard, but to get started is actually really easy. With a good get-started guide you can have the system integrated into your game in a short time. Many complexities are also hidden, so to start a new path request is only one line of code for example. The project includes 13 (!) example scenes to help you learn how to use it (the free version includes some, but not all of them since some features are pro only).
Path modifiers makes getting a nice smooth path from the system a breeze.
The project inclues for example a smoothing modifier, raycast simplifier, funnel modifier and a few others.
It is also easy to write your own.
The project includes several extensive custom editors to help you work as efficiently as possible. Both a dark skin and a light skin is included.
Want your resource gatherer to find the path to the nearest resource, or do you just want your civilians find any path which takes them away from the evil enemies? You can do that in a single path request! Search modes available are: Normal, Multiple Target, Flee and Random. But as with graphs, all of these are written as add-ons, they are not hard coded into the system which means that you can add your own specialized search modes without modifying the pathfinding core!
All graphs can be saved to files and loaded on the fly later on. You can also use the same feature to reduce loading times by calculating the graphs in the editor and then simply load the already calculated graph. A huge win for mobile applications.
The system is fully multithreaded to be able to maximize throughput. This also means that pathfinding will have a very small impact on the framerate when running on 2+ core machines. The image to the left shows a stress test I made. The computer I ran it on has 4 physical cores and hyperthreading makes it 8 logical ones (that's why it starts to level out after 4 threads).
Graphs can be easily updated during runtime, both using scripting and easy to use components. This makes it simple to create a tower defence game where the enemies always need to avoid the towers the player place down. Almost everything in the graphs can be updated at runtime, tags, walkability, penalty, connections, etc. Since a graph update can be applied to only a small part of the graph, you will not get a huge FPS spike just because you updated some tiny detail. It is fast enough to enable moving obstacles which characters dynamically avoid.
The system supports dynamic obstacles on grid graphs easily. But navmesh graphs (those made up of triangles) are in other pathfinding packages usually very hard to update in real time. However the A* Pathfinding Project supports navmesh cutting so you can get dynamic obstacles even on navmeshes. See more details here.
You can use penalties on nodes to define how "hard" it is to traverse those nodes. This can be used to make characters prefer walking on roads and walkways instead of in the middle of the terrain.
Tags (some know it as 'layers') can be used to restrict which parts of the graph a character can walk on, or just apply a penalty for walking on it. For example if you are making a Tower Defence game which has lava as an obstacle, you can have some units that need to follow a path around the lava pools and some fire resistand units that can walk through the lava (but maybe with a penalty for doing so to make sure they walk around the lava if it isn't a much longer path).
The system is optimized for maximum performance. This means the project can support a high number of agents pathfinding at the same time.
It can also handle very large worlds (see description of Recast graphs above), users have used it with worlds spanning 8 times 8 kilometers with great success.
If you want to see an example, here is a stress-test of the system.
The system includes lots of useful utilities such as generating random points on the navmesh, calculating group formations, adding an obstacle to a grid graph unless it would block the path between two nodes (useful for TD games to avoid players blocking the path from the start to the end of the map) and of course obvious things like getting the closest node to a given point.
You also have full access to graph data and you can modify it through script, many parts of the A* Pathfinding Project are in fact written in the same style as add-ons.