Lesson 5: AI-Powered NPC System

Welcome to the most exciting part of your RPG development journey! In this lesson, you'll learn how to create intelligent NPCs that can have dynamic conversations with players using AI. This is where your game truly comes alive with characters that feel real and engaging.

What You'll Learn

By the end of this lesson, you'll have:

• ChatGPT API Integration - Connect your game to OpenAI's powerful language model
• Dynamic Dialogue System - NPCs that respond contextually to player interactions
• Behavior Trees - Create complex NPC decision-making systems
• State Machines - Manage NPC behavior states and transitions
• Real-time AI Conversations - Players can talk to NPCs naturally

Prerequisites

Before starting, make sure you have:

• Completed Lesson 4 (Character Controller & Movement Systems)
• Unity project with basic scene setup
• OpenAI API key (we'll show you how to get one)
• Basic understanding of C# scripting

Step 1: Setting Up ChatGPT API Integration

Getting Your OpenAI API Key

1. Go to OpenAI's website
2. Create an account or sign in
3. Navigate to API Keys section
4. Create a new secret key
5. Copy and save it securely (you'll need it for Unity)

Installing Required Packages

1. Open your Unity project
2. Go to Window > Package Manager
3. Search for "JSON" and install "JSON .NET"
4. Search for "UnityWebRequest" (should be included by default)

Creating the API Manager

Create a new C# script called ChatGPTManager.cs:

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;
using System.Text;

public class ChatGPTManager : MonoBehaviour
{
    [Header("API Configuration")]
    public string apiKey = "your-api-key-here";
    public string apiUrl = "https://api.openai.com/v1/chat/completions";

    [Header("NPC Settings")]
    public string npcPersonality = "You are a friendly village merchant who loves to help travelers.";
    public int maxTokens = 150;

    public static ChatGPTManager Instance { get; private set; }

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void SendMessageToNPC(string playerMessage, System.Action<string> onResponse)
    {
        StartCoroutine(SendChatGPTRequest(playerMessage, onResponse));
    }

    private IEnumerator SendChatGPTRequest(string playerMessage, System.Action<string> onResponse)
    {
        // Create the request payload
        var requestData = new
        {
            model = "gpt-3.5-turbo",
            messages = new[]
            {
                new { role = "system", content = npcPersonality },
                new { role = "user", content = playerMessage }
            },
            max_tokens = maxTokens,
            temperature = 0.7f
        };

        string jsonData = JsonUtility.ToJson(requestData);
        byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);

        // Create the web request
        UnityWebRequest request = new UnityWebRequest(apiUrl, "POST");
        request.uploadHandler = new UploadHandlerRaw(bodyRaw);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", "Bearer " + apiKey);

        // Send the request
        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            // Parse the response
            var response = JsonUtility.FromJson<ChatGPTResponse>(request.downloadHandler.text);
            string npcResponse = response.choices[0].message.content;
            onResponse?.Invoke(npcResponse);
        }
        else
        {
            Debug.LogError("ChatGPT API Error: " + request.error);
            onResponse?.Invoke("I'm having trouble thinking right now. Can you try again?");
        }
    }
}

[System.Serializable]
public class ChatGPTResponse
{
    public Choice[] choices;
}

[System.Serializable]
public class Choice
{
    public Message message;
}

[System.Serializable]
public class Message
{
    public string content;
}

Step 2: Creating the NPC Dialogue System

Building the Dialogue UI

1. Create a Canvas in your scene
2. Add a Panel for the dialogue box
3. Add Text components for player and NPC messages
4. Add an InputField for player input
5. Add a Button to send messages

Creating the Dialogue Manager

Create NPCDialogueManager.cs:

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class NPCDialogueManager : MonoBehaviour
{
    [Header("UI References")]
    public GameObject dialoguePanel;
    public TextMeshProUGUI npcText;
    public TextMeshProUGUI playerText;
    public TMP_InputField inputField;
    public Button sendButton;

    [Header("NPC Settings")]
    public string npcName = "Village Merchant";
    public Transform playerTransform;
    public float interactionDistance = 3f;

    private bool isDialogueActive = false;
    private bool isWaitingForResponse = false;

    void Start()
    {
        dialoguePanel.SetActive(false);
        sendButton.onClick.AddListener(SendMessage);

        // Allow Enter key to send message
        inputField.onEndEdit.AddListener(OnInputEndEdit);
    }

    void Update()
    {
        // Check if player is close enough to interact
        if (Vector3.Distance(transform.position, playerTransform.position) <= interactionDistance)
        {
            if (Input.GetKeyDown(KeyCode.E) && !isDialogueActive)
            {
                StartDialogue();
            }
        }

        // Close dialogue if player moves away
        if (isDialogueActive && Vector3.Distance(transform.position, playerTransform.position) > interactionDistance)
        {
            EndDialogue();
        }
    }

    public void StartDialogue()
    {
        isDialogueActive = true;
        dialoguePanel.SetActive(true);
        inputField.text = "";
        inputField.ActivateInputField();

        // Send initial greeting
        string greeting = "Hello there, traveler! How can I help you today?";
        npcText.text = greeting;
    }

    public void EndDialogue()
    {
        isDialogueActive = false;
        dialoguePanel.SetActive(false);
    }

    private void SendMessage()
    {
        if (isWaitingForResponse) return;

        string playerMessage = inputField.text.Trim();
        if (string.IsNullOrEmpty(playerMessage)) return;

        // Display player message
        playerText.text = "You: " + playerMessage;
        inputField.text = "";

        // Show loading state
        npcText.text = "Thinking...";
        isWaitingForResponse = true;

        // Send to ChatGPT
        ChatGPTManager.Instance.SendMessageToNPC(playerMessage, OnNPCResponse);
    }

    private void OnNPCResponse(string response)
    {
        npcText.text = npcName + ": " + response;
        isWaitingForResponse = false;
        inputField.ActivateInputField();
    }

    private void OnInputEndEdit(string text)
    {
        if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter))
        {
            SendMessage();
        }
    }
}

Step 3: Creating NPC Behavior Trees

Understanding Behavior Trees

Behavior trees are a powerful way to create complex NPC AI. They use a hierarchical structure of nodes that determine what an NPC should do.

Creating a Simple Behavior Tree

Create NPCBehaviorTree.cs:

using UnityEngine;

public class NPCBehaviorTree : MonoBehaviour
{
    [Header("Behavior Settings")]
    public float patrolRadius = 10f;
    public float waitTime = 2f;
    public float moveSpeed = 2f;

    private Vector3 startPosition;
    private Vector3 targetPosition;
    private float waitTimer;
    private NPCState currentState;

    public enum NPCState
    {
        Idle,
        Patrolling,
        Talking,
        Returning
    }

    void Start()
    {
        startPosition = transform.position;
        currentState = NPCState.Idle;
        SetRandomTarget();
    }

    void Update()
    {
        switch (currentState)
        {
            case NPCState.Idle:
                HandleIdleState();
                break;
            case NPCState.Patrolling:
                HandlePatrolState();
                break;
            case NPCState.Talking:
                HandleTalkingState();
                break;
            case NPCState.Returning:
                HandleReturnState();
                break;
        }
    }

    private void HandleIdleState()
    {
        waitTimer += Time.deltaTime;
        if (waitTimer >= waitTime)
        {
            currentState = NPCState.Patrolling;
            waitTimer = 0f;
        }
    }

    private void HandlePatrolState()
    {
        MoveTowardsTarget();

        if (Vector3.Distance(transform.position, targetPosition) < 0.5f)
        {
            currentState = NPCState.Idle;
            SetRandomTarget();
        }
    }

    private void HandleTalkingState()
    {
        // NPC stops moving when talking
        // This state is managed by the dialogue system
    }

    private void HandleReturnState()
    {
        targetPosition = startPosition;
        MoveTowardsTarget();

        if (Vector3.Distance(transform.position, startPosition) < 0.5f)
        {
            currentState = NPCState.Idle;
        }
    }

    private void MoveTowardsTarget()
    {
        Vector3 direction = (targetPosition - transform.position).normalized;
        transform.position += direction * moveSpeed * Time.deltaTime;

        // Face the direction of movement
        if (direction != Vector3.zero)
        {
            transform.rotation = Quaternion.LookRotation(direction);
        }
    }

    private void SetRandomTarget()
    {
        Vector2 randomPoint = Random.insideUnitCircle * patrolRadius;
        targetPosition = startPosition + new Vector3(randomPoint.x, 0, randomPoint.y);
    }

    public void StartConversation()
    {
        currentState = NPCState.Talking;
    }

    public void EndConversation()
    {
        currentState = NPCState.Returning;
    }
}

Step 4: Integrating Dialogue with Behavior

Connecting Dialogue to Behavior

Update your NPCDialogueManager.cs to work with the behavior tree:

// Add this to NPCDialogueManager
private NPCBehaviorTree behaviorTree;

void Start()
{
    // ... existing code ...
    behaviorTree = GetComponent<NPCBehaviorTree>();
}

public void StartDialogue()
{
    isDialogueActive = true;
    dialoguePanel.SetActive(true);
    inputField.text = "";
    inputField.ActivateInputField();

    // Stop NPC movement
    if (behaviorTree != null)
    {
        behaviorTree.StartConversation();
    }

    // Send initial greeting
    string greeting = "Hello there, traveler! How can I help you today?";
    npcText.text = greeting;
}

public void EndDialogue()
{
    isDialogueActive = false;
    dialoguePanel.SetActive(false);

    // Resume NPC behavior
    if (behaviorTree != null)
    {
        behaviorTree.EndConversation();
    }
}

Step 5: Advanced NPC Personalities

Creating Different NPC Types

Create a script to define different NPC personalities:

[System.Serializable]
public class NPCPersonality
{
    public string name;
    public string systemPrompt;
    public float responseTime;
    public string[] greetingMessages;
}

public class NPCPersonalityManager : MonoBehaviour
{
    [Header("NPC Personalities")]
    public NPCPersonality[] personalities;

    public NPCPersonality GetRandomPersonality()
    {
        return personalities[Random.Range(0, personalities.Length)];
    }
}

Setting Up Different Personalities

In your ChatGPTManager, you can switch personalities:

public void SetNPCPersonality(string personality)
{
    npcPersonality = personality;
}

Mini Challenge: Create Your First AI NPC

Your Task:

1. Set up the ChatGPT API integration
2. Create an NPC with dialogue system
3. Add basic behavior (idle, patrol, talk)
4. Test a conversation with your NPC

Success Criteria:

• NPC responds to player messages
• NPC has basic movement behavior
• Dialogue system works smoothly
• No errors in the console

Pro Tips for Better NPCs

1. Context Awareness

// Add context to your API calls
string contextualPrompt = npcPersonality + "\nCurrent time: " + System.DateTime.Now.ToString("HH:mm") + 
                         "\nPlayer level: " + playerLevel + "\nLocation: " + currentLocation;

2. Response Caching

// Cache common responses to reduce API calls
private Dictionary<string, string> responseCache = new Dictionary<string, string>();

3. Personality Consistency

// Use consistent personality traits
public class PersonalityTraits
{
    public string speakingStyle;
    public string[] favoriteTopics;
    public string[] dislikes;
    public float friendliness;
}

Troubleshooting Common Issues

Issue 1: API Key Not Working

Symptoms: "Unauthorized" or "Invalid API Key" errors Solution:

• Double-check your API key
• Ensure you have credits in your OpenAI account
• Check if the key has proper permissions

Issue 2: Slow Response Times

Symptoms: NPCs take too long to respond Solution:

• Reduce max_tokens parameter
• Use GPT-3.5-turbo instead of GPT-4
• Implement response caching

Issue 3: Inappropriate Responses

Symptoms: NPCs give weird or inappropriate answers Solution:

• Improve your system prompt
• Add content filtering
• Use more specific personality descriptions

What's Next?

Congratulations! You've created your first AI-powered NPC. In the next lesson, you'll learn about Procedural Quest Generation - using AI to create dynamic, never-ending quests for your players.

Coming Up in Lesson 6:

• AI-generated quest content
• Dynamic quest objectives
• Procedural storylines
• Quest tracking systems

Resources

• OpenAI API Documentation
• Unity WebRequest Guide
• Behavior Tree Patterns

Ready to make your NPCs even smarter? Share your AI conversations in the community and get feedback on your NPC personalities!

Found this lesson helpful? Bookmark it for reference and share your AI NPC creations with the community. The future of game development is here - and you're building it!