Adding solo Quick Revive with ChatGPT

What I wanted Quick Revive to do

I wanted World at War’s Quick Revive to work in solo like it does in later Zombies games. Buy the perk, go down, survive the downed window and get back up. This was one of the earlier things I asked ChatGPT to mod, before the Black Ops 1 asset imports became the much bigger project.

The feature sounded like a script change, and it was, but it touched more of the game than I expected. World at War already had a downed state for a teammate to revive you. In solo, the surrounding death and mission-failure logic could end the match before our ten-second timer finished. Just setting the player’s health back up did not recreate a proper revive.

The implemented behavior keeps the stock 1,500-point price, allows three solo purchases per match and uses a temporary downed weapon. After recovery it gives back the earlier weapons, removes perks and clears the temporary protection. Getting each of those transitions right took repeated changes and playtests.

The mod was selected, but the game loaded another script

One early failure looked like a gameplay bug but was a loading problem. CoD Xe had the correct active profile, yet Verrückt still used the stock 500 starting points instead of the temporary 10,000-point test value. ChatGPT checked the files on disk, then enabled rawfile dumping to see which scripts the map actually requested.

The dump contained 197 rawfiles. Verrückt requested maps/_zombiemode_asylum.gsc; the helper had put the new core logic in maps/_zombiemode.gsc. The script inside the donor patch archive and the path requested at runtime were different. The generator needed a per-map destination, not another rewrite of the revive logic.

There was a second catch: CoD Xe’s rawfile-dump mode returned the original script before applying an override. It helped find the paths, but had to be turned off for the next gameplay test. The useful proof became the GSCLoader: Loaded override script log entries, the active profile and the on-screen SQR markers. Elevated points were later removed from the normal build.

Earlier direct FastFile replacements had stalled during loading. ChatGPT restored the stock archives and generated script overlays through CoD Xe instead. The generator, remote/waw-fftool.py, could then stage each map’s scripts and verify its expected paths and markers before a relaunch.

Keeping the game alive long enough to revive me

I pointed out that multiplayer Zombies already had the downed behavior I wanted. ChatGPT inspected maps/_laststand.gsc and reused PlayerLastStand, which handles the downed view, revive trigger, pistol and weapon storage. The self-revive could then call the game’s existing revive_force_revive path.

The next attempts still faded to black and restarted. The debug messages reached the lethal branch and pistol swap but stopped before “REVIVE TIMER DONE.” ChatGPT moved the countdown from a player-owned thread to a level-owned thread. That addressed the possibility that a player transition was terminating the timer; it was one part of the fix, and the next playtest still failed.

solo_quick_revive_self_revive()
{
    level thread solo_quick_revive_self_revive_for_player( self );
}

The generator also held the player’s bleedout counter above the recovery window, temporarily set player_lastStandBleedoutTime to 30 and gated the map’s player_becomes_zombie callback while self-revive was active. The controller’s ten-second wait was then followed by the stock revive call. This excerpt shows the normal completion path after its player and last-stand checks:

player solo_quick_revive_debug( "SQR: FORCE REVIVE" );
player maps\_laststand::revive_force_revive( player );
wait( 0.1 );
player solo_quick_revive_clear_perks();
player solo_quick_revive_restore_bleedout_dvar();
player solo_quick_revive_end_protection();

player.solo_quick_revive_active = undefined;
player notify( "solo_quick_revive_done" );

Grenade tests exposed another timing problem. The notes suspected that pending lethal damage could finish resolving after last stand had begun. ChatGPT added temporary damage absorption and delayed entry to stock last stand by one script tick. Later playtests reached the expected downed window. I would not describe the initial damage-ordering theory as a separately proven engine fact; it was a hypothesis tested alongside the other state protections.

Restoring weapons and removing the temporary protection

The downed pistol could not be the same asset on every map. The recorded weapon tables showed zombie_colt_upgraded on Der Riese, but not on Verrückt or Shi No Numa. The latter two use ray_gun, which also has a stock last-stand handling path. The generator checks the chosen weapon per map instead of assuming the name will resolve everywhere.

Health cleanup mattered just as much. The damage-absorption code briefly raised health and maximum health to around 10,000. Leaving that behind would turn a recovery feature into accidental invulnerability. One generated helper also failed to clear the separate Quick Revive ownership flag, allowing the next down to look eligible again.

ChatGPT made perk removal clear that flag and restore 100 health and maximum health. The end-protection helper also normalizes health according to current Juggernog ownership. This mattered when I reported taking many hits after buying Juggernog: the stock Verrückt script itself heals 40 points every half-second up to 160, so spaced hits were not a clean measure of the mod’s protection.

A later “Unknown function” error came from a debug helper added to the perks script even though it was defined only in the map’s core script. ChatGPT removed that cross-file call and added a verifier that rejects it. That was another case where a tiny diagnostic change could stop the map before we ever reached the feature.

What my Shi No Numa playtest confirmed

On June 23 I played the revised Shi No Numa build with normal 500 starting points and reported that solo Quick Revive worked correctly. The earlier Juggernog concern did not reproduce in that playtest. That is the acceptance recorded for this map; I have not treated it as proof for every map, co-op or a physical Xbox 360.

ChatGPT helped because it could compare the generated scripts, inspect what CoD Xe actually loaded, add a marker at the missing transition and prepare the next build. I was doing the meaningful down-and-revive playtests and reporting where the sequence stopped. The later BO1 project developed a much fuller automated gameplay runner; this earlier WaW work still depended heavily on my reports.

Without those tools I would have been checking the same map files, changing the active profile and relaunching after each edit. ChatGPT handled that repetitive work and kept turning the reported failures into concrete checks. It also introduced bugs along the way, including the unsafe debug-helper call, so “the script verifier passed” was never the same as “I played it and it worked.”