Create a Simple AI Companion in Unity

Imagine the possibilities: a helpful companion in your game, reacting to your commands, and adding depth to your world. Building an AI companion might seem daunting, but with Unity and a bit of code, it’s surprisingly achievable. This guide breaks down the process, focusing on creating a basic, functional companion, and skipping the fluff that often clutters beginner tutorials. We’re diving straight into the practical implementation, leaving you with a working prototype and a solid understanding of the core principles.

Setting Up Your Project

First, create a new Unity project. This provides a clean slate for our AI companion. Import the NavMeshComponents package (Window -> Package Manager). This is crucial for enabling our companion to navigate the environment intelligently.

One common mistake is forgetting to “bake” the NavMesh. Navigate to Window -> AI -> Navigation. Select the “Bake” tab and click “Bake.” This generates the navigation mesh from your scene’s static objects, defining where your companion can move. If you skip this step, your AI will simply stand still, confused and lost.

Implementing Basic Following Behavior with NavMesh

Now, let’s create the companion. Create a new GameObject (e.g., a simple capsule) and name it "Companion". Add a NavMeshAgent component to the “Companion” GameObject. This component is the key to making it move along the NavMesh.

Here’s the C# script, CompanionAI.cs, for basic following. Attach this script to your “Companion” GameObject:

using UnityEngine;
using UnityEngine.AI;

public class CompanionAI : MonoBehaviour
{
    public Transform target; // The object to follow (e.g., the player)
    private NavMeshAgent agent; // The NavMeshAgent component

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        if (agent == null)
        {
            Debug.LogError("NavMeshAgent not found on this GameObject!");
            enabled = false; // Disable the script if the agent is missing
            return;
        }

        if (target == null)
        {
            Debug.LogError("Target not assigned! Please assign a target in the Inspector.");
            enabled = false;
            return;
        }
    }

    void Update()
    {
        // Tell the agent to move to the target's position
        agent.SetDestination(target.position);
    }
}

Don’t underestimate the importance of error handling. The Start() function checks for missing components and a missing target. Failing to do this can lead to NullReferenceExceptions and frustrating debugging sessions.

Assign your player GameObject to the target field in the Inspector of your “Companion” GameObject. Now, your companion should follow the player around the baked NavMesh.

Interaction Triggers: Stay and Follow Commands

To give the player control, let’s add some basic interaction triggers for “stay” and “follow” commands. We’ll use a simple boolean flag to control the agent’s movement.

Modify the CompanionAI.cs script:

using UnityEngine;
using UnityEngine.AI;

public class CompanionAI : MonoBehaviour
{
    public Transform target;
    private NavMeshAgent agent;
    private bool isFollowing = true; // Flag to control following behavior

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
         if (agent == null)
        {
            Debug.LogError("NavMeshAgent not found on this GameObject!");
            enabled = false; // Disable the script if the agent is missing
            return;
        }

        if (target == null)
        {
            Debug.LogError("Target not assigned! Please assign a target in the Inspector.");
            enabled = false;
            return;
        }
    }

    void Update()
    {
        if (isFollowing)
        {
            agent.SetDestination(target.position);
        }
        else
        {
            // Stop the agent
            agent.ResetPath();
        }
    }

    // Public method to toggle following behavior
    public void ToggleFollow()
    {
        isFollowing = !isFollowing;
    }
}

Now, create a simple UI button in your scene. Attach a script to this button that calls the ToggleFollow() method on the “Companion” GameObject when clicked.

Here’s a script for the UI Button, ButtonController.cs:

using UnityEngine;
using UnityEngine.UI;

public class ButtonController : MonoBehaviour
{
    public CompanionAI companion; // Reference to the CompanionAI script

    void Start()
    {
        Button button = GetComponent<Button>();
        if (button == null)
        {
            Debug.LogError("Button component not found on this GameObject!");
            enabled = false;
            return;
        }

        button.onClick.AddListener(TaskOnClick);

         if (companion == null)
        {
            Debug.LogError("Companion AI not assigned! Please assign a companion in the Inspector.");
            enabled = false;
            return;
        }
    }

    void TaskOnClick()
    {
        companion.ToggleFollow();
    }
}

Attach this to a Button. Then drag the companion to the companion field on this script’s inspector window.

A common mistake is forgetting to link the button’s onClick event to the TaskOnClick method. This is done in the Inspector of the button GameObject. Without this link, the button will do nothing when clicked.

Common Pitfalls and Solutions

One major challenge is collision avoidance. The NavMeshAgent has built-in collision avoidance, but it can sometimes be insufficient, especially in complex environments. Experiment with the radius and height properties of the NavMeshAgent to fine-tune its collision behavior. Consider adding a Rigidbody and Capsule Collider to the Companion for more robust collision detection and response. However, be cautious: improperly configured physics can lead to jittery movement and unexpected behavior.

Another issue is performance. NavMeshAgent.SetDestination is relatively expensive. Calling it every frame, especially with multiple agents, can impact performance. Consider using techniques like path caching or only updating the destination when the target has moved a significant distance.

This covers the basics. Further enhancements could include more complex command systems (e.g., “attack,” “defend”), animation integration, and more sophisticated AI behaviors. By building upon this foundation, you can create truly engaging and interactive AI companions for your Unity games.