Easy Chapter Generator – Linear Chapters & Objectives

Easy Chapter Generator is a visual authoring and runtime system for building deterministic linear progression in Unity.

Create Chapters, organize Ordered Objectives, configure lifecycle actions and events, connect optional Scene Objective Components, validate your setup, and control the complete progression flow from the Editor or C#.

Build progression without building the framework first

Easy Chapter Generator separates progression from gameplay logic:

• The Chapter Manager coordinates the active Chapter, transitions, failure handling and progression state.
• Each Chapter contains an ordered sequence of Objectives.
• Each Ordered Objective stores its identity, conditions, lifecycle actions and state.
• Optional Scene Objective Components can detect gameplay interactions and request completion of the linked Objective.
• Your own systems remain in control of dialogue, inventory, UI, movement, combat, cameras and other gameplay-specific behaviour.

This makes the system suitable for adventures, escape rooms, training simulations, story-driven experiences, guided sequences, interactive applications and other projects that need predictable linear progression.

Visual workflow for designers

Most progression can be authored directly from the Chapter & Objectives window:

• Create and reorder Chapters.
• Create and reorder Objectives.
• Configure conditions and delays.
• Activate or deactivate GameObjects on start or completion.
• Trigger UnityEvents.
• Link scene interactions without manually managing IDs.
• Validate broken links, duplicate bindings and incomplete configurations.
• Navigate quickly between Chapters, Objectives and linked scene components.
• Use Undo/Redo throughout the authoring workflow.

Extensible for programmers

The visual workflow does not lock you into predefined behaviours.

Use the public runtime API to query or control progression, listen to lifecycle events, trigger failure, manage scene transitions or integrate the system with your own gameplay architecture.

You can also create your own Objective components by deriving from the included Objective base class and requesting completion when your custom gameplay condition is met.

Included Objective components cover common use cases such as:

• Trigger-based completion
• Button interactions
• Timed Objectives
• Object destruction
• Object placement
• Multi-action conditions
• Walk-to destinations
• External/code-driven completion

Deterministic runtime progression

Easy Chapter Generator maintains a predictable execution model:

1. A Chapter becomes active.
2. The first eligible Ordered Objective becomes active.
3. The Objective completes, skips, or fails according to your logic.
4. The next eligible Objective starts automatically.
5. The Chapter completes only when its progression is finished.
6. Optional completion transitions can continue the experience in another scene or Chapter.

Repeated completion requests are handled safely and the current Chapter and Objective can be queried at runtime.

Failure handling without hidden behaviour

Failure is explicit and under your control.

Call the Failure API when your game decides that the current experience has failed. Easy Chapter Generator updates the progression state and emits both C# and UnityEvent notifications.

It does not automatically reload scenes, restore checkpoints or decide how your game should recover. You decide whether failure should show a death screen, restart the Chapter, reload a scene, update statistics or trigger another custom response.

Progress State Persistence

The package includes lightweight progression persistence with a replaceable storage backend.

It is designed to preserve progression state — not to replace your complete save-game system.

The default implementation uses PlayerPrefs, while the public persistence interface allows projects to provide their own storage implementation.

Scene transitions and handoff

Chapter completion can transition between scenes while preserving the intended destination Chapter or Objective.

The handoff system ensures that a scene reload or transition resumes at the configured progression point instead of falling back to the default Chapter.

Built-in validation

Authoring mistakes are surfaced before they become runtime bugs.

Validation detects issues such as:

• Missing or invalid identifiers
• Duplicate Scene Objective bindings
• Components linked to the wrong Chapter
• Missing scene components
• Incomplete Objective configuration
• Invalid references

Warnings and errors are shown directly in the authoring workflow so they can be corrected without manually searching the hierarchy.

Documentation and Demo

Easy Chapter Generator includes:

• A complete playable Demo for the Built-in Render Pipeline
• English and Spanish documentation
• Quick-start tutorials
• Runtime flow documentation
• Component reference
• C# examples
• Custom Objective tutorials
• Failure and persistence guides
• Troubleshooting and support documentation

Documentation is also available online:

https://overfuture.dev/easychaptergenerator/

Render Pipeline Compatibility
The included Demo is authored for the Built-in Render Pipeline. The core Easy Chapter Generator runtime and Editor tooling do not use render-pipeline-specific APIs, but the Demo materials are not intended for URP or HDRP. Developers using URP or HDRP can use the core Chapter and Objective system with their own project scenes and materials.

Designed to stay out of your way

Easy Chapter Generator focuses on one job: reliable Chapter and Objective progression.

It does not try to replace your dialogue system, inventory, character controller, quest framework or complete save-game architecture. Instead, it provides a clean progression layer that those systems can connect to through UnityEvents, public APIs and lightweight adapters.