Write AI Prompts for a Relationship RPG

Write AI prompts for a relationship RPG that link character needs to Trust and group support. Map a harbor conversation loop and future build checks.

Seele Editorial TeamUpdated November 17, 2026

Frame one social loop

In a relationship RPG, dialogue matters when a conversation changes what the player can do or what happens later. A line that only changes the next line of text can still be expressive, but a first prototype needs a legible link between choice and consequence. Start with one character, one request, a small set of responses and a later moment that uses the relationship state.

This guide uses a fictional concept called Harborlight. The player helps three residents prepare a community beacon-lighting in a single harbor square. Mara needs practical help repairing the beacon rope. Iven wants someone to listen to his concern about the confusing bell schedule. Sella asks for a clear, bounded plan for raising the lantern. Each conversation offers the same three actions: Listen, Help or Promise.

Harborlight is a design example, not an existing or tested game. Its rules, characters and outcomes are authored here to show how to write a prompt contract. The prompts have not been run, and no playable result or playtest is included. The images are fictional game concepts, not screenshots or evidence of product output.

A player character meets three harbor residents beside an unlit beacon at dusk.
The proposed loop begins with a shared local goal: residents must work together to light the beacon.

Keep the scope contained. The first version has no exploration map, collectible memories, combat, romance system, gifts inventory or branching quest chain. That boundary also separates this prompt library from the related exploration blueprint How to Make a Relationship RPG with Exploration Driven by Collecting Lost Memories Using AI. Here, the central question is how a small social choice changes Trust and later support at one event.

Before asking for dialogue, list each relationship variable, its range, its initial value and the rule that changes it. Make the request visible before showing choices. When a response does not match the request, define what happens rather than letting the game invent a hidden penalty.

Give Trust a clear job

Track Trust separately for Mara, Iven and Sella. Each starts at 1 on an integer scale from 0 to 3. In the first version, a matching response adds one point up to the cap; a different response leaves Trust unchanged and records an unresolved concern. Trust does not fall below zero or rise above three. Restart returns each person to 1 and clears the concern flags.

Here “matching” has a fixed meaning. It is not a judgment made from a hidden personality model. Mara values practical help, so Help matches her request. Iven asks to be heard, so Listen matches. Sella asks for a clear plan, so Promise matches. This makes the rule easy to explain, trace and later inspect in a future build.

ResidentVisible requestMatching actionState change on match
Mara, rope-makerHelp repair the beacon ropeHelpTrust +1; concern clears
Iven, bell-keeperListen to why the schedule confuses himListenTrust +1; concern clears
Sella, lantern-riggerAgree on a bounded raising planPromiseTrust +1; concern clears

For any mismatch, Trust stays where it is and the character's unresolvedConcern flag becomes true. The conversation should show the chosen response and the state result before advancing. A later version could use more nuanced relationship changes, but the first prompt should not ask for nuance before it specifies the basic state transition.

This is a simple deterministic relationship model. It does not claim that people can be reduced to a score; it gives a prototype a consistent rule to test. If the score is displayed, it should not imply a level of emotional certainty that the design does not contain. A short response such as “Iven still has a concern to discuss” is more informative than adding a second hidden meter.

Resolve a social choice

Present each resident's request first, then offer exactly three actions. The player selects one. The game compares that action with the resident's matching action, clamps Trust to the 0–3 range, updates the concern flag and shows the result. Only then does it open the next conversation. This order keeps the choice understandable and makes the state change auditable.

A player character pauses to listen to a harbor resident beside a simple three-choice dialogue panel.
A conversation can make the response options visible while keeping the character's request in context.

Consider Iven. He says that the bell schedule is difficult to follow and asks the player to hear his concern. Listen is the matching action. If the player chooses it, Trust rises from 1 to 2 and the concern clears. Help or Promise leaves Trust at 1 and sets unresolvedConcern to true. No response causes an immediate game over or an invented loss of points.

Write down the before-and-after values rather than relying on adjectives such as “closer” or “upset.” A compact trace might say: “Iven: Trust 1; request to be heard; chose Listen; match; Trust 2; unresolvedConcern false.” The game could later add expressive dialogue, but the rule is already precise without needing to infer sentiment from generated prose.

Do not make every action correct for every resident. If all three options raise Trust, the player is not making a meaningful social choice. Conversely, avoid punishing every nonmatching option in the first pass; a neutral mismatch is easier to distinguish from a relationship break. One clear positive match and one defined nonmatch give the design room to grow after the core loop is stable.

Connect relationships to the ending

Trust needs a downstream job. At the beacon event, count the residents whose Trust is at least 2. Each qualifying resident supplies a defined form of support: Mara secures the rope, Iven coordinates the bell signal and Sella guides the lantern lift. If at least two residents qualify, show the Collaborative Beacon Lighting ending. With zero or one, show Solo Lighting. The ending depends only on current Trust at the event; it uses no hidden flags, random rolls or unstated story score.

Conversation choicesTrust at eventSupport countAuthored ending
Help Mara, Listen to Iven, Promise Sella2, 2, 23Collaborative Beacon Lighting
Help Mara, Promise to Iven, Promise Sella2, 1, 22Collaborative Beacon Lighting
Listen to Mara, Help Iven, Listen to Sella1, 1, 10Solo Lighting

The second trace shows why a single mismatch need not erase the whole story: two residents still offer help. The third shows the alternative outcome. These are hand-calculated examples of the proposed rules, not observed results. A future implementation should make the support count and ending label visible enough to check that the relationship values really drive the event.

Two harbor residents help the player light the community beacon after building trust.
The group ending turns relationship state into visible support at the shared event.

Separate eligibility from flavor. Trust at 2 or higher determines whether a resident helps; the character's role determines how they help. That division prevents a later rewrite of dialogue from accidentally changing the mechanical threshold. It also makes it easier to add a fourth resident later without rewriting the whole event rule.

Write the prompt sequence in stages

Use six prompts to build the prototype one responsibility at a time. The drafts below are written for the fictional Harborlight concept. They have not been submitted or run. If a later prompt changes the earlier state rules, revise the rule contract before adding more scenes.

Prompt 1 — frame one social loop

Create a small single-player relationship RPG called Harborlight. The player helps three residents prepare a community beacon-lighting in one harbor square. Keep version one to three short conversations and one event. Do not add exploration, collectible memories, combat, romance meters, inventory gifts, a map, or a branching quest chain. Show one clear player choice per conversation and make its effect on a relationship state visible in the next event.

Prompt 2 — set Trust state

Track Trust separately for Mara, Iven, and Sella. Each starts at 1 on a 0–3 integer scale. Trust cannot go below 0 or above 3. Store one unresolvedConcern flag per character. A Restart resets all three Trust values to 1, clears all flags, and returns to the first conversation. Do not change a score merely because dialogue text appears.

Prompt 3 — make each need visible

Mara asks for practical help repairing the beacon rope; Iven says he wants someone to listen to why the bell schedule is confusing; Sella asks for a clear, bounded plan for raising the lantern. Present each request before showing choices. Keep their needs visible, distinct, and understandable without hidden affinity rules. Use original characters and concise dialogue.

Prompt 4 — resolve the three response actions

For each conversation, offer exactly three actions: Listen, Help, and Promise. Mara's matching action is Help, Iven's is Listen, and Sella's is Promise. A matching action adds 1 Trust up to the cap of 3 and clears that character's unresolvedConcern. A mismatch leaves Trust unchanged and sets unresolvedConcern true. Do not decrease Trust in this first version. Show the selected response and resulting state before moving on.

Prompt 5 — connect Trust to the event

At the beacon event, count residents with Trust at 2 or higher. Each qualifying resident supplies their own support. If at least two qualify, show the Collaborative Beacon Lighting ending; otherwise show Solo Lighting. Display who helps and why. The ending must be determined only by Trust values at the event, not by hidden choices or random rolls. Then show a clear Restart option.

Prompt 6 — prepare future checks

For a future playable build, log each resident's initial Trust, request, chosen action, match result, new Trust and unresolvedConcern flag. Check the 0–3 clamp, exact action mapping, mismatch behavior, support threshold and both endings. Check that Restart restores all three values to 1 and clears flags. Do not say these checks passed unless an actual build is inspected; return the checks as a plan only.

These prompts specify one fixed action per character, a bounded score and a downstream event. If a future tool changes Iven's score after Help, restate the matching-action table instead of rewriting all of the dialogue. If the ending fails to change when two residents reach the threshold, ask for a state trace showing all three Trust values and the ending gate.

For general prompt-to-game workflow context, SEELE describes starting with a plain-English idea, generating a playable first version, testing it in a browser and refining it with follow-up prompts on its Free AI game maker page. That page describes the general workflow; it does not verify Harborlight, these relationships or any generated result. Free AI game maker is a place to explore a game concept. Review any resulting behavior directly before treating it as implemented or tested.

Plan what to check in a future build

When a playable version is available, record the starting value, resident request, selected response, match result, new Trust and concern flag for each conversation. Then test values at the range limits and check that the ending counts residents at the threshold, rather than adding their points together or relying on an old flag.

Future checkExpected behavior in this designEvidence to capture later
Starting stateThree Trust values begin at 1; flags are clearInitial state screen or readable state log
Matching actionOnly the resident's mapped response adds 1, capped at 3Request, action, match, before/after values
Nonmatching actionTrust remains unchanged and concern becomes trueSelected action and resulting flag
Ending gateTwo or more residents at Trust 2+ produce the collaborative endingThree Trust values, support count and ending
RestartTrust returns to 1 and concern flags clearState before and after Restart

These are plans for evidence, not completed tests. No prompt in this article has been run, and no playable Harborlight build is presented. The official product page describes a general prompt-to-game workflow; it does not promise this design's social state or ending. Treat the prompt drafts as a starting specification, then inspect the result if you build it.

Frequently asked questions

What should an AI prompt define for a relationship RPG?

Define the relationship variable, its starting value and range, which choices change it, and what later dialogue or event uses the result.

How can a relationship stat affect gameplay?

Tie a clear threshold to a later action or outcome. In this fictional example, residents at Trust 2 or higher offer support at the beacon event.

Should every dialogue choice change trust?

No. State which response fits each character's request and what other choices do. Harborlight leaves Trust unchanged on a mismatch and records an unresolved concern.

How many characters belong in a first relationship RPG prototype?

Start with a few characters whose requests and consequences are easy to trace. This example uses three residents and one conversation with each.

Were these relationship RPG prompts tested in a playable build?

No. Harborlight and its trust rules are fictional design material. The prompt drafts are unrun; no playable build or observed test result is included.

SEELE AI

Turn this guide into a playable build.

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

Start creating