Demo Scene

Simple Quest Forge includes an interactive demo scene that showcases all quest features at runtime. The demo mirrors the pattern used by Simple Enemy Forge's Bestiary Demo — a generator creates a complete UI canvas with multiple tabs, and a runtime MonoBehaviour drives the interactive features.

The demo is designed as a self-contained data browser. Once generated, you can enter Play Mode and explore every quest, chain, and procedural template in your databases without writing a single line of code. It also doubles as a live reference for how to use the runtime API classes like SimpleQuestTracker, SimpleQuestChainTracker, SimpleQuestHelper, and SimpleProceduralQuestGenerator in your own projects.

Prerequisites

Before generating the demo scene, make sure the following requirements are met:

TextMeshPro package — The demo UI is built entirely with TextMeshPro components (TMP_Text, TMP_InputField, TMP_Dropdown). TextMeshPro is included by default in Unity 2019.4 and later. If you are prompted to import TMP Essentials when entering Play Mode, accept the import and re-enter Play Mode. Without TextMeshPro, the demo will not compile.
At least one generated Quest Forge database — You need a fully generated Quest Forge database (the .asset file, not just the wizard data). Run the Quest Forge Wizard through all 5 steps and click Generate. Wait for compilation to finish and confirm the .asset file appears in your output folder.
Quest Chain database (optional) — If you also generate a Quest Chain database, the Chains tab will be populated with your chain data. Without it, the Chains tab will appear but display no content.
Procedural Quest database (optional) — If you also generate a Procedural Quest database, the Procedural tab will let you browse templates and generate random quest instances on the fly. Without it, the Procedural tab will appear but display no content.

Tip: For the full demo experience, generate all three database types. Use one of the built-in genre templates (RPG, Action, Horror, Visual Novel, Simulation, Strategy) to quickly populate a Quest Forge database, then build chains and procedural templates referencing those quests.

Generating the Demo

1 Generate your databases first
Create at least a Quest Forge database using one of the wizard templates. Optionally, also generate a Quest Chain database and a Procedural Quest database for the full demo experience. Make sure each wizard completes both generation phases (script compilation + asset creation) before proceeding.

2 Open the demo generator
Navigate to Window → Simple Quest Forge → Generate Quest Demo. This opens the QuestDemoGenerator window, which provides database assignment slots and a Generate button.

3 Assign databases
The generator window shows array slots for quest databases, chain databases, and procedural databases. Drag your generated .asset files into the appropriate slots. You can assign multiple databases of each type — the demo will merge them and display all entries across all assigned databases.

4 Generate
Click Generate to create the demo canvas in your scene. The generator creates all UI elements (panels, scroll views, buttons, text fields, tab bar), wires up references, and attaches the QuestDemo MonoBehaviour with all database references pre-assigned. The entire canvas hierarchy appears under a root GameObject named "QuestDemoCanvas".

Demo Tabs

The demo features 5 interactive tabs, each demonstrating a different aspect of the quest system. Switch between tabs using the teal-highlighted tab buttons along the top of the canvas.

Quests Tab

The Quests tab is the primary data browser. On the left panel (32% width) you see a scrollable list of all quests from every assigned database, each showing its icon (if assigned) and display name. A search field at the top filters quests by name or code in real time. A category dropdown lets you filter by any category defined in your schema (e.g., Quest Type, Difficulty).

Selecting a quest populates the right detail panel (68% width) with the full quest data: code, name, description, icon preview, all objectives (with target codes, required counts, and objective-level dynamic properties), all rewards (with item codes, quantities, and reward-level properties), prerequisites, and every dynamic property value at the quest level — categories, flags, numerics, and texts, each labeled with their schema-defined names.

Chains Tab

The Chains tab displays quest chain data. The left panel lists all chains by name. Selecting a chain shows its ordered sequence of steps in the right panel. Each step displays its linked quest code (resolved to a name when possible), whether it is required or optional, and its branch group assignment with color coding. Steps within the same branch group share a color, making it easy to visualize parallel branches. The overall chain structure — linear progression with optional branching points — is presented as a vertical timeline, giving you an at-a-glance view of chain flow.

Procedural Tab

The Procedural tab lets you browse procedural quest templates and generate random quest instances in real time. The left panel lists all templates. Selecting a template shows its configuration: the title and description patterns with {variable} tokens, all defined variables (TextList with their option pools, NumericRange with their min/max bounds), and objective/reward templates.

Click the GENERATE button to produce a random quest instance from the selected template. The generated result appears below, showing every token resolved to a concrete value: the final title, description, objective targets and counts, reward quantities — all with their random selections highlighted so you can see exactly which values were chosen.

Tracker Tab

The Tracker tab is an interactive demo of SimpleQuestTracker in action. You see a list of available quests that can be started. Click a quest to start tracking it, which moves it into the "Active" section. Each active quest shows its objectives with current/required progress counters and + / - buttons to increment or decrement progress. A real-time completion percentage bar updates as you modify progress. When all objectives reach their required counts, the quest automatically moves to "Completed".

The tab also demonstrates save/load snapshots: click Save to capture the current tracker state, then modify progress or complete quests, then click Load to restore the saved snapshot. This shows how SimpleQuestTracker's serialization works for save systems.

Helper Tab

The Helper tab demonstrates the utility methods in SimpleQuestHelper. It provides interactive buttons for each helper function: Check Prerequisites evaluates whether a selected quest's prerequisites are met given the current tracker state. Group Rewards shows all rewards for a quest organized by type. Find by Target searches across all quests for objectives that reference a specific target code (useful for "which quests involve this enemy?" queries). Find Dependents shows which quests list the selected quest as a prerequisite. Traverse Prerequisites walks the full prerequisite chain recursively, displaying the complete dependency tree.

Setup Instructions

After generating the demo:

The demo canvas is added to the currently open scene as a root-level GameObject
A QuestDemo MonoBehaviour is attached with database references pre-assigned
Enter Play Mode to interact with the demo — the UI is not functional in Edit Mode
Use the tab buttons at the top to switch between views
The Back button in the top-left corner destroys the demo canvas (useful for testing in your own scene without leaving Play Mode)
If you regenerate your databases with different schemas, regenerate the demo as well to pick up the changes

Layout: 1920x1080 target resolution with CanvasScaler using Scale With Screen Size. Split panels: 32% list / 68% detail, matching SEF's Bestiary Demo layout. The canvas uses a reference resolution of 1920x1080 and will scale proportionally on other resolutions.

Demo Architecture

The demo is built from exactly two C# files, following the same pattern established by Simple Enemy Forge's Bestiary Demo:

QuestDemoGenerator.cs (Editor)

Location: Editor/Demo/QuestDemoGenerator.cs

This is a static editor class that creates the entire demo UI programmatically. It is accessed via the menu item Window → Simple Quest Forge → Generate Quest Demo. When you click Generate, this class:

Creates a root Canvas with CanvasScaler (Scale With Screen Size, 1920x1080 reference)
Builds the tab bar with 5 tab buttons (Quests, Chains, Procedural, Tracker, Helper)
Creates 5 tab content panels, each with their own layout of scroll views, text fields, buttons, and list items
Builds prefab-style elements for list entries, detail panels, and interactive controls
Attaches a QuestDemo MonoBehaviour to the root and assigns all UI references and database arrays
Applies the Black + Teal color scheme to all UI elements

This file lives in an Editor folder and is stripped from builds automatically. It only runs in the Unity Editor and has no runtime cost.

QuestDemo.cs (Runtime)

Location: Runtime/Demo/QuestDemo.cs

This is the runtime MonoBehaviour that drives all interactive behavior. It holds arrays for each database type (ScriptableObject[] questDatabases, ScriptableObject[] chainDatabases, ScriptableObject[] proceduralDatabases) and caches their interfaces (ISimpleQuestDataSource, ISimpleQuestChainDataSource, ISimpleProceduralQuestDataSource) on Awake().

At runtime, QuestDemo manages:

Tab switching (showing/hiding content panels)
Quest list population with search filtering and category dropdown filtering
Detail panel updates when a quest, chain, or template is selected
Procedural quest generation via SimpleProceduralQuestGenerator
Quest tracking state via SimpleQuestTracker (start, progress, complete, save, load)
Helper queries via SimpleQuestHelper (prerequisites, rewards, cross-references)
Back button cleanup (destroys the canvas GameObject)

Color Scheme

The demo uses the SQF documentation color scheme:

Background: Black (#121212)
Primary: Teal (#2CA5A5)
Secondary: Light Teal (#4DB8B8)
Panel backgrounds: Dark grey (#1A1A1A)

This matches SEF's Bestiary Demo pattern (which uses Black + Crimson Red) but with the SQF teal color scheme for visual distinction. Active tab buttons and selected list items are highlighted in teal, while inactive elements use muted greys.

Tips

Run in Play Mode

The demo UI is completely inert in Edit Mode. All interactivity — tab switching, list selection, search filtering, quest tracking, procedural generation — only works when you enter Play Mode. If the canvas appears but nothing responds to clicks, make sure you are in Play Mode.

Use 1920x1080 Game View

The demo is designed for a 1920x1080 resolution. In the Game view, set the aspect ratio to "1920x1080" (or "Full HD") from the resolution dropdown for the best layout. The CanvasScaler will adapt to other resolutions, but text sizes and panel proportions are optimized for 1920x1080.

Back Button Destroys Canvas

Clicking the Back button in the top-left corner calls Destroy() on the entire demo canvas. This is intentional — it lets you test the demo in your own scene without leaving Play Mode. If you accidentally click Back, simply exit and re-enter Play Mode (the canvas GameObject is still in the scene hierarchy, it is only destroyed at runtime).

Safe to Regenerate

You can regenerate the demo as many times as you like. Each generation replaces the previous demo canvas in the scene. If you have regenerated your quest databases with a different schema or different quests, regenerate the demo to pick up the new data. The generator does not modify any of your database assets — it only reads from them.