new-content-qfg

name	new-content-qfg
description	Guided content creation for the QFG adventure game. Use when the user wants to add a new room, quest, NPC, puzzle, or story element. Triggered by /new-content-qfg or when the user describes a content idea like "I want a forest clearing with a witch" or "add a new area to the game".

New Content — Quest for Glory

Orchestrate the creation of game content through a creative interview, then build everything silently using existing skills and agents. The user is a creative director — they provide ideas and feedback, not technical details.

RULES

• Never expose technical details to the user. No file paths, no GDScript, no scene tree terminology. Speak in game/story terms only.
• One question at a time during the interview. Use AskUserQuestion with multiple-choice options wherever possible.
• The user's initial idea is the seed — expand on it, don't override it.
• Adaptive interview — skip questions that are already answered by the user's initial description. 3-5 questions max.
• Silent build phase — once the creative brief is approved, build everything without asking further questions. Use parallel agents where possible.
• Always end with a playable result — the user should be able to run make run and experience what was built.

---

PHASE 1: INTERVIEW

The user provides an initial idea (e.g., "a haunted library with a ghost librarian"). Parse it for any details already given (setting, characters, mood, puzzle hints), then ask only what's missing.

Questions to ask (skip if already answered):

1. Mood & atmosphere

"What feeling should this area give the player?" Options: Cozy & safe / Mysterious & eerie / Dangerous & tense / Humorous & quirky / (Other)

2. Key characters

"Who does the player meet here?" Options based on context. For each NPC, ask: "What's [name]'s personality in a few words?" Options: Friendly & helpful / Grumpy & suspicious / Mysterious & cryptic / Comedic & eccentric / (Other)

3. Puzzle or challenge

"What should the player need to figure out here?" Options: An inventory puzzle (use item on something) / A skill check (stat-gated challenge) / A dialogue puzzle (say the right thing) / Pure exploration, no puzzle / (Other)

4. Class flavor

"Should Fighter, Mage, and Thief have different experiences here?" Options: Yes, different paths for each / Minor flavor differences in dialogue / No, same experience for all classes

5. Connections

"How does the player get here?" Options: Connected to an existing room (specify which) / New area accessible from the world map / Standalone for now (connect later) / (Other)

6. Scope (ask only if unclear)

"How big is this?" Options: A single room / A small area (2-3 connected rooms) / A quest chain (3-5 rooms with a story arc)

---

PHASE 2: CREATIVE BRIEF

Compile all answers into a creative brief. Present it to the user in plain language:

## [Area/Quest Name]

**Setting:** [One paragraph describing the place]
**Mood:** [Atmosphere in a sentence]

**Characters:**
- [NPC name] — [personality, role, what they want]

**What happens here:**
- [Player experience from entry to completion]
- [Puzzle/challenge description in player terms]
- [Class-specific variations if any]

**Connects to:** [Which existing room/area, or standalone]

Ask: "Does this capture what you had in mind? Anything you'd change?"

If the user wants changes, update the brief and re-present. Once approved, move to Phase 3.

---

PHASE 3: BUILD

Do not ask the user any questions during this phase. Build everything silently.

Step 1: Plan the assets needed

From the creative brief, determine:

• How many rooms (each needs: background art, scene, script, hotspots)
• How many NPCs (each needs: sprite art, character scene, Dialogic character, timeline)
• What Dialogic events are needed (stat checks, inventory events, class gates)
• What items are needed (inventory icons, item definitions)
• Room connections and entry points

Step 2: Generate art assets

For each room background:

• Invoke the art-gen skill to create an Aseprite Lua script
• Background must be 320x176, use the shared palette
• Run make backgrounds to export

For each NPC:

• Invoke the art-gen skill to create sprite with idle + talk animations
• Sprites are 24x32 or 32x32, shared palette
• Run make sprites to export

For each inventory item:

• Invoke the art-gen skill to create 16x16 icon
• Run make ui to export

Step 3: Build rooms

For each room:

• Invoke the new-room skill
• Create the scene with background, walkable area, hotspots, NPC containers
• Write room script with interaction handlers for all hotspots
• Register in RoomManager with entry points and transitions to connected rooms

Step 4: Build NPCs

For each NPC:

• Invoke the new-npc skill
• Create character scene with exported sprite
• Create Dialogic character file
• Write Dialogic timeline(s) incorporating:
  • Personality from the creative brief
  • Any stat checks ([stat_check] events)
  • Any inventory exchanges ([give_item] events)
  • Any class-gated dialogue ([class_gate] events)
  • Skill growth where narratively appropriate ([skill_growth] events)
• Place NPC in the correct room scene

Step 5: Wire up puzzles

For inventory puzzles:

• Add items to ItemDatabase resource
• Write hotspot interaction handlers for "use item on target"
• Add pickup interactions in room scripts

For stat-check puzzles:

• Add [stat_check] events in Dialogic timelines
• Write success/failure branches
• Add [skill_growth] on successful checks

For class-specific paths:

• Add [class_gate] events in timelines
• Create alternative hotspot interactions or dialogue branches per class

Step 6: Write tests for new content

Every new room MUST have a corresponding test file. This is non-negotiable.

For each new room, create game/test/unit/test_room_<room_name>.gd following the project's GUT conventions:

Required test coverage for rooms:

• Scene structure: Background (Sprite2D with texture at 160,100), WalkableArea (NavigationRegion2D with polygon), Hotspots container, NPCs container, EntryPoints container
• Entry points: default marker exists + all named entry points from connected rooms
• Hotspots: each hotspot exists, has correct hotspot_name, has a CollisionShape2D with a shape
• Door hotspots: is_door == true, correct door_target_room path, correct door_entry_point
• Non-door hotspots: verify is_pickupable, is_door, look_text properties are set correctly
• Hotspot state: get_state() returns expected defaults
• Bidirectional connections: door targets match entry points in connected rooms

Required test coverage for NPCs:

• NPC hotspot exists with correct hotspot_name
• dialogue_timeline is set and points to a valid .dtl file
• NPC has a sprite or visual representation

Required test coverage for puzzles:

• Pickupable items: is_pickupable == true, pickup_item_id is set
• Stat checks: timeline contains [stat_check] with correct parameters (verify via file read)

After writing tests, run make test and ensure ALL tests pass (not just the new ones).

Step 7: Quality assurance

Run these agents (in parallel where possible):

• art-verifier agent — validate all exported assets have correct dimensions
• gdscript-reviewer agent — review all new GDScript files for Godot 4.4 correctness and project conventions

Fix any issues found before proceeding.

Step 8: Final verification

• Run make art to ensure all assets are exported
• Run make test to ensure all tests pass
• Run make run to verify the game launches

---

PHASE 4: DELIVERY

Tell the user what was created in game terms only (no technical details):

Your [area name] is ready!

**What's new:**
- [Room name] — [one-line description of the place]
- [NPC name] — [what they do / their role]
- [Puzzle/interaction] — [what the player can do]

**How to experience it:**
Run `make run`, then [how to get there from existing game — e.g., "go through the north door in the tavern"].

**Tip:** [Any gameplay hint, e.g., "Try talking to the librarian as a Mage for a different reaction"]

---

ERROR HANDLING

• If a skill fails (art generation, room creation, etc.), do not surface the error to the user. Diagnose and fix it, or use a placeholder and note what needs manual attention.
• If the game won't launch after building, debug silently. Only tell the user if you genuinely cannot resolve it — and frame it in game terms ("The room has a layout issue I need to sort out").
• If an asset fails verification, regenerate it. Don't ask the user about dimensions or file formats.

---

EXAMPLE SESSION

User: /new-content-qfg A spooky graveyard where a ghost needs help finding peace

Claude: "What feeling should this area give the player?" → User picks: Mysterious & eerie

Claude: "The ghost — what's their personality?" → User picks: Mysterious & cryptic

Claude: "What should the player need to figure out here?" → User picks: An inventory puzzle

Claude: "Should Fighter, Mage, and Thief have different experiences here?" → User picks: Minor flavor differences in dialogue

Claude: Creative brief:

The Old Graveyard — A fog-shrouded cemetery at the edge of town. Crumbling headstones lean at odd angles, and pale light flickers between the graves. The ghost of a former scholar drifts among the stones, unable to rest...

→ User approves

Claude: [Silently builds: graveyard background, ghost NPC sprite, room scene, Dialogic timeline with class-flavored dialogue, inventory puzzle with a burial token item, stat check for perception, unit tests for room structure and connections...]

Claude: "Your Old Graveyard is ready! Run make run and head through the east gate in the town square. Tip: Look carefully at the headstones — one of them has something useful."