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.

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.
| State | Typical lifetime | Question for the existing project |
|---|---|---|
| Run reward | Until claimed after completion | Can a reload or repeated visit claim it twice? |
| Run build | Current mission only | Which powers reset at the next start? |
| Hub purchase | Across runs if intended | Which system owns the durable unlock? |
| Unspent currency | Design-dependent | Does 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.

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.
| Moment | State change | Failure to watch for |
|---|---|---|
| Run completion | Finalize score and eligible reward | Reward recalculated on every hub entry |
| Claim | Mark the run reward as claimed once | Duplicate currency after reload |
| Purchase | Spend currency and add durable unlock | Currency deducted but unlock not stored |
| New run | Build a fresh run from meta state | Temporary 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.
| Scenario | Action | Expected observation |
|---|---|---|
| Normal completion | Finish a run and enter the hub | One final reward appears |
| Repeated visit | Leave and reopen the result or hub | The same run is not rewarded twice |
| Purchase | Spend currency on one unlock | Cost and unlock update together |
| New run | Start again after purchase | Durable choice applies; temporary build resets |
| Reload | Close and reload after claiming | Claim and purchase states remain coherent |
| Old save | Load a duplicate from before the change | Fallback preserves a playable progression path |

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.


