About Simple Quest Forge

Simple Quest Forge is a free Unity Editor tool for creating ScriptableObject-based quest databases using a wizard-driven workflow. It follows the same proven architecture as Simple Enemy Forge and Simple Item Forge — dynamic property systems, two-phase code generation, schema export/import for AI-assisted content creation, and optional integration bridges via safe reflection.

Whether you're building a small indie RPG or a large-scale MMO, Simple Quest Forge adapts to your game's needs. You define the properties that matter to your game (there are no hardcoded "XP Reward" or "Quest Type" fields), and the tool generates production-ready code and data assets from your design.

Design Philosophy

Two-Level Properties

The Quest Forge defines dynamic properties at both quest-level AND objective-level. No other forge tool in the ecosystem uses two-level properties — this is unique to SQF and enables unprecedented flexibility. A quest can have "Region" and "Difficulty" while each of its objectives independently tracks "Objective Type" and "XP Multiplier".

Dynamic, Not Hardcoded

There are no built-in "XP Reward" or "Quest Type" fields. You define your own property schema using four property types: Categories (dropdowns), Flags (booleans), Numerics (numbers), and Texts (strings). An MMO might need "Reputation Gain" and "Token Reward". A narrative RPG might need "Morality Shift" and "Companion Affinity". Your game, your properties, your rules.

Three Tools, One Ecosystem

Quest Forge defines individual quests with objectives, rewards, and prerequisites. Quest Chain Forge groups them into ordered storylines with branching paths. Procedural Quest Forge generates unlimited variations at runtime from template definitions. Together they cover hand-authored content, narrative structure, and emergent gameplay — all from the same property system.

AI-First Content Pipeline

All three wizards support schema export in 3 formats (Full JSON, Light JSON, Markdown) with detailed AI instructions embedded in the export. Define your schema once, let AI generate hundreds of quests, chains, and procedural templates. Import the output with automatic validation and 3-choice conflict resolution (Replace All, Add to Existing, Cancel).

Zero-Dependency Bridges

Integration with Simple Enemy Forge, Simple Item Forge, and Simple Attribute Forge uses pure reflection — no hard assembly references, no conditional compilation. Install a companion package and dropdowns automatically appear. Remove it and everything still compiles with zero errors. Your data is always preserved.

Complete Runtime Solution

Not just an editor tool — SQF ships with full runtime tracking (SimpleQuestTracker, SimpleQuestChainTracker), a static helper library (SimpleQuestHelper), and a procedural generator (SimpleProceduralQuestGenerator). Save/load snapshots, fire events on quest completion, evaluate prerequisites, and generate quests from templates — all included.

The Forge Ecosystem

Three wizard tools, two utility windows, and four runtime components:

Wizard Tools

Wizard	Steps	Purpose	Properties
Quest Forge	5	Define quests with objectives, rewards, prerequisites, and bridge integration	Two-level (quest + objective)
Quest Chain Forge	5	Group quests into ordered chains with steps, branches, and sortOrder	Single-level (chain only)
Procedural Quest Forge	5	Design templates with variables for unlimited runtime quest generation	Single-level (template only)

Editor Utility Windows

Window	Purpose
Quest Browser	Browse and search across all generated quest databases. Multi-database viewer with filtering, sorting, and quest detail inspection.
Quest Dependencies	Visualize prerequisite relationships between quests. Shows which quests unlock which, and identifies circular dependency chains.

Runtime Components

Component	Type	Purpose
SimpleQuestHelper	Static class	Pure utility functions: prerequisite checks, reward grouping, objective sorting, cross-reference queries, prerequisite chain traversal
SimpleQuestTracker	MonoBehaviour	Quest state management: activation, objective progress, timers, completion/failure events, save/load via JSON snapshots
SimpleQuestChainTracker	MonoBehaviour	Chain progression: step completion, branch choices, sync with quest tracker, save/load
SimpleProceduralQuestGenerator	Static class	Generate concrete quest instances from procedural templates with variable resolution, batch generation, and external pool support

What Gets Generated

Each forge generates 3 C# files and 1 asset file. All files are self-contained and ready for production use:

File	Description
`{Prefix}Type.cs`	A C# enum with one entry per quest/chain/template code. Gives you compile-time safety and IDE autocomplete instead of error-prone magic strings.
`{Prefix}Database.cs`	A ScriptableObject implementing the appropriate data source interface (`ISimpleQuestDataSource`, `ISimpleQuestChainDataSource`, or `ISimpleProceduralQuestDataSource`). Contains all data, metadata arrays for property definitions, and accessor methods.
`{Prefix}DatabaseEditor.cs`	A custom Inspector editor with split-panel layout, search, sort, category filter, pagination, nested ReorderableLists for sub-entries (objectives, rewards, prerequisites, steps, variables), and bulk operations. No more "Element 0", "Element 1" in the Inspector.
`{Prefix}Database.asset`	The ScriptableObject data file, created in phase 2 of the two-phase generation process.

Two-Phase Generation: Phase 1 writes .cs files and triggers AssetDatabase.Refresh(), causing a domain reload. Phase 2 runs automatically via [InitializeOnLoad] after recompilation, reading wizard data from a temporary JSON file and populating the ScriptableObject asset. This ensures generated types are fully compiled before data is written.

Companion Products

Simple Quest Forge is part of the Living Failure Games forge ecosystem. Each product is sold separately on the Unity Asset Store and integrates via safe reflection bridges — no hard dependencies, no conditional compilation, no risk of breaking your project:

Simple Enemy Forge (SEF)

7 interconnected wizards for enemy databases: Enemy, Squad, Spawn, Scaling, Wave, Behavior, and Faction Forge. Provides enemy codes for kill objectives, faction codes for reputation rewards, and squad codes for group objectives in SQF.

Simple Item Forge (SIF)

Wizard-driven item databases with loot tables, crafting recipes, and dynamic properties. Provides item codes for collect objectives and item rewards, plus loot table codes for loot-based rewards in SQF.

Simple Attribute Forge (SAF)

Attribute system with modifiers, runtime attribute management, and influence systems. Provides attribute names for stat prerequisites (e.g., "Requires STR >= 20") and modifier ScriptableObject assets for quest rewards in SQF.

All integrations are optional. Simple Quest Forge works perfectly standalone. Install companion packages to unlock dropdown menus, code pickers, and additional features. Remove them at any time with zero compilation errors. Your data is always preserved — target codes stored as strings survive package removal and restoration.

Version History

v1.0.0 — Initial Release

3 Forge Wizards — Quest Forge (5 steps, two-level properties), Quest Chain Forge (5 steps, branch groups), Procedural Quest Forge (5 steps, variable system)
Two-Level Dynamic Properties — Quest-level and Objective-level Categories, Flags, Numerics, Texts — unique to SQF in the Forge ecosystem
Two-Phase Generation — Scripts + domain reload + asset creation for all 3 forges
Generated Custom Editors — Split-panel Inspectors with search, sort, filter, pagination, nested objectives/rewards/prerequisites/steps/variables
Schema Export/Import — Full JSON, Light JSON, Markdown for all 3 forges with embedded AI instructions and 3-choice conflict resolution on import
6 Genre Templates — Generic RPG, Open World, MMO, Survival, Narrative RPG, Roguelike (both Quest Forge and Procedural Quest Forge)
4 Runtime Components — SimpleQuestHelper, SimpleQuestTracker, SimpleQuestChainTracker, SimpleProceduralQuestGenerator
4 Integration Bridges — SEFBridge, SIFBridge, SAFBridge, SDFBridge (stub)
Quest Browser Window — Multi-database quest browser with search and filtering
Quest Dependency Window — Prerequisite relationship visualizer
Interactive Demo Scene — 5-tab runtime demo with quest tracking, chain progression, procedural generation, and helper utility showcase
63 C# files — 12 Runtime + 51 Editor

Support

Self-Help Resources

Troubleshooting Guide — Solutions for common generation, import, wizard, editor, bridge, and runtime issues
Runtime API Reference — Complete documentation for all runtime components, data source interfaces, and struct definitions
Quick Start Guide — Create your first quest database in under 5 minutes with step-by-step instructions
Integration Guide — How bridges work, what each companion package adds, and the safe round-trip lifecycle

Get in Touch

Unity Asset Store — Leave a review or ask questions on the Simple Quest Forge Asset Store page
Email — Contact the developer at livingfailuregames@gmail.com
Website — livingfailuregames.com

Response time: We aim to respond to all support emails within 48 hours. When reporting issues, please include your Unity version, the steps to reproduce, and any Console error messages prefixed with [Simple Quest Forge].