Lesson 6: Procedural Quest Generation

Welcome to the most exciting part of your AI-Powered RPG Game! In this lesson, you'll learn how to create an infinite quest system that generates unique, engaging content using AI. No more static quests - your game will have endless replayability.

What You'll Build

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

• Procedural Quest System that generates unique quests dynamically
• AI-Powered Quest Content using ChatGPT for descriptions, objectives, and rewards
• Quest Categories with different types (fetch, kill, explore, escort)
• Difficulty Scaling that adapts to player level
• Reward System with appropriate loot and experience

Why Procedural Quest Generation Matters

The Problem: Traditional RPGs have limited quest content. Players eventually run out of things to do.

The Solution: AI-generated quests that are:

• Infinite - Never run out of content
• Dynamic - Adapt to player progress and choices
• Engaging - Each quest feels unique and interesting
• Scalable - Difficulty adjusts to player level

Prerequisites

Before starting this lesson, make sure you have:

• ✅ Completed Lesson 5: AI-Powered NPC System
• ✅ Working ChatGPT API integration
• ✅ Basic Unity C# scripting knowledge
• ✅ Understanding of JSON data structures

Step 1: Design Your Quest System Architecture

Quest Data Structure

First, let's design how quests will be structured in your game:

[System.Serializable]
public class Quest
{
    public string id;
    public string title;
    public string description;
    public QuestType type;
    public int difficulty;
    public QuestObjective[] objectives;
    public QuestReward[] rewards;
    public string[] prerequisites;
    public bool isCompleted;
    public bool isActive;
}

[System.Serializable]
public class QuestObjective
{
    public string description;
    public ObjectiveType type;
    public int targetCount;
    public int currentCount;
    public string targetId; // NPC, item, or location ID
}

[System.Serializable]
public class QuestReward
{
    public RewardType type;
    public int amount;
    public string itemId;
}

public enum QuestType
{
    Fetch,      // Collect items
    Kill,       // Defeat enemies
    Explore,    // Visit locations
    Escort,     // Protect NPCs
    Craft,      // Create items
    Social      // Talk to NPCs
}

public enum ObjectiveType
{
    Collect,
    Kill,
    Visit,
    Talk,
    Craft,
    Survive
}

public enum RewardType
{
    Experience,
    Gold,
    Item,
    Reputation
}

Quest Generator Class

Create a new script called QuestGenerator.cs:

using System.Collections.Generic;
using UnityEngine;
using System;

public class QuestGenerator : MonoBehaviour
{
    [Header("AI Configuration")]
    public string openaiApiKey;
    public string openaiBaseUrl = "https://api.openai.com/v1/chat/completions";

    [Header("Quest Settings")]
    public int playerLevel = 1;
    public string gameWorld = "Fantasy";
    public string currentLocation = "Village";

    private void Start()
    {
        // Load API key from PlayerPrefs or secure storage
        openaiApiKey = PlayerPrefs.GetString("OpenAI_API_Key", "");
    }

    public async void GenerateRandomQuest()
    {
        if (string.IsNullOrEmpty(openaiApiKey))
        {
            Debug.LogError("OpenAI API key not found!");
            return;
        }

        try
        {
            Quest newQuest = await CreateQuestWithAI();
            if (newQuest != null)
            {
                Debug.Log($"Generated Quest: {newQuest.title}");
                Debug.Log($"Description: {newQuest.description}");
                // Add quest to quest log
                QuestManager.Instance.AddQuest(newQuest);
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"Quest generation failed: {e.Message}");
        }
    }
}

Step 2: Create AI-Powered Quest Generation

Quest Generation Prompt

Create a method that generates quest content using AI:

private async Task<Quest> CreateQuestWithAI()
{
    string prompt = $@"
    Generate a unique RPG quest for a level {playerLevel} player in a {gameWorld} setting.
    Current location: {currentLocation}

    Requirements:
    - Quest should be appropriate for player level {playerLevel}
    - Make it engaging and unique
    - Include specific objectives
    - Suggest appropriate rewards

    Return ONLY a JSON object with this exact structure:
    {{
        ""title"": ""Quest Title"",
        ""description"": ""Detailed quest description"",
        ""type"": ""Fetch|Kill|Explore|Escort|Craft|Social"",
        ""difficulty"": {playerLevel},
        ""objectives"": [
            {{
                ""description"": ""Objective description"",
                ""type"": ""Collect|Kill|Visit|Talk|Craft|Survive"",
                ""targetCount"": 1,
                ""targetId"": ""specific_target""
            }}
        ],
        ""rewards"": [
            {{
                ""type"": ""Experience|Gold|Item|Reputation"",
                ""amount"": 100,
                ""itemId"": ""item_id_if_applicable""
            }}
        ]
    }}
    ";

    string response = await CallOpenAIAPI(prompt);
    return ParseQuestFromJSON(response);
}

API Communication

Add the OpenAI API call method:

private async Task<string> CallOpenAIAPI(string prompt)
{
    var requestBody = new
    {
        model = "gpt-4",
        messages = new[]
        {
            new { role = "system", content = "You are a game designer creating engaging RPG quests. Always respond with valid JSON only." },
            new { role = "user", content = prompt }
        },
        max_tokens = 1000,
        temperature = 0.8
    };

    string jsonBody = JsonUtility.ToJson(requestBody);

    using (UnityWebRequest request = new UnityWebRequest(openaiBaseUrl, "POST"))
    {
        byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(jsonBody);
        request.uploadHandler = new UploadHandlerRaw(bodyRaw);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", $"Bearer {openaiApiKey}");

        var operation = request.SendWebRequest();

        while (!operation.isDone)
        {
            await Task.Yield();
        }

        if (request.result == UnityWebRequest.Result.Success)
        {
            var response = JsonUtility.FromJson<OpenAIResponse>(request.downloadHandler.text);
            return response.choices[0].message.content;
        }
        else
        {
            throw new Exception($"API request failed: {request.error}");
        }
    }
}

JSON Response Classes

Add these classes to handle the API response:

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

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

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

Step 3: Implement Quest Management System

Quest Manager

Create a QuestManager.cs script:

using System.Collections.Generic;
using UnityEngine;

public class QuestManager : MonoBehaviour
{
    public static QuestManager Instance;

    [Header("Quest Lists")]
    public List<Quest> activeQuests = new List<Quest>();
    public List<Quest> completedQuests = new List<Quest>();
    public List<Quest> availableQuests = new List<Quest>();

    [Header("Quest Generation")]
    public QuestGenerator questGenerator;
    public int maxActiveQuests = 5;

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

    public void AddQuest(Quest quest)
    {
        if (activeQuests.Count < maxActiveQuests)
        {
            quest.isActive = true;
            activeQuests.Add(quest);
            Debug.Log($"Quest added: {quest.title}");
        }
        else
        {
            availableQuests.Add(quest);
            Debug.Log($"Quest queued: {quest.title}");
        }
    }

    public void CompleteQuest(string questId)
    {
        Quest quest = activeQuests.Find(q => q.id == questId);
        if (quest != null)
        {
            quest.isCompleted = true;
            quest.isActive = false;
            activeQuests.Remove(quest);
            completedQuests.Add(quest);

            // Give rewards
            GiveQuestRewards(quest);

            // Check for new quests
            if (availableQuests.Count > 0)
            {
                Quest nextQuest = availableQuests[0];
                availableQuests.RemoveAt(0);
                AddQuest(nextQuest);
            }

            Debug.Log($"Quest completed: {quest.title}");
        }
    }

    private void GiveQuestRewards(Quest quest)
    {
        foreach (QuestReward reward in quest.rewards)
        {
            switch (reward.type)
            {
                case RewardType.Experience:
                    // Add experience to player
                    PlayerStats.Instance.AddExperience(reward.amount);
                    break;
                case RewardType.Gold:
                    // Add gold to player
                    PlayerStats.Instance.AddGold(reward.amount);
                    break;
                case RewardType.Item:
                    // Add item to inventory
                    InventoryManager.Instance.AddItem(reward.itemId, reward.amount);
                    break;
                case RewardType.Reputation:
                    // Add reputation
                    PlayerStats.Instance.AddReputation(reward.amount);
                    break;
            }
        }
    }
}

Step 4: Create Quest UI System

Quest Log UI

Create a quest log interface:

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class QuestLogUI : MonoBehaviour
{
    [Header("UI References")]
    public GameObject questLogPanel;
    public Transform questListParent;
    public GameObject questItemPrefab;
    public TextMeshProUGUI questTitleText;
    public TextMeshProUGUI questDescriptionText;
    public TextMeshProUGUI questObjectivesText;
    public TextMeshProUGUI questRewardsText;

    private Quest selectedQuest;

    private void Start()
    {
        questLogPanel.SetActive(false);
        UpdateQuestList();
    }

    public void ToggleQuestLog()
    {
        questLogPanel.SetActive(!questLogPanel.activeSelf);
        if (questLogPanel.activeSelf)
        {
            UpdateQuestList();
        }
    }

    private void UpdateQuestList()
    {
        // Clear existing quest items
        foreach (Transform child in questListParent)
        {
            Destroy(child.gameObject);
        }

        // Create quest items for active quests
        foreach (Quest quest in QuestManager.Instance.activeQuests)
        {
            GameObject questItem = Instantiate(questItemPrefab, questListParent);
            QuestItemUI questItemUI = questItem.GetComponent<QuestItemUI>();
            questItemUI.SetupQuest(quest, this);
        }
    }

    public void SelectQuest(Quest quest)
    {
        selectedQuest = quest;
        questTitleText.text = quest.title;
        questDescriptionText.text = quest.description;

        // Display objectives
        string objectivesText = "Objectives:\n";
        foreach (QuestObjective objective in quest.objectives)
        {
            objectivesText += $"• {objective.description} ({objective.currentCount}/{objective.targetCount})\n";
        }
        questObjectivesText.text = objectivesText;

        // Display rewards
        string rewardsText = "Rewards:\n";
        foreach (QuestReward reward in quest.rewards)
        {
            rewardsText += $"• {reward.amount} {reward.type}\n";
        }
        questRewardsText.text = rewardsText;
    }
}

Quest Item UI

Create a prefab for individual quest items:

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class QuestItemUI : MonoBehaviour
{
    [Header("UI References")]
    public TextMeshProUGUI questTitleText;
    public TextMeshProUGUI questTypeText;
    public TextMeshProUGUI questDifficultyText;
    public Button questButton;

    private Quest quest;
    private QuestLogUI questLogUI;

    public void SetupQuest(Quest quest, QuestLogUI questLogUI)
    {
        this.quest = quest;
        this.questLogUI = questLogUI;

        questTitleText.text = quest.title;
        questTypeText.text = quest.type.ToString();
        questDifficultyText.text = $"Level {quest.difficulty}";

        questButton.onClick.AddListener(() => questLogUI.SelectQuest(quest));
    }
}

Step 5: Implement Quest Progression Tracking

Objective Tracking

Add methods to track quest progress:

public class QuestManager : MonoBehaviour
{
    // ... existing code ...

    public void UpdateQuestProgress(string objectiveType, string targetId, int amount = 1)
    {
        foreach (Quest quest in activeQuests)
        {
            foreach (QuestObjective objective in quest.objectives)
            {
                if (objective.type.ToString() == objectiveType && objective.targetId == targetId)
                {
                    objective.currentCount += amount;
                    objective.currentCount = Mathf.Min(objective.currentCount, objective.targetCount);

                    Debug.Log($"Quest progress updated: {quest.title} - {objective.description} ({objective.currentCount}/{objective.targetCount})");

                    // Check if quest is complete
                    if (IsQuestComplete(quest))
                    {
                        CompleteQuest(quest.id);
                    }
                }
            }
        }
    }

    private bool IsQuestComplete(Quest quest)
    {
        foreach (QuestObjective objective in quest.objectives)
        {
            if (objective.currentCount < objective.targetCount)
            {
                return false;
            }
        }
        return true;
    }
}

Integration with Game Systems

Connect quest tracking to your existing game systems:

// In your enemy death handler
public void OnEnemyDeath(string enemyId)
{
    QuestManager.Instance.UpdateQuestProgress("Kill", enemyId, 1);
}

// In your item collection handler
public void OnItemCollected(string itemId)
{
    QuestManager.Instance.UpdateQuestProgress("Collect", itemId, 1);
}

// In your location visit handler
public void OnLocationVisited(string locationId)
{
    QuestManager.Instance.UpdateQuestProgress("Visit", locationId, 1);
}

Step 6: Advanced Quest Features

Quest Chains

Implement quest chains for connected storylines:

[System.Serializable]
public class QuestChain
{
    public string chainId;
    public Quest[] quests;
    public int currentQuestIndex;
    public bool isCompleted;
}

public class QuestChainManager : MonoBehaviour
{
    public List<QuestChain> questChains = new List<QuestChain>();

    public void StartQuestChain(string chainId)
    {
        QuestChain chain = questChains.Find(qc => qc.chainId == chainId);
        if (chain != null && !chain.isCompleted)
        {
            Quest firstQuest = chain.quests[0];
            QuestManager.Instance.AddQuest(firstQuest);
        }
    }

    public void CompleteQuestInChain(string questId)
    {
        foreach (QuestChain chain in questChains)
        {
            for (int i = 0; i < chain.quests.Length; i++)
            {
                if (chain.quests[i].id == questId)
                {
                    chain.currentQuestIndex = i + 1;

                    // Start next quest in chain
                    if (chain.currentQuestIndex < chain.quests.Length)
                    {
                        Quest nextQuest = chain.quests[chain.currentQuestIndex];
                        QuestManager.Instance.AddQuest(nextQuest);
                    }
                    else
                    {
                        chain.isCompleted = true;
                        Debug.Log($"Quest chain completed: {chain.chainId}");
                    }
                    break;
                }
            }
        }
    }
}

Dynamic Difficulty Scaling

Implement difficulty scaling based on player performance:

public class QuestDifficultyScaler : MonoBehaviour
{
    [Header("Difficulty Settings")]
    public float baseDifficultyMultiplier = 1.0f;
    public float performanceThreshold = 0.7f; // 70% quest completion rate

    private float questCompletionRate;
    private int totalQuestsAttempted;
    private int totalQuestsCompleted;

    public void UpdateQuestCompletionRate(bool questCompleted)
    {
        totalQuestsAttempted++;
        if (questCompleted)
        {
            totalQuestsCompleted++;
        }

        questCompletionRate = (float)totalQuestsCompleted / totalQuestsAttempted;

        // Adjust difficulty based on performance
        if (questCompletionRate > performanceThreshold)
        {
            baseDifficultyMultiplier += 0.1f; // Increase difficulty
        }
        else if (questCompletionRate < performanceThreshold * 0.5f)
        {
            baseDifficultyMultiplier = Mathf.Max(0.5f, baseDifficultyMultiplier - 0.1f); // Decrease difficulty
        }

        Debug.Log($"Quest completion rate: {questCompletionRate:P1}, Difficulty multiplier: {baseDifficultyMultiplier:F1}");
    }
}

Step 7: Testing and Optimization

Quest Generation Testing

Create a test script to validate quest generation:

public class QuestGenerationTester : MonoBehaviour
{
    [Header("Test Settings")]
    public int testQuestCount = 10;
    public float testInterval = 2.0f;

    private QuestGenerator questGenerator;
    private int questsGenerated = 0;

    private void Start()
    {
        questGenerator = FindObjectOfType<QuestGenerator>();
        StartCoroutine(GenerateTestQuests());
    }

    private IEnumerator GenerateTestQuests()
    {
        while (questsGenerated < testQuestCount)
        {
            questGenerator.GenerateRandomQuest();
            questsGenerated++;
            yield return new WaitForSeconds(testInterval);
        }

        Debug.Log($"Generated {testQuestCount} test quests");
    }
}

Performance Optimization

Optimize quest generation for better performance:

public class QuestGenerator : MonoBehaviour
{
    [Header("Performance Settings")]
    public int maxQuestsPerMinute = 5;
    public float questGenerationCooldown = 12.0f;

    private float lastQuestGenerationTime;
    private Queue<string> questGenerationQueue = new Queue<string>();

    public void RequestQuestGeneration(string playerContext)
    {
        if (Time.time - lastQuestGenerationTime < questGenerationCooldown)
        {
            questGenerationQueue.Enqueue(playerContext);
            return;
        }

        GenerateQuestWithContext(playerContext);
    }

    private async void GenerateQuestWithContext(string context)
    {
        lastQuestGenerationTime = Time.time;

        // Add context to prompt for more relevant quests
        string contextualPrompt = $@"
        Player context: {context}
        Current time: {System.DateTime.Now:HH:mm}
        Recent quests: {GetRecentQuestTypes()}

        Generate a quest that fits this context...
        ";

        // Process queued requests
        if (questGenerationQueue.Count > 0)
        {
            string queuedContext = questGenerationQueue.Dequeue();
            // Handle queued request
        }
    }
}

Mini-Task: Create Your First Procedural Quest

Your Mission: Generate 5 unique quests using your new system and test them in-game.

Steps:

1. Set up the QuestGenerator in your scene
2. Configure your OpenAI API key
3. Generate 5 different quests
4. Test quest completion and reward systems
5. Verify quest UI displays correctly

Success Criteria:

• ✅ 5 unique quests generated successfully
• ✅ Quest objectives track progress correctly
• ✅ Rewards are given upon completion
• ✅ Quest UI displays all information properly

Common Issues and Solutions

Issue 1: API Rate Limits

Problem: Getting rate limit errors from OpenAI Solution: Implement request queuing and cooldown periods

Issue 2: Invalid JSON Responses

Problem: AI sometimes returns malformed JSON Solution: Add JSON validation and retry logic

Issue 3: Quest Difficulty Imbalance

Problem: Generated quests are too easy or too hard Solution: Implement difficulty scaling and player feedback loops

Next Steps

Congratulations! You've built a complete procedural quest generation system. In the next lesson, you'll learn about:

• Advanced AI Integration - More sophisticated AI features
• Quest Analytics - Tracking player engagement
• Performance Optimization - Making your system more efficient

Resources

• Unity WebRequest Documentation
• JSON Serialization in Unity
• OpenAI API Documentation

Community Challenge

Share Your Quest System: Post a screenshot of your quest generation in action and tag us on social media! Show off the most creative quest your AI generated.

Pro Tip: Experiment with different prompt styles to generate quests that match your game's tone and setting. The more specific your prompts, the better your results will be.

Ready to create infinite content for your RPG? Let's build the quest system that will keep players engaged for hours!