Scenario Studio

Scenario Studio is an authoring suite that lets instructional designers build branching, evidence-driven training simulations — the kind you usually can’t build in Articulate or H5P without writing code — and ship them to any SCORM-compliant LMS.

In daily use. Feature-complete through Phase 14.4. A full four-act demo course (~4 hours of content) authored inside the tool and SCORM-tested against SCORM Cloud.

The problem

Mainstream e-learning tools top out at shallow branching: click an avatar, pick from three answers, get a score. They can’t model the thing that actually matters in workplace judgement training — do I have enough evidence yet, and is it the right kind?

• Articulate Storyline / Rise — linear with light branching; no state, no persistent consequences.
• H5P Branching Scenario — branching trees, but no systems (no inventory of evidence, no trust state, no mini-games).
• Custom Unity / Unreal builds — powerful, but require a full dev team for every course. Instructional designers get locked out of authoring.

The gap: a tool that’s authorable by an instructional designer, runtime-rich enough for serious games, and deliverable through any LMS via SCORM.

The solution

A Godot 4 project with two halves.

The runtime — a serious-game engine for scenario-based learning

A playable scenario is composed from Godot Resources (.tres data files), driven by a small set of engine systems:

• Dialog engine — line-by-line speaker/portrait UI with branching choices, document overlays, and auto-advance nodes.
• Scenario state machine — global ScenarioRunner autoload tracks the current node, character trust (-10..+10), memory flags, evidence cards, scored choices.
• Evidence board — a persistent corkboard-style UI collecting colour-coded cards (Green = verified, Yellow = unverified, Red = disputed) as the player plays. Cards carry through acts.
• Finding builder — a validated card-selection UI. The player drafts audit findings by picking cards from the board. Findings are scored on reliability + keyword coverage, not just “right answer chosen” — so picking only Yellow cards triggers an “Audit Risk” warning in-game.
• Mini-game framework — a MiniGameBase contract (setup(config) + completed(score, metadata) signal). Every mini-game is a self-contained scene droppable into any dialog node.
• Context map — a corkboard-and-red-string investigation board for navigating between acts, with a campaign end screen (stars, per-act score breakdown, verdict copy driven by authored thresholds).
• SCORM 1.2 bridge — on scenario_ended, converts the fractional score to 0–100, writes cmi.core.score.raw, sets lesson_status to passed / failed against an authored threshold. One-click HTML5 + SCORM zip export.

The authoring suite — a MainScreen plugin for Godot

A full editor plugin (addons/scenario_editor/) that replaces .tres text-editing with form-based UI:

• Campaign tab — title / subtitle, ordered location list with map positions and prerequisites, per-campaign scoring config.
• Scenario tab — a visual graph editor built on Godot’s GraphEdit. Nodes colour-coded by role; drag-to-connect routing; BFS auto-layout; node positions persisted in the resource’s metadata.
• Characters tab — form editor with drop-zone portrait, auto-slugged internal IDs, trust / memory-flag config.
• Minigames tab — bespoke editors per mini-game type: file-explorer tree, log-file editor, spreadsheet-style ticket grid, org-chart parent-dropdown editor.
• Findings tab — template editor for FindingTemplateData (keywords, min / max cards, feedback copy per outcome band) and EvidenceTriggerData (per-choice card emission).
• New Scenario wizard — creates a playable stub from shipped templates in one click.
• Welcome modal + coach marks — a data-driven 8-step tour with a dim overlay and hole-cut highlight, re-queried per frame so UI reflows don’t break the tour.

The demo course — The Alpha Audit

Ships with the engine as an optional example (examples/alpha_audit/). A full four-act internal-audit training scenario:

1. The File — skills assessment via a file-explorer laptop sim.
2. The Incidents — incident triage via a filterable ticket system and a command-line terminal emulator.
3. The Structure — organisational analysis via an interactive org chart.
4. The Recommendation — synthesis and staffing judgement.

Every act ends in a scored choice plus a finding-builder exercise. Trust and evidence cards carry across acts. The designed-in trap: Ana, your colleague, pushes conclusions that the evidence doesn’t support — the learning is in resisting her without dismissing her.

The scenario was designed and authored using the same tool it validates. Every data shape, every mini-game, every scoring rule was stress-tested by authoring four hours of real training content.

Why it’s interesting

As instructional design

• Evidence-first scoring. Most scored e-learning scores choices. This scores the quality of the evidence chain behind a choice. Learners who pick the right answer for the wrong reasons get partial credit; learners who cite disputed sources get flagged.
• Persistent state across acts. Trust and evidence carry through the full experience. Rushing Act 1 costs you in Act 3 when you can’t defend your finding.
• Authorable by the designer. No dev handoff required to change a line of dialogue, re-route a branch, or re-tune a scoring threshold.

As engineering

• Data-driven end to end. Every piece of content is a Godot Resource; the runtime has zero scenario-specific code. The same executable plays Alpha Audit, a compliance scenario, or a clinical-judgement scenario.
• Plugin architecture, not a fork of the editor. The authoring tool is a real Godot EditorPlugin with MainScreen tab and Inspector integration — same tooling as a first-party editor extension.
• LMS-deliverable by default. HTML5 export with a patched imsmanifest.xml and bundled SCORM API wrapper produces a zip that drops into SCORM Cloud, Moodle, TalentLMS, or any compliant LMS. Tested end-to-end.

As a product bet

This is the tool I would have wanted for the last ten years of instructional-design work. It sits between no-code author (too shallow) and custom game studio build (too expensive) — a zone every L&D team with a serious training problem ends up in, and currently has no good tool for.

Tech

• Engine — Godot 4.x (2D, GL Compatibility renderer, HTML5 export)
• Language — GDScript (strict-typed)
• Data — Godot Resources (.tres) — diffable, version-controllable, Inspector-editable
• Delivery — SCORM 1.2 (via a vendored, patched SCORM plugin)
• Authoring — Custom Godot EditorPlugin (MainScreen + Inspector integration)
• Dev loop — Claude Code + GDAI MCP bridge, driving the Godot editor directly over HTTP for scene/script scaffolding

Status

Engine and authoring suite feature-complete through Phase 14.4. Full four-act demo course authored and playable end-to-end. SCORM export tested against SCORM Cloud. Currently polishing one-click SCORM packaging and user-facing documentation.