Bug Reporting for Games With New Game Plus

New game plus is a promise of payoff: start over but keep what you earned, and face a world that respects your power. It is also one of the most bug prone features a game can ship, because it touches every system at once. A second run that loses your hard won gear, resets a level you meant to keep, or throws starting zone enemies at your endgame character all break the promise in different ways. Underneath is a carryover step that decides what persists and what resets, plus a scaling step that recomputes difficulty from your progress. The bugs hide in those two transitions. This post is about capturing the carryover and scaling state so a new game plus report names what was dropped or mis scaled.

New game plus is a state migration

A new game plus run is, mechanically, a state migration. You take a completed save and produce a fresh one, copying some values forward, resetting others to their starting defaults, and recomputing derived values like enemy scaling. Migrations are notoriously bug prone because every value has to be explicitly classified as carry, reset, or recompute, and the natural failure is forgetting to classify one. A new stat or item added late in development that nobody added to the carryover map will silently reset, and the player loses it without any error, because nothing went wrong from the code's point of view.

The player experiences this as a betrayal that is hard to articulate. They know something is missing or wrong but may not immediately notice which of dozens of progression values was dropped. They report I lost stuff in new game plus, which is true but useless without specifics. Capturing the before and after state of the migration, what the completed save held and what the new run received, turns this into a diff. You compare the two and the dropped value stands out as present before and default after, which is the carryover entry that was missed.

The carryover state to capture

Capture a snapshot of the relevant progression state at the moment a new game plus run is created: the carried values with their amounts, the values that were intentionally reset, and ideally the source completed save's values for comparison. Progression state means levels, currency, unlocked abilities, inventory and equipment, key items, and any meta unlocks. With a before and after pair you can audit the migration directly. A piece of gear present in the completed save but absent in the new run, and not on the intended reset list, is a carryover bug visible the instant you read the diff.

Capture the carryover classification itself if you can, the policy that says this value carries and that one resets, because the bug is sometimes a value classified wrong rather than missed entirely. A consumable that should reset but is marked carry gives players an unintended stockpile, while a key item marked reset locks them out of content. Recording each value's intended disposition next to its actual outcome separates a missing classification from a wrong one, which matters because the fixes differ: one adds an entry, the other corrects it. The captured policy makes the intent explicit instead of implicit in scattered code.

What persists and what should not

Deciding what persists is a design call, and bugs come from the implementation diverging from that design. Most games carry character power and cosmetics but reset story progress and consumed world state, so the player replays the narrative with their built up character. The tricky cases are the in between values: quest items, faction standing, currency, and one time unlocks. A quest item that carries over can break the early game by letting a quest complete instantly, and capturing the carried inventory against the intended carry list catches exactly these inappropriate persistences before they confuse players.

The opposite bug, resetting something that should persist, is the more painful one for players because it erases effort. A cosmetic unlocked through a long grind, an ability tied to a difficult achievement, or a currency meant to span runs all feel terrible to lose. Capturing the reset values against the intended reset list surfaces these immediately when a value the player earned to keep shows up reset. Because progression state is large and added to over a project's life, the only reliable way to keep the persist and reset lists honest is to capture and diff the actual migration outcome rather than trusting that every value was remembered.

Scaling bugs and the difficulty cliff

The second half of new game plus is scaling: enemies, rewards, and challenges should recompute to match a carried over, powerful character. Scaling bugs produce either a trivial run, where enemies stayed at first run values while the player kept endgame gear, or a brutal cliff, where scaling overshot and the starting zone is unwinnable. Both come from the scaling formula reading the wrong input, perhaps the new run's nominal level rather than the carried power, or the new game plus tier counter not incrementing. Capturing the scaling inputs and the resulting enemy values exposes which it is.

Capture the scaling tier, the inputs the formula consumed, and a sample of the scaled enemy stats in the report. A run where enemies feel trivial will show a scaling tier of zero or enemy values matching a first run, telling you the tier never incremented or the formula ignored it. A run that feels impossible will show enemy values far above the carried power, telling you the formula overshot or compounded across runs. These are precise, fixable diagnoses, and they are impossible to reach from a player report that says the difficulty feels wrong without the scaling state attached to ground it.

Setting it up with Bugnet

Bugnet's in-game report button captures game state automatically, so a new game plus report arrives with the carryover diff and scaling inputs attached rather than a player vaguely describing lost progress. Serialize the migration into custom fields: the carried values, the reset values, the source save's values where available, the scaling tier, the scaling inputs, and a sample of scaled enemy stats. When a report says I lost my gear in new game plus, you open it and the equipment is present in the source values but default in the carried set, naming the missing carryover entry without you reconstructing the player's save.

Occurrence grouping folds matching new game plus reports into one issue with a count, so a dropped value or a scaling formula error that hits everyone starting a second run surfaces as a single high priority entry rather than scattered complaints. You can filter by the scaling tier custom field to isolate reports from a specific new game plus level, and compare carryover diffs across reports to confirm the same value is missing for everyone. With the before and after state and the scaling inputs in one dashboard, a feature that touches every system becomes auditable from a single report.

Testing the migration and the scaling curve

The durable defense is testing new game plus as the migration and recomputation it is. Write a test that takes a representative completed save, runs the carryover, and asserts every value matches its intended disposition: carried values equal the source, reset values equal the defaults, and nothing is silently dropped. Because you add progression values over a project's life, make this test enumerate against the full set of progression fields so a newly added value without a classification fails the test rather than silently resetting in production for real players.

Test the scaling separately by feeding known carried power levels and tiers into the formula and asserting the resulting enemy and reward values fall within the intended band, with explicit checks at the first new game plus tier and a high tier to catch both the trivial and the cliff failure modes. Because your reports serialize the carryover and scaling state, any odd run replays into a test directly. The teams that ship new game plus that feels right are the ones who treat it as a tested migration, and when the carryover and scaling are observable and asserted, the lost gear and the broken difficulty stop recurring run after run.

New game plus is a state migration. Capture the before and after and the scaling inputs, and the lost gear and broken difficulty become a diff you can read.