Dynamic Quest Generator Using AI + Rule‑Based Systems (AAA Design + Unity Implementation)
A Dynamic Quest Generator combines classical rule‑based systems with AI‑driven content generation to produce quests that adapt to the world state, faction relationships, player history, emotional tone, and long‑term narrative memory. This hybrid model ensures the content is coherent, story‑safe, and procedurally rich while preserving writer control.
1. System Overview
The generator is built from four subsystems:
World State Model (facts, flags, factions, NPC states)
AI Expansion Layer (dialogue, flavor text, twists)
Quest Memory System (tracks past events, reputation, recurring characters)
The rule system ensures correctness; the AI layer injects creativity and personalization.
2. World State Representation
This contains the facts the generator can use.
public class WorldState
{
public HashSet<string> flags = new HashSet<string>(); // "village_burned", "king_missing"
public Dictionary<string, int> factionReputation = new(); // "MagesGuild" → 40
public Dictionary<string, NPCState> npcStates = new(); // NPCs, their mood & alive/dead
public string currentRegion; // biome, story area
}
NPC state is also tracked:
public class NPCState
{
public string name;
public bool alive = true;
public string mood = "neutral";
public List<string> personalHistory = new(); // “player saved him in Act 1”
}
3. Quest Template System (Rule‑Based)
A Quest Template is a structured rule definition. It ensures the AI never generates structurally broken quests.
Example template fields:
public class QuestTemplate
{
public string templateID;
public string category; // "Rescue", "Investigation", "Delivery", "Assassination"
// Hard rules
public List<string> requiredFlags = new();
public List<string> forbiddenFlags = new();
public List<string> allowedRegions = new();
// Soft rules
public int minReputation;
public string npcTag; // NPC type needed: "merchant", "soldier", "mage"
}
Templates guarantee:
There is always a valid target NPC
Quest stages follow a valid pattern
No contradictions with world state
4. Quest Generator Pipeline
Full generation process:
Select valid templates via rule filtering
Select target NPCs / locations / factions
Let AI generate quest flavor, twist, dialogue, emotional tone
Build final quest graph (objectives, conditions, rewards)
public class QuestGenerator
{
public async Task<Quest> Generate(WorldState ws, DialogueContext memory, List<QuestTemplate> templates)
{
// 1. Filter templates
var valid = templates.Where(t => IsTemplateValid(t, ws)).ToList();
var chosen = valid[UnityEngine.Random.Range(0, valid.Count)];
// 2. Pick actors/locations
var npc = PickNPC(chosen, ws);
var region = ws.currentRegion;
// 3. AI Expansion Layer
string aiDescription = await AIQuestExpander.GenerateQuestText(chosen, npc, ws, memory);
// 4. Build a quest object
return BuildQuest(chosen, npc, region, aiDescription);
}
}
5. AI Quest Expansion Layer
The AI is never allowed to invent structural logic. Instead, it embellishes what the rule‑based layer decides.
Prompt builder example:
public static class AIQuestExpander
{
public static async Task<string> GenerateQuestText(
QuestTemplate t, NPCState npc, WorldState ws, DialogueContext mem)
{
string prompt =
$@"Generate a short quest description.
TemplateType: {t.category}
NPC: {npc.name}, Mood: {npc.mood}
Region: {ws.currentRegion}
PlayerHistory:
{string.Join("\n", mem.conversationHistory.TakeLast(6))}
WorldFacts:
{string.Join(", ", ws.flags)}
Rules:
- Follow the structure of a {t.category} quest
- Do NOT contradict world flags
- Do NOT create new world events
- Keep it short, game-friendly, and consistent
Respond with a single paragraph.";
return await AIClient.QueryAsync(prompt);
}
}
This ensures 100% safe output.
6. Quest Memory System (Long‑Term Narrative Memory)
This is where it gets interesting. The generator tracks past quests, important NPC interactions, betrayals, favors, etc.
public class QuestMemory
{
public List<string> completedQuestIDs = new();
public Dictionary<string, int> npcAffinity = new(); // "Elara" → +20
public Dictionary<string, string> persistentTags = new(); // “Elara_mood” → “grateful”
}
How it works:
If the player betrayed an NPC earlier → reduce their affinity → quest styles shift
If the player saved a village → unlock new quest templates
If the player makes repeated choices (mercy/violence) → tone shifts in AI responses
This memory merges into AI prompts automatically.
7. Building the Final Quest Object
Example Unity‑friendly quest class:
public class Quest
{
public string questID;
public string title;
public string description;
public NPCState giver;
public string region;
public List<QuestStep> steps = new();
}
public class QuestStep
{
public string text;
public string objectiveType; // “go_to”, “kill”, “talk”
public string targetID;
}
The final quest is a mix of:
Rule‑generated safe structure
AI‑generated details and tone
Memory that personalizes the quest
8. Example End‑to‑End Flow
Let’s simulate:
WorldState:
- region = Frozen Coast
- flags = ["village_burned", "wolves_aggressive"]
- NPC “Elara” saved by player in Act 1 (mood=grateful)
Template: Investigation
AI adds:
“A frightened Elara asks you to investigate strange tracks
leading from the burned village into the frozen cliffs...”
Final Quest:
- Investigate the tracks
- Follow clues to the cliffs
- Confront a possessed ranger
The world state created the setup; the AI wrote the flavor; and the rule template ensured a valid structure.
9. Preventing AI from Breaking Canon
Strong constraints are essential:
AI never decides objectives
AI never creates new flags
AI never kills/creates major NPCs
All branching handled by rule system
AI only writes text, not logic
This turns AI into a stylist, not a game designer.
