Build Your Quest System
Stop hand-coding quest databases and writing boilerplate ScriptableObject editors. Simple Quest Forge gives you 3 interconnected wizard tools that generate production-ready databases with custom editors, type-safe enums, runtime tracking, and AI-assisted content generation — all from a guided, step-by-step interface inside the Unity Editor.
Whether you are building an RPG with hundreds of hand-crafted quests, a roguelike with procedurally generated objectives, or a narrative adventure with branching quest chains, Simple Quest Forge handles the infrastructure so you can focus on game design.
Why Simple Quest Forge?
FREE
Completely free on the Unity Asset Store. No hidden tiers, no premium upgrades, no paywalls. The full package — all 3 forges, all runtime components, all templates — is yours at zero cost.
Two-Level Properties
The only quest system with dynamic properties at both quest-level AND objective-level. Define Categories, Flags, Numerics, and Texts independently for quests and their objectives — giving you unmatched flexibility without touching code.
AI-First Design
Schema export in 3 formats (Full JSON, Light JSON, Markdown) with embedded AI instructions for bulk content generation. Export your schema, hand it to ChatGPT or Claude, and import hundreds of quests back into your database in seconds.
63 C# Files
12 Runtime + 51 Editor scripts — a complete, production-ready package. Not a prototype or a starter kit. Every wizard, every generated editor, every runtime tracker is battle-tested and ready for your shipping game.
Zero Dependencies
Works standalone out of the box. Optional companion integrations with Simple Enemy Forge, Simple Item Forge, and Simple Attribute Forge are handled via safe reflection bridges — install or remove companions at any time with zero compile errors.
Runtime Complete
Quest tracking, chain progression, procedural generation, and helper utilities are all included.
Drop SimpleQuestTracker on a GameObject and you have quest state management, objective
progress, timers, events, and save/load snapshots working immediately.
The Three Forges
Quest Forge
The core wizard. 5 steps guide you through building a quest database: Setup, Definitions, Quests, Settings, and Generate. Define two-level dynamic properties (quest-level AND objective-level), build quests with nested objectives (targetCode, targetCount, timeLimit), rewards with choice groups (same group = player picks one), and prerequisites with comparison operators. Full bridge integration provides enemy, item, faction, and attribute code dropdowns when companion forges are installed.
Learn more →Quest Chain Forge
Group quests into ordered storylines. 5 steps: Setup, Definitions, Chains, Settings, and Generate. Each chain contains ordered steps that reference quest codes with sortOrder, isRequired, and branchGroup — steps sharing the same string-based branch group represent a player choice (complete any one to advance). Links directly to your Quest Forge databases for code validation and dropdown selection. Single-level dynamic properties on chains.
Learn more →Procedural Quest Forge
Design templates that generate unlimited unique quests at runtime. 5 steps: Setup,
Definitions, Templates, Settings, and Generate. Define variable slots with 3 types —
NumericRange (random int/float in range), TextList (random pick from list),
and Custom (you provide the value) — then use {VARIABLE} tokens
in names, descriptions, objectives, and rewards. At runtime,
SimpleProceduralQuestGenerator resolves all tokens and returns a
SimpleGeneratedQuest ready for tracking.
Utility Windows
Two standalone editor windows provide cross-database inspection and visualization:
Quest Browser
A multi-database quest browser accessible from Window > Simple Quest Forge > Quest Browser. Search across all generated quest databases simultaneously, filter by properties, and inspect full quest details including objectives, rewards, prerequisites, and dynamic property values — all in a read-only split-panel interface.
Quest Dependencies
A prerequisite relationship visualizer at Window > Simple Quest Forge > Quest Dependencies. See which quests unlock which — view the full dependency graph showing prerequisite chains, identify bottleneck quests that gate multiple paths, and verify your quest progression flow is correct before shipping.
What Gets Generated
Each forge generates a complete, self-contained system of 4 files:
1. Type-Safe Enum
{Prefix}Type.cs — Strongly-typed identifiers for compile-time safety. Reference quests like
MyQuestType.KILL_THE_DRAGON instead of magic strings. One enum entry per quest, chain,
or template code.
2. Database ScriptableObject
{Prefix}Database.cs — All your data in a single ScriptableObject implementing
the full data source interface (ISimpleQuestDataSource, ISimpleQuestChainDataSource,
or ISimpleProceduralQuestDataSource) for runtime access. Metadata arrays store your
property definitions alongside the entries.
3. Custom Inspector Editor
{Prefix}DatabaseEditor.cs — A professional custom Inspector generated alongside
your database. Split-panel layout, search, sort, filter, multi-select, bulk operations, and pagination
— all built in. Edit your quest data directly in the Inspector with the same quality as the wizard.
4. Asset File
{Prefix}Database.asset — The actual ScriptableObject asset containing all your quest data.
Drag it into any MonoBehaviour field, reference it in your game managers, or query it via the
data source interface at runtime.
AssetDatabase.Refresh() and domain reload. After recompilation, an
[InitializeOnLoad] handler fires via delayCall to create the asset
from a temporary JSON file. This ensures the generated types exist before the asset is created,
preventing serialization errors.
Runtime Components
Simple Quest Forge ships with 4 runtime classes that handle quest state, chain progression, procedural generation, and common query operations:
SimpleQuestHelper
Static utility class. Common query operations across quest databases — find quests by code, check prerequisites against player state, filter by property values, and validate quest data. No MonoBehaviour needed; call static methods from anywhere.
SimpleQuestTracker
MonoBehaviour. Manages quest state for a single player: accept, advance, complete, fail, and abandon quests. Tracks objective progress with counts and timers. Fires C# events on state changes. Supports save/load via serializable snapshots for integration with any save system.
SimpleQuestChainTracker
MonoBehaviour. Manages chain progression. Tracks which step the player is on, handles branch group resolution (player choice between steps), auto-advances when required quests complete, and coordinates with SimpleQuestTracker for seamless quest-to-chain integration.
SimpleProceduralQuestGenerator
Static generator. Takes a procedural template database and resolves all
{VARIABLE} tokens at runtime, producing a SimpleGeneratedQuest with
concrete names, descriptions, objectives, and rewards. Supports batch generation, DB-linked
variable pools, and seed-based deterministic output.
Getting Started
Go from zero to a working quest system in 5 steps:
Import Simple Quest Forge from the Unity Asset Store. No setup required — the package is self-contained with zero external dependencies.
Create your first quest database in under 5 minutes. The Quick Start walks you through defining properties, adding quests, and generating your database with a custom editor.
Learn every step of all 3 forge wizards. Understand two-level properties, objectives, rewards, prerequisites, chain branching, and procedural variables.
Export your schema in Full JSON, Light JSON, or Markdown format. Each export includes embedded instructions that tell AI exactly how to generate valid quest data. Import the results with a single click.
Drop SimpleQuestTracker and SimpleQuestChainTracker onto GameObjects. Accept quests, advance objectives, complete chains, and save/load player progress — all with clean C# events and serializable snapshots.
Interconnected Ecosystem
All three forges work together, and integrate with the wider Forge ecosystem via safe reflection bridges. Install or remove companion tools at any time — your project always compiles cleanly:
Each bridge uses runtime reflection (Type.GetType()) to detect companion tools.
No assembly references, no #if directives, no conditional compilation. When a companion
is installed, its codes appear in dropdowns automatically. When removed, the fields gracefully
degrade to plain string inputs.