An extraction shooter progression system has to preserve the meaning of “extract.” If every run grants the same permanent rewards regardless of outcome, the risk may disappear. If a save boundary fires twice, the stash may duplicate cargo. Before adding a progression layer, define which state belongs to the profile, the current raid, the stash, and a resolved outcome.

This guide uses an invented prototype to make the decisions concrete. No project, build, extraction, or playtest is represented. The goal is a narrow plan an AI assistant can implement in the existing game without replacing the raid loop.
Separate profile, stash, raid, and outcome state
Start with four buckets. Profile state might include reputation or permanent unlocks. Stash state contains secured items between raids. Raid state includes the current objective, carried cargo, and temporary damage. Outcome state records whether the raid extracted, failed, or was abandoned. Keep these meanings explicit; otherwise a pause or scene transition can accidentally turn unfinished loot into permanent progression.
| Bucket | Example | When to change |
|---|---|---|
| Profile | Reputation, permanent unlocks | When the existing progression rule awards it |
| Stash | Secured weapons, extracted cargo | After an authoritative raid resolution |
| Current raid | Carried loot, objective status, health | While the raid is active |
| Outcome | Extracted, failed, abandoned | Once, at the resolution boundary |
In the fictional Greyline Depot example, a player can carry a sample case during the raid. If extraction succeeds, the case moves into the stash. If the raid fails, carried cargo is lost, but reputation earned from a separate persistent objective may remain. That is only one possible design. Write the real project's risk rules before changing data flow.
Trace the existing raid lifecycle
Find where a raid starts, how objectives are tracked, where the extraction trigger resolves, how failure is handled, and when the player returns to the hub. Map which script or service owns each transition. Ask AI to explain this path before it modifies code. Keep a copy of the project and a disposable profile save so you can compare behavior safely.
Use the existing outcome event if one exists. Avoid adding a second extraction handler that listens to the same trigger and writes its own stash update. A completion state should be committed once, after the game knows the outcome. If network authority or asynchronous requests already exist, preserve that model rather than introducing a local-only shortcut.

Make reward resolution idempotent
Duplicate rewards often appear around transitions: the extraction animation fires, a results screen opens, and a reload repeats the same callback. Design the commit so that processing one raid outcome more than once cannot add the cargo twice. A stable raid ID or explicit resolved marker can help, depending on the project's architecture.
Keep the order deliberate. First settle the result from the authoritative raid logic. Then compute what is kept, what is lost, and what permanent progress is earned. Validate item IDs and quantities. Commit one coherent profile and stash update. Finally show the summary and move to the hub. If saving fails, the game should communicate that failure and use a recovery policy the project can support; it should not silently show a success result that was never stored.
Do not promise database-style atomicity from a local file save. Use the storage approach already supported by the engine and platform, keep a recoverable copy where appropriate, and test interruption behavior. Godot's stable documentation recommends user:// for persistent user data and describes it as writable in exports. Unity documents Application.persistentDataPath for data retained between runs, with platform-specific locations. These references describe paths, not guarantees about transactions, backups, or cloud sync.
Ask AI for a bounded change
State the rules in plain language: preserve objective, enemy, movement, combat, and extraction behavior; only successful extraction moves carried loot into the stash; failure resolves losses according to the current game rules; persistent profile rewards use their existing system; and processing the same outcome twice must not duplicate cargo. Ask for changed files, assumptions, migration effects, and rollback steps.
Review the code path that calculates loot, not only the UI summary. Check that the summary reads the committed result rather than independently recalculating rewards. Verify that a failed raid cannot leave a stale “success” marker and that returning to the hub does not reopen an already resolved raid.
If the existing game has loadouts or item rarity, keep identifiers stable and validate inventory limits. A new progression layer should not silently delete items that older saves already contain. Test an old save on a duplicate file and decide how unknown or retired item IDs are handled before overwriting any real profile.
Test success, failure, and interrupted transitions
Use a matrix that covers both raid outcomes and state recovery. The following rows are suggested checks, not reported results from the fictional prototype.
| Case | Action | Expected behavior to verify |
|---|---|---|
| Fresh profile | Start with no prior profile | Default stash and unlocks match the documented rules |
| Successful extraction | Carry two known items and extract | Each item enters the stash once; raid state closes |
| Failed raid | Carry loot and trigger the existing failure outcome | Loss rules apply without deleting unrelated profile progress |
| Repeated outcome | Replay the same result event in a safe test copy | No duplicate cargo or reputation |
| Interrupted return | Test a safe interruption near the result transition | Recovery follows the declared policy and result stays understandable |
| Older save | Load a copy from before the progression fields | Known inventory is preserved or a clear migration error appears |
Record game version, platform, profile fixture, raid result, steps, expected outcome, and observed outcome. Repeat on the target build because the storage path and lifecycle can differ by platform. A diagram, mock result screen, or example item list cannot stand in for a real extraction test.

Frequently asked questions
What should persist in an extraction shooter prototype?
Decide separately what belongs to the profile, stash, current raid, and extracted cargo. A useful first slice may persist reputation and completed objectives while banking raid loot only after successful extraction. State the intended reward rule so players can understand what carries forward.
When should extracted items enter the stash?
Commit the result once the existing raid-resolution flow confirms extraction. Keep a stable raid or resolution identifier so a repeated scene transition cannot add the same cargo twice. A single result owner makes the commit easier to audit and recover.
Should gear from a failed raid remain in progression?
Follow the prototype's stated risk model. If the design says carried gear is lost on failure, resolve that loss explicitly and keep unrelated profile progress intact; do not let a save bug silently convert failure into extraction. Keep the failure policy visible in design notes and player-facing language.
How can I add progression without rewriting the raid loop?
Route the existing extraction and failure outcomes into one progression boundary. Preserve objective, enemy, movement, and combat owners, and ask AI to report a small file-level diff and rollback path. That boundary helps avoid a second owner for combat or objectives.
What should I test before keeping the progression change?
Test a fresh profile, successful extraction, failed extraction, interrupted resolution, duplicate transition, returning stash, and an older save. Record build, platform, and actual outcomes instead of treating the test plan as evidence. Treat the actual run record as evidence and keep examples labeled hypothetical.
Protect the meaning of extraction
Keep the first implementation focused on outcome resolution and the stash boundary. If the project can explain exactly what survives a successful extraction, what is lost on failure, and how the same result avoids being applied twice, the progression layer has a reviewable contract. Then verify that contract in the real game before expanding it.
For a separate browser-playable prototype idea, try SEELE AI Game Maker. This CTA is for a separate prototype, not an existing-project repair feature.


