feat(replay): Add checkpoint save and resume functionality for replays

Core/GameEngine/Include/Common/RandomValue.h

@@ -35,4 +35,10 @@ extern void InitRandom( UnsignedInt seed );
 extern UnsignedInt GetGameLogicRandomSeed();   ///< Get the seed (used for replays)
 extern UnsignedInt GetGameLogicRandomSeedCRC();///< Get the seed (used for CRCs)
 
+// TheSuperHackers @info bobtista 19/01/2026
+// Functions to save/restore the full RNG state for checkpoints.
+// The state array must have room for 6 UnsignedInts.
+extern void GetGameLogicRandomState( UnsignedInt* state, UnsignedInt* baseSeed );
+extern void SetGameLogicRandomState( const UnsignedInt* state, UnsignedInt baseSeed );
+
 //--------------------------------------------------------------------------------------------------------------

Core/GameEngine/Include/Common/ReplaySimulation.h

@@ -28,6 +28,9 @@ class ReplaySimulation
 	// Returns exit code 0 if all replays were successfully simulated without mismatches
 	static int simulateReplays(const std::vector<AsciiString> &filenames, int maxProcesses);
 
+	// Continue a replay from a checkpoint file in headless mode
+	static int continueReplayFromCheckpoint(const AsciiString &checkpointFile);
+
 	static void stop() { s_isRunning = false; }
 
 	static Bool isRunning() { return s_isRunning; }

Core/GameEngine/Include/Common/Snapshot.h

@@ -42,6 +42,7 @@ class Snapshot
 {
 
 friend class GameState;
+friend class GameLogic;  // TheSuperHackers @bugfix bobtista 22/01/2026 Allow GameLogic to call loadPostProcess on objects
 friend class XferLoad;
 friend class XferSave;
 friend class XferCRC;

Core/GameEngine/Include/GameLogic/AIPathfind.h

@@ -175,6 +175,11 @@ class Path : public MemoryPoolObject, public Snapshot
 	/// Given a location, return closest location on path, and along-path dist to end as function result
 	void markOptimized() {m_isOptimized = true;}
 
+	/// TheSuperHackers @bugfix bobtista 31/01/2026 Invalidate CPOP cache after checkpoint load.
+	/// This forces computePointOnPath() to search from the beginning of the path and find the
+	/// segment closest to the unit's current position, rather than using a stale cached segment.
+	void invalidateCpopCache(void) {m_cpopValid = false; m_cpopRecentStart = nullptr;}
+
 protected:
 	// snapshot interface
 	virtual void crc( Xfer *xfer );
@@ -304,9 +309,11 @@ class PathfindCell
 
 	Bool setTypeAsObstacle( Object *obstacle, Bool isFence, const ICoord2D &pos );				///< flag this cell as an obstacle, from the given one
 	Bool removeObstacle( Object *obstacle );				///< unflag this cell as an obstacle, from the given one
+	void resetForCheckpointLoad( void );				///< reset cell type and obstacle info, but preserve flags and zone
 	void setType( CellType type );	///< set the cell type
 	CellType getType() const { return (CellType)m_type; }				///< get the cell type
 	CellFlags getFlags() const { return (CellFlags)m_flags; }				///< get the cell type
+	void setFlags( CellFlags flags ) { m_flags = flags; }				///< set the cell flags (TheSuperHackers @bobtista 29/01/2026)
 	Bool isAircraftGoal() const {return m_aircraftGoal != 0;}
 
 	Bool isObstaclePresent( ObjectID objID ) const;					///< return true if the given object ID is registered as an obstacle in this cell
@@ -417,6 +424,7 @@ typedef PathfindCell *PathfindCellP;
  */
 class PathfindLayer
 {
+	friend class Pathfinder;  ///< TheSuperHackers @info bobtista 21/01/2026 Allows Pathfinder::xfer to serialize layer state
 public:
 	PathfindLayer();
 	~PathfindLayer();
@@ -527,6 +535,7 @@ typedef ZoneBlock *ZoneBlockP;
  */
 class PathfindZoneManager
 {
+	friend class Pathfinder;  ///< TheSuperHackers @info bobtista 20/01/2026 Allows Pathfinder::xfer to serialize zone state
 public:
 	enum {INITIAL_ZONES = 256};
 	enum {ZONE_BLOCK_SIZE = 10};	// Zones are calculated in blocks of 20x20.  This way, the raw zone numbers can be used to

Core/GameEngine/Source/Common/RandomValue.cpp

@@ -182,6 +182,40 @@
 // of the effects displayed on the GameClient.
 //
 
+UnsignedInt GetGameLogicRandomSeed( void )
+{
+	return theGameLogicBaseSeed;
+}
+
+UnsignedInt GetGameLogicRandomSeedCRC( void )
+{
+	CRC c;
+	c.computeCRC(theGameLogicSeed, 6*sizeof(UnsignedInt));
+	return c.get();
+}
+
+// TheSuperHackers @info bobtista 19/01/2026
+// Get the full RNG state for serialization in checkpoints.
+void GetGameLogicRandomState( UnsignedInt* state, UnsignedInt* baseSeed )
+{
+	for (int i = 0; i < 6; ++i)
+	{
+		state[i] = theGameLogicSeed[i];
+	}
+	*baseSeed = theGameLogicBaseSeed;
+}
+
+// TheSuperHackers @info bobtista 19/01/2026
+// Restore the full RNG state after loading a checkpoint.
+void SetGameLogicRandomState( const UnsignedInt* state, UnsignedInt baseSeed )
+{
+	for (int i = 0; i < 6; ++i)
+	{
+		theGameLogicSeed[i] = state[i];
+	}
+	theGameLogicBaseSeed = baseSeed;
+}
+
 //
 // Integer random value
 //

Core/GameEngine/Source/Common/ReplaySimulation.cpp

@@ -21,6 +21,7 @@
 #include "Common/ReplaySimulation.h"
 
 #include "Common/GameEngine.h"
+#include "Common/GameState.h"
 #include "Common/LocalFileSystem.h"
 #include "Common/Recorder.h"
 #include "Common/WorkerProcess.h"
@@ -99,8 +100,27 @@
 					fflush(stdout);
 				}
 				TheGameLogic->UPDATE();
+
+				// Check for checkpoint save BEFORE checking for CRC mismatch
+				// so we can save checkpoints even if the replay will eventually fail
+				if (TheGlobalData->m_replaySaveAtFrame != 0 &&
+					TheGameLogic->getFrame() == TheGlobalData->m_replaySaveAtFrame &&
+					!TheGlobalData->m_replaySaveTo.isEmpty())
+				{
+					// TheSuperHackers @info bobtista 19/01/2026
+					// Pass just the filename to saveGame() - it will be saved to the Save directory.
+					SaveCode result = TheGameState->saveGame(TheGlobalData->m_replaySaveTo, UnicodeString::TheEmptyString, SAVE_FILE_TYPE_NORMAL);
+					if (result != SC_OK)
+					{
+						numErrors++;
+					}
+					TheRecorder->stopPlayback();
+					break;
+				}
+
 				if (TheRecorder->sawCRCMismatch())
 				{
+					DEBUG_LOG(("CRC mismatch at frame %d", TheGameLogic->getFrame()));
 					numErrors++;
 					break;
 				}
@@ -253,3 +273,95 @@
 	else
 		return simulateReplaysInWorkerProcesses(filenamesResolved, maxProcesses);
 }
+
+int ReplaySimulation::continueReplayFromCheckpoint(const AsciiString &checkpointFile)
+{
+	int numErrors = 0;
+
+	// TheSuperHackers @info bobtista 19/01/2026
+	// We need to initialize the replay BEFORE loading the checkpoint because:
+	// 1. loadGame() calls startNewGame() which creates team prototypes based on the map
+	// 2. During replay playback, startNewGame() uses TheRecorder->getGameInfo() to get the correct team setup
+	// 3. But CHUNK_Recorder is loaded AFTER startNewGame() runs
+	// So we must initialize the replay first to provide the correct game info.
+	if (TheGlobalData->m_simulateReplays.empty())
+	{
+		DEBUG_LOG(("No replay file specified for checkpoint loading"));
+		return 1;
+	}
+
+	AsciiString replayFile = TheGlobalData->m_simulateReplays[0];
+	DEBUG_LOG(("Initializing replay from %s before loading checkpoint", replayFile.str()));
+
+	// Initialize the recorder from the replay file so that when loadGame() calls
+	// startNewGame(), it will have the correct game info from the replay header.
+	if (!TheRecorder->initializeReplayForCheckpointLoad(replayFile))
+	{
+		DEBUG_LOG(("Failed to initialize replay from %s", replayFile.str()));
+		return 1;
+	}
+
+	DEBUG_LOG(("Loading checkpoint from %s", checkpointFile.str()));
+
+	AvailableGameInfo gameInfo;
+	gameInfo.filename = checkpointFile;
+	TheGameState->getSaveGameInfoFromFile(checkpointFile, &gameInfo.saveGameInfo);
+
+	SaveCode result = TheGameState->loadGame(gameInfo);
+	if (result != SC_OK)
+	{
+		DEBUG_LOG(("Failed to load checkpoint (error %d)", result));
+		return 1;
+	}
+
+	if (!TheRecorder->isPlaybackMode())
+	{
+		DEBUG_LOG(("Checkpoint was not saved during replay playback"));
+		return 1;
+	}
+
+	DEBUG_LOG(("Resuming replay from frame %d", TheGameLogic->getFrame()));
+
+#ifdef _DEBUG
+	DWORD startTimeMillis = GetTickCount();
+	UnsignedInt totalTimeSec = TheRecorder->getPlaybackFrameCount() / LOGICFRAMES_PER_SECOND;
+#endif
+
+	while (TheRecorder->isPlaybackInProgress())
+	{
+		TheGameClient->updateHeadless();
+
+#ifdef _DEBUG
+		const int progressFrameInterval = 10*60*LOGICFRAMES_PER_SECOND;
+		if (TheGameLogic->getFrame() != 0 && TheGameLogic->getFrame() % progressFrameInterval == 0)
+		{
+			UnsignedInt gameTimeSec = TheGameLogic->getFrame() / LOGICFRAMES_PER_SECOND;
+			UnsignedInt realTimeSec = (GetTickCount()-startTimeMillis) / 1000;
+			DEBUG_LOG(("Elapsed Time: %02d:%02d Game Time: %02d:%02d/%02d:%02d",
+					realTimeSec/60, realTimeSec%60, gameTimeSec/60, gameTimeSec%60, totalTimeSec/60, totalTimeSec%60));
+		}
+#endif
+		TheGameLogic->UPDATE();
+		if (TheRecorder->sawCRCMismatch())
+		{
+			numErrors++;
+			break;
+		}
+	}
+
+#ifdef _DEBUG
+	{
+		UnsignedInt gameTimeSec = TheGameLogic->getFrame() / LOGICFRAMES_PER_SECOND;
+		UnsignedInt realTimeSec = (GetTickCount()-startTimeMillis) / 1000;
+		DEBUG_LOG(("Elapsed Time: %02d:%02d Game Time: %02d:%02d/%02d:%02d",
+				realTimeSec/60, realTimeSec%60, gameTimeSec/60, gameTimeSec%60, totalTimeSec/60, totalTimeSec%60));
+
+		if (TheRecorder->sawCRCMismatch())
+			DEBUG_LOG(("CRC Mismatch detected!"));
+		else
+			DEBUG_LOG(("Replay completed successfully"));
+	}
+#endif
+
+	return numErrors != 0 ? 1 : 0;
+}