AI Prompts for a Card-Based Narrative Game: From Rules to a Build Plan

Write AI prompts for a card-based narrative game that connect story decisions through a card interface to working gameplay.

Seele Editorial TeamUpdated November 17, 2026

A card-based narrative game works when a card changes what the story can do next. A hand might offer a clue, a relationship move, or a risky action, while earlier choices set flags that change later dialogue. The player should understand both the immediate cost and the future branch before committing.

The cards, characters, setting, and outcomes below are fictional. The prompt examples are unrun drafts; this package does not claim a playable build or tested story branch.

A fictional narrative card game places illustrated story cards beside a lantern-lit platform scene where a character faces a branching choice.
Let story art, card actions, and the next scene point to the same decision.

Define the card and story loop

Start with one chapter, a small hand, and a single resource. The fictional loop here is: enter a scene, read its situation, choose one card, pay its focus cost, update a story flag, then open the next scene. This lets you check whether the card interface and branching narrative describe the same action.

Decide what belongs to the deck and what belongs to the story map. A card stores its action, cost, and condition. A scene stores its text, available responses, and next-scene links. Story state stores persistent facts such as whether the protagonist has earned someone's trust or raised an alarm. Keeping these records separate makes later chapters easier to change.

ElementFictional ruleVisible question
HandThree cards drawn for a sceneWhich actions are available now?
FocusStarts at 2Can the player afford this card?
CardOne played per sceneWhat changes when it resolves?
Flag`trust` or `alarm` persistsWhich earlier choice matters later?
Scene linkConditions route to a next sceneWhy did the story branch?

Connect card actions to story state

Write each card in a consistent format: name, cost, playable condition, immediate effect, and any persistent flag. For the example deck, Listen costs zero and reveals a clue. Reassure costs one focus and sets `trust=1`. Press costs zero and sets `alarm=1`. These effects are fictional game rules, not general advice about real conversations.

When the player selects a card, validate the cost first. If focus is too low, the card stays unavailable and the interface explains why. If the action resolves, update focus and story flags once, then show what changed. Do not let a card spend focus twice because the hand and scene both process the click.

A fictional narrative card interface connects three action cards to focus tokens, a trust flag, an alarm flag, and conditional scene paths.
Keep the card effect, resource cost, and later scene condition visible together.

A simple data shape can make the logic easier to inspect:

{
  "cardId": "reassure",
  "focusCost": 1,
  "requires": [],
  "effects": [{ "type": "setFlag", "key": "trust", "value": true }],
  "nextScene": "lantern-platform-after-choice"
}

Keep dialogue and prose outside the state transition where practical. That way an edit to a line does not accidentally remove the trust update. A conditional response should name the flag it checks and the fallback text if the flag is absent.

Trace one branch through three scenes

Use one fictional route to check that the card action persists. The opening scene gives the player Listen, Reassure, and Press. Listen costs no focus and reveals a map clue. Reassure spends one focus and sets trust. The Lantern Platform scene then offers a “share the map” response only when trust is true. The final scene changes one line based on whether alarm was raised.

SceneActionResource and flag stateNext story beat
Opening archivePlay ListenFocus stays 2; clue revealedLantern Platform appears
Lantern PlatformPlay ReassureFocus becomes 1; trust=trueShare-the-map response is available
Final crossingResolve the trust conditionTrust remains true; alarm remains falseUse the cooperative ending text

This is a hand-traced fictional path, not an observed game result. Test the alternate route too: if Press is played, set alarm=true and confirm that the final scene uses the changed text. If the route is locked, show the missing condition instead of removing the scene without explanation.

Record prompt runs and branch checks

Stage prompts so each one preserves the previous rules. First request the chapter loop and resource. Next add the three cards and their effects. Then add conditional scene links and a visible flag ledger. Finish by asking for a readability pass that preserves the branch logic.

Build a compact fictional card-based narrative prototype with one chapter, three scenes, a three-card hand, and 2 focus. One card may be played per scene. Listen costs 0 and reveals a clue; Reassure costs 1 and sets trust=true; Press costs 0 and sets alarm=true. In the Lantern Platform scene, offer a share-the-map response only if trust=true. In the final scene, show different text if alarm=true. Display focus before and after a card, and show which flag unlocked each response. Do not add deck-building progression or extra chapters yet.

These prompts are drafts, not tested executions. When you run them, save the exact text, date, tool, output version, and any correction. Distinguish a written branch map from a mockup and from a playable branch that you actually exercised.

SEELE's official AI Game Maker page describes creating a game from text, testing a browser-playable result, and refining it. That is broad workflow context only; the prompts here have not been run and no result is attributed to SEELE.

  • Cost check: Reassure changes focus from 2 to 1 exactly once.
  • Flag check: Reassure sets trust; Press sets alarm; Listen changes neither.
  • Branch check: the share-the-map response appears only when trust is true.
  • Fallback check: the final scene has readable text when neither flag is set.
  • Evidence check: record a real run before calling the branch playable or tested.
A fictional card-based story reaches a lantern platform where a character can share a map with an ally after a trust-building choice.
Close a prompt stage by checking that the earlier card changes a later scene.

Once a short chapter behaves predictably, add new cards only when they create a distinct choice. Keep the deck, flags, and scene map small enough to review together. That makes it easier to see whether a new card adds a meaningful branch or merely another line of text.

Card-based narrative prompt FAQs

How many cards should I start with?

Three is enough to compare a clue, relationship, and risk action. Add more only after costs, effects, and scene consequences are clear.

How should a card affect later scenes?

Store a named story flag or resource change, then make the later scene condition visible. Show the player why an option appears or remains locked.

What should happen when a card costs more focus than I have?

Keep it unavailable and explain the shortfall. Do not subtract below zero or silently play a different card.

How do I prevent a story branch from disappearing?

Give each condition a fallback path and test both the true and false cases. Keep scene IDs and flag names explicit in your notes.

Can I call these prompts tested?

Only after running them and inspecting the output. These examples are unrun drafts, and no playable result is claimed.

Make your own card-based narrative game

Begin with one chapter, a small hand, and a flag that visibly changes a later response. Then add the next card that creates a distinct consequence. For a general starting point, explore the SEELE AI Game Maker and adapt this unrun prompt sequence to your own story prototype.

SEELE AI

Turn this guide into a playable build.

Start with a focused brief, then iterate in the Seele AI Workspace.

Start creating