Tutorial on how to make a wandering AI.

There are several methods for making a wandering AI. They differ in both quality and performance. There is no obvious best solution, different methods will suite different games better. For each method I have listed some advantages and disadvantages.

Method 1: Random point inside a circle

The easiest method for picking a point to move to is simply to pick a random point within a specific distance around the character.

    Vector3 PickRandomPoint () {
        var point = Random.insideUnitSphere * radius;
        point.y = 0;
        point += transform.position;
        return point;
    }

If you are using one of the included movement scripts you can for example change the destination of the AI whenever it has reached the end of its current path:

﻿using UnityEngine;
using System.Collections;
using Pathfinding;
public class WanderingDestinationSetter : MonoBehaviour {
    public float radius = 20;
    IAstarAI ai;
    void Start () {
        ai = GetComponent<IAstarAI>();
    }
    Vector3 PickRandomPoint () {
        var point = Random.insideUnitSphere * radius;
        point.y = 0;
        point += ai.position;
        return point;
    }
    void Update () {
        // Update the destination of the AI if
        // the AI is not already calculating a path and
        // the ai has reached the end of the path or it has no path at all
        if (!ai.pathPending && (ai.targetReached || !ai.hasPath)) {
            ai.destination = PickRandomPoint();
            ai.SearchPath();
        }
    }
}

You can attach the script above to any GameObject with one of the built-in movement scripts (e.g AIPath/RichAI/AILerp).

Note: Make sure that you do not have any other components attached that also try to set the destination of the AI (e.g the AIDestinationSetter component).

See Also: Pathfinding.IAstarAI; Random.insideUnitSphere

Advantages

Very fast.
Simple code.
Works reasonably well for all graph types.

Disadvantages

Ignores the actual distance to the point which means it can produce very long paths if the world is not very open (see the video above).
Has a slight bias towards points close to walls/obstacles as any points that were generated inside the obstacles would have to be snapped to the closest point on the graph.

Misc

Ignores penalties when picking points (penalties will be taken into account when searching for a path to the point though).

Method 2: The RandomPath type

The RandomPath type is a path type that in contrast to the normal paths which calculate a path from a specific point to another specific point, calculates a random path away from a starting point.

        RandomPath path = RandomPath.Construct(transform.position, searchLength);
        path.spread = spread;
        seeker.StartPath(path);

See Also: Searching for paths

Adding this to any of the included movement scripts does however require that you create a new class that inherits from that movement script and overrides the relevant methods. So the other methods may be easier if you are using those.

Advantages

Picks a point and calculates a path in one go.
Every node that is considered has the same probability of being chosen, no bias towards being near obstacles like in Method 1: Random point inside a circle.
A minimum path cost can be set (searchLength).

Disadvantages

Can be slow for long paths.
Not as easy to integrate with the built-in movement scripts.
Does not work that well for navmesh/recast graphs as every node has the same probability of being chosen, which will cause a bias towards regions with a lot of detail (and thus more and smaller nodes).

Misc

Takes penalties into account.

See Also: Pathfinding.RandomPath

Method 3: The ConstantPath type

The ConstantPath type is a path type which will find all nodes which can be reached from the start point with a cost at most equal to a particular value. After all those nodes have been found we can pick one or more random points on the surface of those nodes.

        ConstantPath path = ConstantPath.Construct(transform.position, searchLength);
        AstarPath.StartPath(path);
        path.BlockUntilCalculated();
        var singleRandomPoint = PathUtilities.GetPointsOnNodes(path.allNodes, 1)[0];
        var multipleRandomPoints = PathUtilities.GetPointsOnNodes(path.allNodes, 100);

If you want to feed this to a built-in movement script you can use the same approach as in Method 1: Random point inside a circle.

See Also: Pathfinding.ConstantPath; Pathfinding.PathUtilities.GetPointsOnNodes

Advantages

Can pick multiple random points with just a single path request.
The probability of chosing a node is proportional to its surface area (so if all nodes have the same size, e.g when using a grid graph then every node that is considered has the same probability of being chosen). There is no bias towards being near obstacles like in Method 1: Random point inside a circle.
Possible to do custom filtering of the nodes afterwards if that should be necessary.
Usually slightly faster than Method 2: The RandomPath type.
Works reasonably well for navmesh/recast graphs.

Disadvantages

Can be slow when having to search a lot of nodes.

Misc

Takes penalties into account.

Method 4: Breadth-first search

A breadth-first search is a simple search that searches outwards from the starting node a single node at a time. It doesn't take penalties or any other types of costs into account. This means for example that moving diagonally on a grid graph has the same cost as moving along one of the 4 non-diagonal connections.

The way you use it is very similar to what is done in Method 3: The ConstantPath type.

        var startNode = AstarPath.active.GetNearest(transform.position).node;
        var nodes = PathUtilities.BFS(startNode, nodeDistance);
        var singleRandomPoint = PathUtilities.GetPointsOnNodes(nodes, 1)[0];
        var multipleRandomPoints = PathUtilities.GetPointsOnNodes(nodes, 100);

If you want to feed this to a built-in movement script you can use the same approach as in Method 1: Random point inside a circle.

See Also: Pathfinding.PathUtilities.BFS; Pathfinding.PathUtilities.GetPointsOnNodes

Advantages

Can pick multiple random points, not just one.
The probability of chosing a node is proportional to its surface area (so if all nodes have the same size, e.g when using a grid graph then every node that is considered has the same probability of being chosen). There is no bias towards being near obstacles like in Method 1: Random point inside a circle.
Possible to do custom filtering of the nodes afterwards if that should be necessary.
No round trip to the pathfinding system necessary which can save some overhead.
Usually slightly faster than Method 3: The ConstantPath type and Method 2: The RandomPath type.

Disadvantages

Can be slow when having to search a lot of nodes.
Does not use the pathfinding threads, so you loose the ability to easily offload it from the main Unity thead.
Does not work particularly well for navmesh/recast graphs as the paths will have a large variation in length depending on the detail of the navmesh (more and smaller nodes means the BFS will not reach as far).

Misc

Does not take penalties or any other costs into account, only the number of nodes traversed is relevant.