[GEN][ZH] Add Replay Simulation feature

Core/GameEngine/CMakeLists.txt

@@ -95,6 +95,7 @@ set(GAMEENGINE_SRC
 #    Include/Common/RandomValue.h
 #    Include/Common/Recorder.h
 #    Include/Common/Registry.h
+    Include/Common/ReplaySimulation.h
 #    Include/Common/ResourceGatheringManager.h
 #    Include/Common/Science.h
 #    Include/Common/ScopedMutex.h
@@ -129,6 +130,7 @@ set(GAMEENGINE_SRC
 #    Include/Common/UserPreferences.h
 #    Include/Common/version.h
 #    Include/Common/WellKnownKeys.h
+    Include/Common/WorkerProcess.h
     Include/Common/Xfer.h
     Include/Common/XferCRC.h
     Include/Common/XferDeepCRC.h
@@ -607,6 +609,7 @@ set(GAMEENGINE_SRC
 #    Source/Common/PerfTimer.cpp
 #    Source/Common/RandomValue.cpp
 #    Source/Common/Recorder.cpp
+    Source/Common/ReplaySimulation.cpp
 #    Source/Common/RTS/AcademyStats.cpp
 #    Source/Common/RTS/ActionManager.cpp
 #    Source/Common/RTS/Energy.cpp
@@ -676,6 +679,7 @@ set(GAMEENGINE_SRC
 #    Source/Common/Thing/ThingTemplate.cpp
 #    Source/Common/UserPreferences.cpp
 #    Source/Common/version.cpp
+    Source/Common/WorkerProcess.cpp
 #    Source/GameClient/ClientInstance.cpp
 #    Source/GameClient/Color.cpp
 #    Source/GameClient/Credits.cpp

Core/GameEngine/Include/Common/ReplaySimulation.h

@@ -0,0 +1,48 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2025 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+class ReplaySimulation
+{
+public:
+
+	// TheSuperHackers @feature helmutbuhler 13/04/2025
+	// Simulate a list of replays without graphics.
+	// Returns exit code 1 if mismatch or other error occurred
+	// Returns exit code 0 if all replays were successfully simulated without mismatches
+	static int simulateReplays(const std::vector<AsciiString> &filenames, int maxProcesses);
+
+	static void stop() { s_isRunning = false; }
+
+	static Bool isRunning() { return s_isRunning; }
+	static UnsignedInt getCurrentReplayIndex() { return s_replayIndex; }
+	static UnsignedInt getReplayCount() { return s_replayCount; }
+
+private:
+
+	static int simulateReplaysInThisProcess(const std::vector<AsciiString> &filenames);
+	static int simulateReplaysInWorkerProcesses(const std::vector<AsciiString> &filenames, int maxProcesses);
+	static std::vector<AsciiString> resolveFilenameWildcards(const std::vector<AsciiString> &filenames);
+
+private:
+
+	static Bool s_isRunning;
+	static UnsignedInt s_replayIndex;
+	static UnsignedInt s_replayCount;
+};

Core/GameEngine/Include/Common/WorkerProcess.h

@@ -0,0 +1,56 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2025 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+// Helper class that allows you to start a worker process and retrieve its exit code
+// and console output as a string.
+// It also makes sure that the started process is killed in case our process exits in any way.
+class WorkerProcess
+{
+public:
+	WorkerProcess();
+
+	bool startProcess(UnicodeString command);
+
+	void update();
+
+	bool isRunning() const;
+
+	// returns true iff the process exited.
+	bool isDone() const;
+
+	DWORD getExitCode() const;
+	AsciiString getStdOutput() const;
+
+	// Terminate Process if it's running
+	void kill();
+
+private:
+	// returns true if all output has been received
+	// returns false if the worker is still running
+	bool fetchStdOutput();
+
+private:
+	HANDLE m_processHandle;
+	HANDLE m_readHandle;
+	HANDLE m_jobHandle;
+	AsciiString m_stdOutput;
+	DWORD m_exitcode;
+	bool m_isDone;
+};

Core/GameEngine/Source/Common/ReplaySimulation.cpp

@@ -0,0 +1,255 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2025 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "PreRTS.h"	// This must go first in EVERY cpp file in the GameEngine
+
+#include "Common/ReplaySimulation.h"
+
+#include "Common/GameEngine.h"
+#include "Common/LocalFileSystem.h"
+#include "Common/Recorder.h"
+#include "Common/WorkerProcess.h"
+#include "GameLogic/GameLogic.h"
+#include "GameClient/GameClient.h"
+
+
+Bool ReplaySimulation::s_isRunning = false;
+UnsignedInt ReplaySimulation::s_replayIndex = 0;
+UnsignedInt ReplaySimulation::s_replayCount = 0;
+
+namespace
+{
+int countProcessesRunning(const std::vector<WorkerProcess>& processes)
+{
+	int numProcessesRunning = 0;
+	size_t i = 0;
+	for (; i < processes.size(); ++i)
+	{
+		if (processes[i].isRunning())
+			++numProcessesRunning;
+	}
+	return numProcessesRunning;
+}
+} // namespace
+
+int ReplaySimulation::simulateReplaysInThisProcess(const std::vector<AsciiString> &filenames)
+{
+	int numErrors = 0;
+
+	if (!TheGlobalData->m_headless)
+	{
+		s_isRunning = true;
+		s_replayIndex = 0;
+		s_replayCount = static_cast<UnsignedInt>(filenames.size());
+
+		// If we are not in headless mode, we need to run the replay in the engine.
+		for (; s_replayIndex < s_replayCount; ++s_replayIndex)
+		{
+			TheRecorder->playbackFile(filenames[s_replayIndex]);
+			TheGameEngine->execute();
+			if (TheRecorder->sawCRCMismatch())
+				numErrors++;
+			if (!s_isRunning)
+				break;
+			TheGameEngine->setQuitting(FALSE);
+		}
+		s_isRunning = false;
+		s_replayIndex = 0;
+		s_replayCount = 0;
+		return numErrors != 0 ? 1 : 0;
+	}
+	// Note that we use printf here because this is run from cmd.
+	DWORD totalStartTimeMillis = GetTickCount();
+	for (size_t i = 0; i < filenames.size(); i++)
+	{
+		AsciiString filename = filenames[i];
+		printf("Simulating Replay \"%s\"\n", filename.str());
+		fflush(stdout);
+		DWORD startTimeMillis = GetTickCount();
+		if (TheRecorder->simulateReplay(filename))
+		{
+			UnsignedInt totalTimeSec = TheRecorder->getPlaybackFrameCount() / LOGICFRAMES_PER_SECOND;
+			while (TheRecorder->isPlaybackInProgress())
+			{
+				TheGameClient->updateHeadless();
+
+				const int progressFrameInterval = 10*60*LOGICFRAMES_PER_SECOND;
+				if (TheGameLogic->getFrame() != 0 && TheGameLogic->getFrame() % progressFrameInterval == 0)
+				{
+					// Print progress report
+					UnsignedInt gameTimeSec = TheGameLogic->getFrame() / LOGICFRAMES_PER_SECOND;
+					UnsignedInt realTimeSec = (GetTickCount()-startTimeMillis) / 1000;
+					printf("Elapsed Time: %02d:%02d Game Time: %02d:%02d/%02d:%02d\n",
+							realTimeSec/60, realTimeSec%60, gameTimeSec/60, gameTimeSec%60, totalTimeSec/60, totalTimeSec%60);
+					fflush(stdout);
+				}
+				TheGameLogic->UPDATE();
+				if (TheRecorder->sawCRCMismatch())
+				{
+					numErrors++;
+					break;
+				}
+			}
+			UnsignedInt gameTimeSec = TheGameLogic->getFrame() / LOGICFRAMES_PER_SECOND;
+			UnsignedInt realTimeSec = (GetTickCount()-startTimeMillis) / 1000;
+			printf("Elapsed Time: %02d:%02d Game Time: %02d:%02d/%02d:%02d\n",
+					realTimeSec/60, realTimeSec%60, gameTimeSec/60, gameTimeSec%60, totalTimeSec/60, totalTimeSec%60);
+			fflush(stdout);
+		}
+		else
+		{
+			printf("Cannot open replay\n");
+			numErrors++;
+		}
+	}
+	if (filenames.size() > 1)
+	{
+		printf("Simulation of all replays completed. Errors occurred: %d\n", numErrors);
+
+		UnsignedInt realTime = (GetTickCount()-totalStartTimeMillis) / 1000;
+		printf("Total Time: %d:%02d:%02d\n", realTime/60/60, realTime/60%60, realTime%60);
+		fflush(stdout);
+	}
+
+	return numErrors != 0 ? 1 : 0;
+}
+
+int ReplaySimulation::simulateReplaysInWorkerProcesses(const std::vector<AsciiString> &filenames, int maxProcesses)
+{
+	DWORD totalStartTimeMillis = GetTickCount();
+
+	WideChar exePath[1024];
+	GetModuleFileNameW(NULL, exePath, ARRAY_SIZE(exePath));
+
+	std::vector<WorkerProcess> processes;
+	int filenamePositionStarted = 0;
+	int filenamePositionDone = 0;
+	int numErrors = 0;
+
+	while (true)
+	{
+		int i;
+		for (i = 0; i < processes.size(); i++)
+			processes[i].update();
+
+		// Get result of finished processes and print output in order
+		while (!processes.empty())
+		{
+			if (!processes[0].isDone())
+				break;
+			AsciiString stdOutput = processes[0].getStdOutput();
+			printf("%d/%d %s", filenamePositionDone+1, (int)filenames.size(), stdOutput.str());
+			DWORD exitcode = processes[0].getExitCode();
+			if (exitcode != 0)
+				printf("Error!\n");
+			fflush(stdout);
+			numErrors += exitcode == 0 ? 0 : 1;
+			processes.erase(processes.begin());
+			filenamePositionDone++;
+		}
+
+		int numProcessesRunning = countProcessesRunning(processes);
+
+		// Add new processes when we are below the limit and there are replays left
+		while (numProcessesRunning < maxProcesses && filenamePositionStarted < filenames.size())
+		{
+			UnicodeString filenameWide;
+			filenameWide.translate(filenames[filenamePositionStarted]);
+			UnicodeString command;
+			command.format(L"\"%s\"%s%s -replay \"%s\"",
+				exePath,
+				TheGlobalData->m_windowed ? L" -win" : L"",
+				TheGlobalData->m_headless ? L" -headless" : L"",
+				filenameWide.str());
+
+			processes.push_back(WorkerProcess());
+			processes.back().startProcess(command);
+
+			filenamePositionStarted++;
+			numProcessesRunning++;
+		}
+
+		if (processes.empty())
+			break;
+
+		// Don't waste CPU here, our workers need every bit of CPU time they can get
+		Sleep(100);
+	}
+
+	DEBUG_ASSERTCRASH(filenamePositionStarted == filenames.size(), ("inconsistent file position 1"));
+	DEBUG_ASSERTCRASH(filenamePositionDone == filenames.size(), ("inconsistent file position 2"));
+
+	printf("Simulation of all replays completed. Errors occurred: %d\n", numErrors);
+
+	UnsignedInt realTime = (GetTickCount()-totalStartTimeMillis) / 1000;
+	printf("Total Wall Time: %d:%02d:%02d\n", realTime/60/60, realTime/60%60, realTime%60);
+	fflush(stdout);
+
+	return numErrors != 0 ? 1 : 0;
+}
+
+std::vector<AsciiString> ReplaySimulation::resolveFilenameWildcards(const std::vector<AsciiString> &filenames)
+{
+	// If some filename contains wildcards, search for actual filenames.
+	// Note that we cannot do this in parseReplay because we require TheLocalFileSystem initialized.
+	std::vector<AsciiString> filenamesResolved;
+	for (std::vector<AsciiString>::const_iterator filename = filenames.begin(); filename != filenames.end(); ++filename)
+	{
+		if (filename->find('*') || filename->find('?'))
+		{
+			AsciiString dir1 = TheRecorder->getReplayDir();
+			AsciiString dir2 = *filename;
+			AsciiString wildcard = *filename;
+			{
+				int len = dir2.getLength();
+				while (len)
+				{
+					char c = dir2.getCharAt(len-1);
+					if (c == '/' || c == '\\')
+					{
+						wildcard.set(wildcard.str()+dir2.getLength());
+						break;
+					}
+					dir2.removeLastChar();
+					len--;
+				}
+			}
+
+			FilenameList files;
+			TheLocalFileSystem->getFileListInDirectory(dir2.str(), dir1.str(), wildcard, files, FALSE);
+			for (FilenameList::iterator it = files.begin(); it != files.end(); ++it)
+			{
+				AsciiString file;
+				file.set(it->str() + dir1.getLength());
+				filenamesResolved.push_back(file);
+			}
+		}
+		else
+			filenamesResolved.push_back(*filename);
+	}
+	return filenamesResolved;
+}
+
+int ReplaySimulation::simulateReplays(const std::vector<AsciiString> &filenames, int maxProcesses)
+{
+	std::vector<AsciiString> filenamesResolved = resolveFilenameWildcards(filenames);
+	if (maxProcesses == SIMULATE_REPLAYS_SEQUENTIAL)
+		return simulateReplaysInThisProcess(filenamesResolved);
+	else
+		return simulateReplaysInWorkerProcesses(filenamesResolved, maxProcesses);
+}