Add a Hub That Makes Every New Run Feel Earned

Plan a between-mission upgrade hub for an existing survivors-like game. Separate run rewards, lasting unlocks, hub choices, and safe regression checks.

Seele Editorial TeamUpdated November 16, 2026

A between-mission hub can make each run feel connected, but it also introduces a new boundary: when does a run end, when is its reward claimed, and which upgrades survive the next start? Treat those as separate state transitions before adding menus or currencies. The safest expansion is one complete-run-to-hub-to-new-run loop that reuses the existing progression owner.

A fictional arena survivor returns to a lantern-lit workshop hub between runs to choose a permanent upgrade.
The Lantern Workshop is an invented teaching scenario, not a tested game.

This guide assumes an existing survivors-like project with a run loop and some form of progression. The courier, workshop, rewards, and choices are fictional. Adapt the design to your actual project; no project or build was tested.

Separate run state from meta progression

Write down what resets when a run ends and what remains after a new run starts. A temporary weapon level, health pickup, and enemy wave belong to the current run. A purchased starting item or character unlock might persist. Currency can be tricky: is it awarded once at run completion, spent in the hub, or both? If the same value serves two roles, name the transitions precisely.

StateTypical lifetimeQuestion for the existing project
Run rewardUntil claimed after completionCan a reload or repeated visit claim it twice?
Run buildCurrent mission onlyWhich powers reset at the next start?
Hub purchaseAcross runs if intendedWhich system owns the durable unlock?
Unspent currencyDesign-dependentDoes it persist, expire, or remain attached to a run?

In the fictional Lantern Workshop, a completed run produces a claimable reward, one purchase unlocks a starting tool, and temporary combat upgrades reset. These are example rules, not facts about a real game. State boundaries help prevent a hub from accidentally carrying a full previous build into a new mission.

Design one complete hub loop

Trace the sequence from the last wave to the next start: the run ends, the result becomes final, the reward is calculated, the player enters the hub, choices are shown, a purchase is confirmed, and a new run receives its starting state. At each transition, identify the system that owns the data and what happens if the player closes the game or returns to a previous screen.

A fictional upgrade hub shows a run token moving to a choice board while permanent unlocks remain on a wall ledger.
Keep this-run rewards, hub choices, and lasting unlocks visually and structurally distinct.

Do not let the hub compute rewards in one script while the results screen independently grants the same reward. Prefer one completion event with a stable run identifier, then route it through the progression owner. If the same run is reopened, the system should know whether its reward was already claimed. This is a design requirement to verify, not an assertion about any particular codebase.

MomentState changeFailure to watch for
Run completionFinalize score and eligible rewardReward recalculated on every hub entry
ClaimMark the run reward as claimed onceDuplicate currency after reload
PurchaseSpend currency and add durable unlockCurrency deducted but unlock not stored
New runBuild a fresh run from meta stateTemporary upgrades leak into the next run

Showing the previous run’s summary in the hub can help a player decide. Keep that record separate from the state used to initialize the next mission. If the game supports abandonment, retries, or multiple save slots, define whether each path reaches the same reward claim and purchase rules.

Extend the existing progression owner

Before implementation, locate where currency, unlocks, run completion, and save data are currently handled. Reuse existing identifiers and reset functions. A second meta-progression manager can create a split brain: the hub says an item is unlocked while the run initializer still reads a different inventory.

Ask AI to inspect the flow first and propose the smallest patch. A useful request names what must stay unchanged: wave pacing, combat controls, run end conditions, existing reward formulas, save slots, and restart behavior. Require a list of files, data fields, migration assumptions, and rollback steps before approving code changes. Review the actual diff instead of trusting a summary.

SEELE’s current capability catalog describes turning a game idea into a starting point and lists playable game categories. That can help explore a separate survivors-like concept or communicate a hub idea. It does not establish that SEELE edits an existing repository or migrates its save data, so use the project’s own tools for the integration.

Protect existing saves and restart behavior

Use a duplicate save to inspect what happens when the new hub fields are missing. A safe default might preserve the current unlocks and initialize a new collection empty, but the correct rule depends on the project. Decide how to handle partial runs, unclaimed rewards, already-purchased items, and currency balances before changing the schema.

Godot’s stable docs describe user:// as a writable user-data location and show file-based save examples. They also demonstrate identifying persistent data and serializing it. That supports where and how a project might store data, not which hub fields should persist. Follow the existing save system and confirm the current engine version and target platforms.

Write a short migration note: old and new schema versions, added fields, fallback values, and behavior if the data cannot be read. Keep one untouched save copy for comparison. Do not use generated hub art or a mock menu as proof that old player data loads correctly.

Test the hub as a state machine

Start with a vertical slice and record build, save version, run identifier, actions, expected result, and observed result. The important questions are about transitions: does completion happen once, does a purchase survive, and does the next run start cleanly? The following matrix is a proposed test plan, not executed results.

ScenarioActionExpected observation
Normal completionFinish a run and enter the hubOne final reward appears
Repeated visitLeave and reopen the result or hubThe same run is not rewarded twice
PurchaseSpend currency on one unlockCost and unlock update together
New runStart again after purchaseDurable choice applies; temporary build resets
ReloadClose and reload after claimingClaim and purchase states remain coherent
Old saveLoad a duplicate from before the changeFallback preserves a playable progression path
The fictional courier leaves the workshop for a new arena run with one selected tool and the hub ledger visible behind.
Illustrative transition only; validate the actual new-run state in the game build.

If a test fails, identify the transition where state diverges: reward creation, claim, purchase, persistence, or run initialization. That narrows the repair and makes rollback easier. Keep the old flow available until the replacement passes the project’s real regression checks.

Frequently asked questions

What should a between-mission upgrade hub do?

Give players a clear place to convert a completed run into a limited set of choices, inspect persistent unlocks, and start the next run. Keep optional collection, permanent progression, and this-run rewards visibly distinct. The hub should reuse the game's existing progression owner and reset rules.

Which upgrades should persist between runs?

Persist only choices the design intends to survive a new run, such as a purchased starting tool or an unlocked character option. Temporary power-ups should reset with the run. Define whether currencies, difficulty modifiers, and unspent tokens persist before building the hub interface.

How do I avoid duplicate rewards when adding a hub?

Make run completion a single event and route its reward through the current progression owner. Record whether that run has already been claimed before adding currency. Test repeated hub visits, reloads, and interrupted transitions so a retry does not grant the same reward twice.

Where should persistent upgrade data be saved in Godot?

Godot’s stable documentation describes user:// as a writable user-data location and provides file-based save examples. Confirm your current engine version and platform, and follow the existing project’s save layer. That reference does not determine which upgrades your game should persist.

How can I test a new upgrade hub without risking player saves?

Use a copied save and record the current build and save version. Test a completed run, one purchase, leaving and re-entering the hub, a fresh run, a reload, and an older save. Keep the old progression flow available for comparison until the new path behaves as intended.

Make the hub serve the next run

Keep the upgrade screen connected to one clear contract: finalize a run, claim its reward once, present durable choices, and initialize the next run from the resulting progression state. Verify repeat visits, reloads, purchases, and older saves before extending the pattern to more currencies or hub features.

To sketch a separate playable concept around this loop, try SEELE AI Game Maker. This is a prototype starting point, not an existing-project editor.

Sources

SEELE AI

Turn this guide into a playable build.

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

Start creating