Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** 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/>.
*/
// Modified 2025-2026 by Olcay Seygan for Zero Hour Reforged; see the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
//
// Westwood Studios Pacific.
//
// Confidential Information
// Copyright (C) 2001 - All Rights Reserved
//
//----------------------------------------------------------------------------
//
// Project: Generals
//
// Module: Game Engine Common
//
// File name: ArchiveFileSystem.cpp
//
// Created: 11/26/01 TR
//
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------
#include "PreRTS.h"
#include "Common/ArchiveFile.h"
#include "Common/ArchiveFileSystem.h"
#include "Common/AsciiString.h"
#include "Common/PerfTimer.h"
#ifdef _INTERNAL
// for occasional debugging...
//#pragma optimize("", off)
//#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
#endif
//----------------------------------------------------------------------------
// Externals
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Defines
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Private Types
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Private Data
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Public Data
//----------------------------------------------------------------------------
ArchiveFileSystem *TheArchiveFileSystem = NULL;
//----------------------------------------------------------------------------
// Private Prototypes
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Private Functions
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Public Functions
//----------------------------------------------------------------------------
//------------------------------------------------------
// ArchivedFileInfo
//------------------------------------------------------
ArchiveFileSystem::ArchiveFileSystem()
{
}
ArchiveFileSystem::~ArchiveFileSystem()
{
ArchiveFileMap::iterator iter = m_archiveFileMap.begin();
while (iter != m_archiveFileMap.end()) {
ArchiveFile *file = iter->second;
if (file != NULL) {
delete file;
file = NULL;
}
iter++;
}
}
void ArchiveFileSystem::loadIntoDirectoryTree(const ArchiveFile *archiveFile, const AsciiString& archiveFilename, Bool overwrite)
{
FilenameList filenameList;
archiveFile->getFileListInDirectory(AsciiString(""), AsciiString(""), AsciiString("*"), filenameList, TRUE);
FilenameListIter it = filenameList.begin();
while (it != filenameList.end()) {
// add this filename to the directory tree.
AsciiString path = *it;
path.toLower();
AsciiString token;
AsciiString debugpath;
ArchivedDirectoryInfo *dirInfo = &m_rootDirectory;
Bool infoInPath;
infoInPath = path.nextToken(&token, "\\/");
while (infoInPath && (!token.find('.') || path.find('.'))) {
ArchivedDirectoryInfoMap::iterator tempiter = dirInfo->m_directories.find(token);
if (tempiter == dirInfo->m_directories.end())
{
dirInfo->m_directories[token].clear();
dirInfo->m_directories[token].m_directoryName = token;
}
dirInfo = &(dirInfo->m_directories[token]);
debugpath.concat(token);
debugpath.concat('\\');
infoInPath = path.nextToken(&token, "\\/");
}
// token is the filename, and dirInfo is the directory that this file is in.
if (dirInfo->m_files.find(token) == dirInfo->m_files.end() || overwrite) {
AsciiString path2;
path2 = debugpath;
path2.concat(token);
// DEBUG_LOG(("ArchiveFileSystem::loadIntoDirectoryTree - adding file %s, archived in %s\n", path2.str(), archiveFilename.str()));
dirInfo->m_files[token] = archiveFilename;
}
it++;
}
}
Bool ArchiveFileSystem::doesFileExist(const Char *filename) const
{
AsciiString path = filename;
path.toLower();
AsciiString token;
const ArchivedDirectoryInfo *dirInfo = &m_rootDirectory;
path.nextToken(&token, "\\/");
while (!token.find('.') || path.find('.'))
{
ArchivedDirectoryInfoMap::const_iterator tempiter = dirInfo->m_directories.find(token);
if (tempiter != dirInfo->m_directories.end())
{
dirInfo = &tempiter->second;
path.nextToken(&token, "\\/");
}
else
{
// the directory doesn't exist, so return false
return FALSE;
}
}
// token is the filename, and dirInfo is the directory that this file is in.
if (dirInfo->m_files.find(token) == dirInfo->m_files.end()) {
return FALSE;
}
return TRUE;
}
File * ArchiveFileSystem::openFile(const Char *filename, Int access /* = 0 */)
{
AsciiString archiveFilename;
archiveFilename = getArchiveFilenameForFile(AsciiString(filename));
if (archiveFilename.getLength() == 0) {
return NULL;
}
return m_archiveFileMap[archiveFilename]->openFile(filename, access);
}
Bool ArchiveFileSystem::getFileInfo(const AsciiString& filename, FileInfo *fileInfo) const
{
if (fileInfo == NULL) {
return FALSE;
}
if (filename.getLength() <= 0) {
return FALSE;
}
AsciiString archiveFilename = getArchiveFilenameForFile(filename);
ArchiveFileMap::const_iterator it = m_archiveFileMap.find(archiveFilename);
if (it != m_archiveFileMap.end())
{
return it->second->getFileInfo(filename, fileInfo);
}
else
{
return FALSE;
}
}
// Where two archives hold the same file, loadIntoDirectoryTree keeps whichever was loaded first.
// That is the right rule for content, but Zero Hour ships downscaled copies of a number of the base
// game's textures in TexturesZH.big, and those win over the full-size originals in the base game's
// Textures.big purely because of load order. For the named pair of archives, and only inside the
// named directory, keep whichever copy is actually the larger file.
void ArchiveFileSystem::prioritizeLargerFiles(const AsciiString& directory, const char *inferiorArchive, const char *superiorArchive)
{
// walk down to the directory
AsciiString path = directory;
path.toLower();
AsciiString token;
ArchivedDirectoryInfo *dirInfo = &m_rootDirectory;
while (path.nextToken(&token, "\\/"))
{
ArchivedDirectoryInfoMap::iterator dirIt = dirInfo->m_directories.find(token);
if (dirIt == dirInfo->m_directories.end())
return;
dirInfo = &dirIt->second;
}
// find the archive that holds the bigger copies
ArchiveFile *superior = NULL;
AsciiString superiorName;
for (ArchiveFileMap::iterator archiveIt = m_archiveFileMap.begin(); archiveIt != m_archiveFileMap.end(); ++archiveIt)
{
if (archiveIt->first.endsWithNoCase(superiorArchive))
{
superior = archiveIt->second;
superiorName = archiveIt->first;
break;
}
}
if (superior == NULL)
return;
for (ArchivedFileLocationMap::iterator fileIt = dirInfo->m_files.begin(); fileIt != dirInfo->m_files.end(); ++fileIt)
{
if (!fileIt->second.endsWithNoCase(inferiorArchive))
continue;
ArchiveFileMap::iterator inferiorIt = m_archiveFileMap.find(fileIt->second);
if (inferiorIt == m_archiveFileMap.end())
continue;
AsciiString filePath = directory;
filePath.concat(fileIt->first);
FileInfo inferiorInfo, superiorInfo;
if (!inferiorIt->second->getFileInfo(filePath, &inferiorInfo))
continue;
if (!superior->getFileInfo(filePath, &superiorInfo))
continue;
if (superiorInfo.sizeLow > inferiorInfo.sizeLow)
{
DEBUG_LOG(("ArchiveFileSystem::prioritizeLargerFiles - %s (%d bytes) from %s wins over the %d byte copy in %s\n",
filePath.str(), superiorInfo.sizeLow, superiorName.str(), inferiorInfo.sizeLow, fileIt->second.str()));
fileIt->second = superiorName;
}
}
}
AsciiString ArchiveFileSystem::getArchiveFilenameForFile(const AsciiString& filename) const
{
AsciiString path;
path = filename;
path.toLower();
AsciiString token;
AsciiString debugpath;
const ArchivedDirectoryInfo *dirInfo = &m_rootDirectory;
path.nextToken(&token, "\\/");
while (!token.find('.') || path.find('.')) {
ArchivedDirectoryInfoMap::const_iterator it = dirInfo->m_directories.find(token);
if (it != dirInfo->m_directories.end())
{
dirInfo = &it->second;
}
else
{
// the directory doesn't exist, so return NULL
// dump the directories;
//DEBUG_LOG(("directory %s not found in %s in archive file system\n", token.str(), debugpath.str()));
//DEBUG_LOG(("directories in %s in archive file system are:\n", debugpath.str()));
//ArchivedDirectoryInfoMap::const_iterator it = dirInfo->m_directories.begin();
//while (it != dirInfo->m_directories.end()) {
// DEBUG_LOG(("\t%s\n", it->second.m_directoryName.str()));
// it++;
//}
//DEBUG_LOG(("end of directory list.\n"));
return AsciiString::TheEmptyString;
}
debugpath.concat(token);
debugpath.concat('\\');
path.nextToken(&token, "\\/");
}
ArchivedFileLocationMap::const_iterator it = dirInfo->m_files.find(token);
if (it != dirInfo->m_files.end())
{
return it->second;
}
else
{
return AsciiString::TheEmptyString;
}
}
void ArchiveFileSystem::getFileListInDirectory(const AsciiString& currentDirectory, const AsciiString& originalDirectory, const AsciiString& searchName, FilenameList &filenameList, Bool searchSubdirectories) const
{
ArchiveFileMap::const_iterator it = m_archiveFileMap.begin();
while (it != m_archiveFileMap.end()) {
it->second->getFileListInDirectory(currentDirectory, originalDirectory, searchName, filenameList, searchSubdirectories);
it++;
}
}