Quick Start Guide

This guide walks you through creating a complete quest database from scratch using the Quest Forge wizard. By the end, you will have a type-safe ScriptableObject database with a professional custom Inspector, ready to use in your game code. The entire process takes under 5 minutes.

The Quest Forge wizard is the foundation of Simple Quest Forge. Everything else — quest chains, procedural generation, and runtime tracking — builds on top of the quest databases you create here.

Prerequisites

Unity 2021.3 or newer — any render pipeline (Built-in, URP, HDRP)
Simple Quest Forge package imported — see Installation if you have not done this yet

No other dependencies are required. Simple Quest Forge works standalone. If you also have Simple Enemy Forge, Simple Item Forge, or Simple Attribute Forge installed, SQF will detect them automatically and offer smart integration features like enemy target dropdowns, item reward linking, and attribute modifier references. But none of these are required to get started.

5-Step Creation Process

The Quest Forge wizard guides you through five sequential steps. You can move back and forth between steps at any time — nothing is committed until you click Generate in the final step.

1 Open the Quest Forge Wizard
Navigate to Window → Simple Quest Forge → Quest Forge Wizard in the Unity menu bar. This opens a dedicated editor window where you will design your quest database.

2 Step 1 — Setup
Enter a Class Prefix (e.g., "Fantasy"). This prefix is used for all generated class names, so "Fantasy" produces FantasyType, FantasyDatabase, etc. Choose a name that describes your game or project.

Optionally select a genre template to pre-populate definitions and example quests. Templates include Generic RPG, Open World, MMO, Survival, Narrative RPG, and Roguelike. Each template sets up appropriate categories, flags, numerics, and sample quests so you can see how everything fits together before customizing.

You can also optionally link external databases here — enemy databases (from Simple Enemy Forge), item databases (from Simple Item Forge), faction databases, loot databases, and attribute databases. When linked, the wizard provides smart dropdown menus for target codes instead of requiring you to type them manually. These are entirely optional and can be added later.

3 Step 2 — Definitions
This is where you design your property system. Simple Quest Forge uses a dynamic property system with four property types (Categories, Flags, Numerics, and Texts) defined at two independent levels:

Quest-level properties describe the quest itself. For example: Quest Type (category), Region (category), Is Repeatable (flag), Recommended Level (numeric), Journal Entry (text).

Objective-level properties describe individual objectives within a quest. For example: Objective Type (category), Is Tracked (flag), XP Multiplier (numeric), Hint Text (text).

Each level has its own independent set of Categories, Flags, Numerics, and Texts. The properties you define here become the fields available on every quest (or every objective) in your database. See the Understanding the Property System section below for more detail.

This step also provides schema export and import for AI-assisted content creation. You can export your definitions as JSON or Markdown, hand them to an AI like ChatGPT or Claude, and import the resulting quest data back. See AI Workflow for the full guide.

4 Step 3 — Quests
Create your actual quests using the properties you defined in Step 2. Each quest has:

Identity — a unique code (e.g., "SLAY_THE_DRAGON"), display name, description, and optional icon sprite
Objectives — each with a code, description, isOptional flag, targetCode, targetCount, timeLimit (in seconds, 0 = no limit), sortOrder, and objective-level dynamic properties
Rewards — each with a code, description, targetCode, amount, isChoice flag, and choiceGroup (rewards sharing the same choiceGroup form a pick-one set)
Prerequisites — each with a targetCode, comparison operator (GreaterThan, GreaterThanOrEqual, LessThan, LessThanOrEqual, Equal, NotEqual), and threshold value
Quest-level properties — the Categories, Flags, Numerics, and Texts you defined in Step 2

The wizard provides a paginated split-panel interface with search and sort, so you can comfortably manage databases with hundreds of quests.

5 Step 4 — Settings
Choose output paths for the generated scripts and the database asset. The defaults place scripts in a Scripts/ folder and the data asset in a Data/ folder, both under a generated output directory. You can customize these paths to match your project structure.

6 Step 5 — Generate
Click Generate. The wizard uses a two-phase generation process: first it writes the C# scripts and triggers an asset database refresh (which causes a domain reload), then an [InitializeOnLoad] handler fires after recompilation to create the actual database asset and populate it with your quest data. This all happens automatically — just click the button and wait for the compilation to finish.

Understanding the Property System

The property system is what makes Simple Quest Forge flexible enough for any game genre. Instead of hardcoding fields like "questType" or "recommendedLevel" into the source code, you define your own custom properties in the Definitions step, and SQF generates the storage and editor UI for them automatically.

There are four property types, each serving a different purpose:

Type	What It Stores	Storage	Example
Categories	A selection from a list of named entries (like an enum)	`int[] categoryValues`	Quest Type (Kill, Fetch, Escort), Region (Forest, Desert, Dungeon)
Flags	A boolean on/off toggle	`bool[] flagValues`	Is Repeatable, Is Hidden, Is Timed
Numerics	A float value (optionally integer, optionally range-clamped)	`float[] numericValues`	Recommended Level, XP Reward, Gold Reward, Time Limit
Texts	A free-form string (single-line or multi-line)	`string[] textValues`	Journal Entry, Completion Text, Failure Text, Lore

These properties are defined once in the Definitions step (Step 2) and then appear as editable fields on every quest in the builder (Step 3) and in the generated custom Inspector. The property arrays are stored directly on the SimpleQuestDefinition struct, so you can access them at runtime using index-based accessors or the convenience methods like GetCategoryValue(index), GetFlagValue(index), GetNumericValue(index), and GetTextValue(index).

Quest-level and objective-level properties are completely independent. You might have a quest-level category called "Quest Type" (index 0) and an objective-level category called "Objective Type" (also index 0), and they do not interfere with each other. Quest-level properties live on SimpleQuestDefinition, while objective-level properties live on SimpleQuestObjective.

Example: RPG Quests

Let us walk through a concrete example. We will create a small fantasy RPG quest database with three quests of increasing complexity.

Step 1: Setup

Basic Settings

Class Prefix: "Fantasy"
Template: Generic RPG

The Generic RPG template pre-populates quest-level categories (Quest Type, Region, Difficulty), quest-level flags (Is Repeatable, Is Hidden), quest-level numerics (Recommended Level, XP Reward, Gold Reward), objective-level categories (Objective Type), and example quests with full objectives, rewards, and prerequisites. You can modify or remove any of these after loading the template — they are just a starting point.

Step 3: Create Quests

Wolf Menace

Code: WOLF_MENACE
Quest Type: Kill Quest
Objective: code: "KILL_WOLVES", description: "Eliminate the wolf pack", targetCode: "WOLF", targetCount: 10, isOptional: false
Reward 1: code: "XP_REWARD", description: "100 Experience Points", targetCode: "XP", amount: 100
Reward 2: code: "GOLD_REWARD", description: "50 Gold Coins", targetCode: "GOLD", amount: 50

The Lost Pendant

Code: THE_LOST_PENDANT
Quest Type: Fetch Quest
Objective: code: "FIND_PENDANT", description: "Find the silver pendant in the ruins", targetCode: "SILVER_PENDANT", targetCount: 1, isOptional: false
Reward 1: code: "XP_REWARD", description: "200 Experience Points", targetCode: "XP", amount: 200
Reward 2: code: "RING_REWARD", description: "Ring of Wisdom", targetCode: "RING_OF_WISDOM", amount: 1, isChoice: false

The Dragon's Bane

Code: THE_DRAGONS_BANE
Quest Type: Boss Quest
Prerequisite: targetCode: "PLAYER_LEVEL", comparison: GreaterThanOrEqual, value: 20
Objective 1: code: "SLAY_DRAGON", description: "Slay the Elder Dragon", targetCode: "ELDER_DRAGON", targetCount: 1, isOptional: false
Objective 2: code: "COLLECT_SCALES", description: "Collect Dragon Scales", targetCode: "DRAGON_SCALE", targetCount: 5, isOptional: true
Reward 1: code: "XP_REWARD", description: "5000 Experience Points", targetCode: "XP", amount: 5000
Reward 2 (choice): code: "SWORD_CHOICE", description: "Dragon Slayer Sword", targetCode: "DRAGON_SWORD", amount: 1, isChoice: true, choiceGroup: 1
Reward 3 (choice): code: "SHIELD_CHOICE", description: "Dragon Scale Shield", targetCode: "DRAGON_SHIELD", amount: 1, isChoice: true, choiceGroup: 1

Note: Rewards 2 and 3 share choiceGroup: 1, so the player must pick one or the other. Reward 1 (XP) has isChoice: false, so it is always granted.

What Gets Generated

After clicking Generate in Step 5, the wizard creates four files. Here is what each one does:

Generated File Tree

Assets/ └─ Generated/ ├─ Quests/Scripts/ │ ├─ FantasyType.cs (enum) │ ├─ FantasyDatabase.cs (ScriptableObject) │ └─ Editor/ │ └─ FantasyDatabaseEditor.cs (custom inspector) └─ Quests/Data/ └─ FantasyDatabase.asset (your data)

What Each File Does

File	Purpose
FantasyType.cs	An `enum` with one entry per quest code (e.g., `FantasyType.WOLF_MENACE`, `FantasyType.THE_DRAGONS_BANE`). Gives you compile-time type safety when referencing quests in code — typos become compiler errors instead of silent runtime bugs.
FantasyDatabase.cs	A `ScriptableObject` that implements `ISimpleQuestDataSource`. Contains the quest array, all property metadata (category labels, flag names, numeric names, text names for both quest-level and objective-level), and accessor methods like `GetQuestByCode()`, `GetQuestsByCategory()`, `GetQuestsWithObjectiveTarget()`, and more.
FantasyDatabaseEditor.cs	A custom `UnityEditor.Editor` that provides a professional split-panel Inspector for your database asset. See The Generated Custom Editor below for details.
FantasyDatabase.asset	The actual ScriptableObject asset containing all your quest data. This is what you drag into MonoBehaviour fields and reference at runtime. You can edit it directly in the Inspector using the generated custom editor, or re-open the wizard to make bulk changes.

Regeneration is safe. You can re-open the Quest Forge wizard, make changes, and click Generate again. The wizard will overwrite the existing scripts and asset, preserving any data that has not changed. If you need to rename your prefix, generate a new set and delete the old files manually.

Using Your Quests in Code

The generated database provides multiple ways to access your quest data at runtime. All access goes through the ISimpleQuestDataSource interface, so your game code does not depend on the specific generated class name.

Basic Access — Look Up a Single Quest

The most common pattern is to look up a quest by its code. The GetQuestByCode() method returns a nullable struct (SimpleQuestDefinition?), so you must check HasValue before accessing the data. This protects you from null reference exceptions if a code does not exist in the database.

using UnityEngine;
using SimpleQuestForge;

public class QuestGiver : MonoBehaviour
{
    [SerializeField] FantasyDatabase questDatabase;

    void Start()
    {
        // --- Look up by code string ---
        SimpleQuestDefinition? result = questDatabase.GetQuestByCode("WOLF_MENACE");

        // Always check HasValue before accessing .Value
        if (result.HasValue)
        {
            SimpleQuestDefinition quest = result.Value;
            Debug.Log(quest.name);        // "Wolf Menace"
            Debug.Log(quest.code);        // "WOLF_MENACE"
            Debug.Log(quest.description); // "Eliminate the wolf pack..."
        }

        // --- Look up by generated enum (type-safe, no typo risk) ---
        var dragonResult = questDatabase.GetQuest(FantasyType.THE_DRAGONS_BANE);

        if (dragonResult.HasValue)
        {
            var dragon = dragonResult.Value;
            Debug.Log(dragon.name); // "The Dragon's Bane"
        }

        // --- Check existence without fetching the full struct ---
        bool exists = questDatabase.HasQuest("THE_LOST_PENDANT"); // true
    }
}

Accessing Objectives

Each quest has an objectives array of SimpleQuestObjective structs. Each objective has these fields:

Field	Type	Description
`code`	string	Unique code within the quest (e.g., "KILL_WOLVES")
`description`	string	Player-facing text (e.g., "Eliminate the wolf pack")
`isOptional`	bool	If true, this is a bonus objective — not required for quest completion
`targetCode`	string	What the player is interacting with (enemy code, item code, location, etc.)
`targetCount`	int	How many (kill 10, collect 3, visit 1)
`timeLimit`	float	Time limit in seconds (0 = no limit)
`sortOrder`	int	Display order within the quest
`categoryValues`	int[]	Objective-level category properties
`flagValues`	bool[]	Objective-level flag properties
`numericValues`	float[]	Objective-level numeric properties
`textValues`	string[]	Objective-level text properties

var quest = questDatabase.GetQuestByCode("THE_DRAGONS_BANE");
if (quest.HasValue)
{
    var objectives = quest.Value.objectives;

    // Access the first objective (index 0)
    Debug.Log(objectives[0].code);        // "SLAY_DRAGON"
    Debug.Log(objectives[0].description); // "Slay the Elder Dragon"
    Debug.Log(objectives[0].targetCode);  // "ELDER_DRAGON"
    Debug.Log(objectives[0].targetCount); // 1
    Debug.Log(objectives[0].isOptional);  // false
    Debug.Log(objectives[0].timeLimit);   // 0 (no time limit)

    // Access the second objective (index 1) - the optional bonus
    Debug.Log(objectives[1].code);        // "COLLECT_SCALES"
    Debug.Log(objectives[1].isOptional);  // true
    Debug.Log(objectives[1].targetCount); // 5

    // Access objective-level dynamic properties
    // If you defined an "Objective Type" category at objective-level:
    int objTypeIndex = objectives[0].GetCategoryValue(0);
}

Accessing Rewards

Each quest has a rewards array of SimpleQuestReward structs. Each reward has six fields:

Field	Type	Description
`code`	string	Unique code within the quest (e.g., "XP_REWARD")
`description`	string	Player-facing text (e.g., "5000 Experience Points")
`targetCode`	string	What is being rewarded (item code, currency code, faction code, etc.)
`amount`	float	Quantity (gold amount, XP amount, item count, etc.)
`isChoice`	bool	If true, this reward is part of a pick-one choice group
`choiceGroup`	int	Rewards sharing the same choiceGroup form a set where the player picks one

var quest = questDatabase.GetQuestByCode("THE_DRAGONS_BANE");
if (quest.HasValue)
{
    var rewards = quest.Value.rewards;

    // Non-choice reward (always granted)
    Debug.Log(rewards[0].code);        // "XP_REWARD"
    Debug.Log(rewards[0].description); // "5000 Experience Points"
    Debug.Log(rewards[0].targetCode);  // "XP"
    Debug.Log(rewards[0].amount);      // 5000
    Debug.Log(rewards[0].isChoice);    // false

    // Choice reward (player picks one from group 1)
    Debug.Log(rewards[1].code);        // "SWORD_CHOICE"
    Debug.Log(rewards[1].description); // "Dragon Slayer Sword"
    Debug.Log(rewards[1].targetCode);  // "DRAGON_SWORD"
    Debug.Log(rewards[1].isChoice);    // true
    Debug.Log(rewards[1].choiceGroup); // 1

    // Iterate and separate choice vs. guaranteed rewards
    foreach (var reward in rewards)
    {
        if (reward.isChoice)
            Debug.Log($"Choice (group {reward.choiceGroup}): {reward.description}");
        else
            Debug.Log($"Guaranteed: {reward.description} x{reward.amount}");
    }
}

Iterating All Quests

You can iterate through the entire database, query by category, or cross-reference by target code:

// Get all quest definitions
SimpleQuestDefinition[] allQuests = questDatabase.GetQuestDefinitions();

foreach (var quest in allQuests)
{
    Debug.Log($"{quest.code}: {quest.name}");
}

// Get all quest codes as strings
string[] codes = questDatabase.GetQuestCodes();

// Filter by category — e.g., get all "Kill Quest" type quests
// (assumes Quest Type is category index 0 and "Kill Quest" is entry index 0)
SimpleQuestDefinition[] killQuests = questDatabase.GetQuestsByCategory(0, 0);

// Filter by flag — e.g., get all repeatable quests
// (assumes "Is Repeatable" is flag index 0)
SimpleQuestDefinition[] repeatableQuests = questDatabase.GetQuestsByFlag(0, true);

// Filter by numeric range — e.g., quests for levels 10-20
// (assumes "Recommended Level" is numeric index 0)
SimpleQuestDefinition[] midLevelQuests = questDatabase.GetQuestsByNumericRange(0, 10f, 20f);

// Cross-reference — find all quests targeting a specific enemy
SimpleQuestDefinition[] dragonQuests = questDatabase.GetQuestsWithObjectiveTarget("ELDER_DRAGON");

// Cross-reference — find all quests that reward a specific item
SimpleQuestDefinition[] swordQuests = questDatabase.GetQuestsWithRewardTarget("DRAGON_SWORD");

// Prerequisite chain — find quests that require a specific quest to be completed
SimpleQuestDefinition[] sequels = questDatabase.GetQuestsRequiringQuest("WOLF_MENACE");

Accessing Quest-Level Dynamic Properties

var quest = questDatabase.GetQuestByCode("THE_DRAGONS_BANE");
if (quest.HasValue)
{
    var q = quest.Value;

    // Category value — returns the index of the selected entry
    // If "Quest Type" is category index 0, and "Boss Quest" is entry 2:
    int questTypeEntry = q.GetCategoryValue(0); // 2

    // To get the human-readable label, use the database metadata:
    string[] questTypeEntries = questDatabase.GetCategoryEntries(0);
    string questTypeName = questTypeEntries[questTypeEntry]; // "Boss Quest"

    // Flag value
    bool isRepeatable = q.GetFlagValue(0); // false

    // Numeric value
    float recommendedLevel = q.GetNumericValue(0); // 20

    // Text value
    string journalEntry = q.GetTextValue(0); // "A fearsome elder dragon..."

    // You can also query the property names from the database metadata:
    string[] categoryLabels = questDatabase.GetCategoryLabels();   // ["Quest Type", "Region", ...]
    string[] flagNames = questDatabase.GetFlagNames();              // ["Is Repeatable", "Is Hidden", ...]
    string[] numericNames = questDatabase.GetNumericNames();        // ["Recommended Level", "XP Reward", ...]
    string[] textNames = questDatabase.GetTextNames();              // ["Journal Entry", ...]
}

Track Quest Progress at Runtime

The SimpleQuestTracker class manages active quest state, objective progress, timed objectives, choice rewards, and save/load snapshots. It is a pure C# class (not a MonoBehaviour), so you instantiate it directly and call it from your own game systems.

Progress is reported using objective codes (the code field on each objective), not array indices. This means you can safely reorder objectives in the wizard without breaking your game code.

// Create a tracker with your database
// The optional valueProvider delegate resolves prerequisite checks
// (e.g., "PLAYER_LEVEL" returns the player's current level)
var tracker = new SimpleQuestTracker(questDatabase, targetCode =>
{
    if (targetCode == "PLAYER_LEVEL") return playerLevel;
    return 0f;
});

// Check if a quest can be started (exists, not active/completed, prerequisites met)
bool canStart = tracker.CanStartQuest("THE_DRAGONS_BANE");

// Start a quest
bool started = tracker.StartQuest("WOLF_MENACE");

// Report progress using the OBJECTIVE CODE (not an array index)
// The second parameter is the objective's code string
// The third parameter is the amount of progress to add (default: 1)
tracker.ReportProgress("WOLF_MENACE", "KILL_WOLVES", 1);  // +1 wolf killed
tracker.ReportProgress("WOLF_MENACE", "KILL_WOLVES", 3);  // +3 more wolves killed

// Check objective status
int progress = tracker.GetObjectiveProgress("WOLF_MENACE", "KILL_WOLVES"); // 4
SimpleObjectiveStatus status = tracker.GetObjectiveStatus("WOLF_MENACE", "KILL_WOLVES");

// Check if all required (non-optional) objectives are complete
bool allDone = tracker.IsQuestComplete("WOLF_MENACE");

// Complete the quest (moves it from active to completed)
if (allDone)
    tracker.CompleteQuest("WOLF_MENACE");

// Get completion percentage (0.0 to 1.0)
float percent = tracker.GetQuestProgress("WOLF_MENACE");

// For timed objectives, call UpdateTimers each frame
tracker.UpdateTimers(Time.deltaTime);
float remaining = tracker.GetObjectiveRemainingTime("TIMED_QUEST", "TIMED_OBJ");

// Listen for events
tracker.OnQuestCompleted += code => Debug.Log($"Quest complete: {code}");
tracker.OnObjectiveProgress += (quest, obj, count) =>
    Debug.Log($"{quest}/{obj}: {count}");
tracker.OnQuestReadyToComplete += code =>
    Debug.Log($"All required objectives done for: {code}");

// Handle choice rewards
tracker.SelectChoiceReward("THE_DRAGONS_BANE", 1, 1); // group 1, pick reward index 1
var rewards = tracker.ClaimRewards("THE_DRAGONS_BANE");

// Save and load state
SimpleQuestTrackerSnapshot snapshot = tracker.CreateSnapshot();
string json = JsonUtility.ToJson(snapshot);
// ... save json to disk or PlayerPrefs ...

// Later, restore:
var loaded = JsonUtility.FromJson<SimpleQuestTrackerSnapshot>(json);
tracker.RestoreFromSnapshot(loaded);

The Generated Custom Editor

Your database asset gets a professional custom Inspector that replaces Unity's default array editor. Instead of seeing "Element 0", "Element 1" with raw property arrays, you get a purpose-built editing experience designed for managing large quest databases efficiently.

Split-Panel Layout

The editor is divided into two panels. The left panel (approximately 280px wide) shows a scrollable list of all quests with their codes and names. Clicking a quest in the list selects it and displays its full details in the right panel, which takes up the remaining width. This lets you quickly browse through quests without losing context.

Search, Sort, and Filter

Search — type in the search bar to filter quests by name or code. The search is case-insensitive and matches partial strings, so typing "dragon" will find "The Dragon's Bane".
Sort — sort the list by Name A-Z, Name Z-A, Code A-Z, or Code Z-A.
Category filter — if you defined categories like "Quest Type", a dropdown appears that lets you show only Kill Quests, only Boss Quests, only Fetch Quests, etc.

Quest Detail Panel

When a quest is selected, the right panel shows all of its data in organized, collapsible sections:

Identity — code, name, description (scrollable text area), and icon field
Objectives — a foldout section with each objective showing its code, description, targetCode, targetCount, timeLimit, isOptional toggle, sortOrder, and all objective-level dynamic properties
Rewards — a foldout section with each reward showing code, description, targetCode, amount, isChoice toggle, and choiceGroup
Prerequisites — a foldout section with each prerequisite showing targetCode, comparison operator dropdown, and threshold value
Quest-level properties — Categories (dropdown selection), Flags (toggle checkboxes), Numerics (float/int fields), and Texts (text areas), all labeled with the names you defined

Bulk Operations

The editor includes several bulk operations accessible from the toolbar area:

Select All / Deselect All — toggle checkboxes on all visible quests
Delete Selected — remove multiple quests at once
Duplicate — clone a quest with a new code
Open Quest Forge Wizard — jump back to the wizard for structural changes

Pagination

For databases with many quests, the editor provides pagination controls at the bottom of the left panel. By default, "Show All" is enabled so small databases display everything. For larger databases (50+ quests), you can toggle pagination on and set the page size. This keeps the Inspector responsive even with hundreds of quests.

No more "Element 0", "Element 1" in the Inspector. Every property shows its real name, every objective and reward is clearly labeled, and you can search, sort, and filter to find exactly what you need.

What's Next

The Quest Forge wizard is just the beginning. Simple Quest Forge provides a natural progression of tools that build on your quest database, taking you from individual quests to full narrative systems and procedural content generation.

The Recommended Path

1 Quest Forge (you are here)
Create your quest database with objectives, rewards, prerequisites, and dynamic properties. This is the foundation everything else depends on.

2 Quest Chain Forge
Group your quests into multi-step storylines. Define ordered steps with required/optional flags and branch groups for non-linear narratives. A quest chain references quests from your database by code, so you can reorganize chains without modifying the quests themselves.
Quest Chain Forge Guide →

3 Procedural Quest Forge
Design quest templates with variable slots (enemy types, locations, reward amounts) and generate unlimited unique quests at runtime. The procedural system uses your quest-level and objective-level property definitions to ensure generated quests match your schema.
Procedural Quest Forge Guide →

4 Runtime Tracking
Use SimpleQuestTracker for state management (active/completed/failed), objective progress reporting, timed objectives, choice reward selection, event callbacks, and save/load snapshots via SimpleQuestTrackerSnapshot.
Runtime API Guide →

Additional Resources

AI-Powered Content

Export your schema, paste it into ChatGPT or Claude, describe the quests you want, and import hundreds of quests in one click. The AI workflow supports Full JSON, Light JSON, and Markdown export formats, plus a JSON import with a 3-choice dialog for handling conflicts.

AI Workflow →

Genre Templates

Start from one of six pre-built templates (Generic RPG, Open World, MMO, Survival, Narrative RPG, Roguelike) that provide curated property definitions, example quests, and procedural templates tuned for specific game genres.

Templates →

Integration Bridges

If you have Simple Enemy Forge, Simple Item Forge, or Simple Attribute Forge installed, SQF detects them automatically and provides smart dropdowns for enemy target codes, item reward linking, faction references, and attribute modifiers.

Integration →

Interactive Demo

Generate a complete demo scene with a 5-tab interactive quest browser. Explore quests, chains, procedural generation, and runtime tracking in action with the Black+Teal themed UI.

Demo Scene →

Congratulations! You now have a fully functional quest database with type-safe enum access, a generated custom Inspector, and the knowledge to access your data from code. The quests you define here are the foundation for quest chains, procedural generation, and runtime tracking — everything in Simple Quest Forge builds on this database.

← Installation Quest Forge Guide →