GeneralsZeroHour/Generals/Code/GameEngine/Include/Common/GameState.h

/*
**	Command & Conquer Generals(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/>.
*/

////////////////////////////////////////////////////////////////////////////////
//																																						//
//  (c) 2001-2003 Electronic Arts Inc.																				//
//																																						//
////////////////////////////////////////////////////////////////////////////////

// FILE: GameState.h //////////////////////////////////////////////////////////////////////////////
// Author: Colin Day, September 2002
// Desc:   Game state singleton from which to load and save the game state
///////////////////////////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef __GAME_STATE_H_
#define __GAME_STATE_H_

// INCLUDES ///////////////////////////////////////////////////////////////////////////////////////
#include "Common/STLTypedefs.h"
#include "Common/Snapshot.h"
#include "Common/SubsystemInterface.h"
#include "Common/UnicodeString.h"
#include "GameNetwork/NetworkDefs.h"

// FORWARD REFERENCES /////////////////////////////////////////////////////////////////////////////
class GameWindow;
class WindowLayout;

///////////////////////////////////////////////////////////////////////////////////////////////////
typedef void (*IterateSaveFileCallback)( AsciiString filename, void *userData );

// ------------------------------------------------------------------------------------------------
/** The save/load window is used for a variety of formats, using this type during the 
	* save/load menu initialization you can make that menu allow loading only, or allow
	* both saving and loading from the same menu */
// ------------------------------------------------------------------------------------------------
enum SaveLoadLayoutType
{
	SLLT_INVALID = 0,
	SLLT_SAVE_AND_LOAD,
	SLLT_LOAD_ONLY,
	SLLT_SAVE_ONLY,

	SLLT_NUM_TYPES // keep this last, why? don't know, it's not really used, but we like it this way
};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
struct SaveDate
{

	SaveDate() { year = month = day = dayOfWeek = hour = minute = second = milliseconds = 0; }
	Bool isNewerThan( SaveDate *other );

	UnsignedShort year;
	UnsignedShort month;
	UnsignedShort day;
	UnsignedShort dayOfWeek;
	UnsignedShort hour;
	UnsignedShort minute;
	UnsignedShort second;
	UnsignedShort milliseconds;

};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
enum SaveFileType
{
	SAVE_FILE_TYPE_NORMAL,		///< a regular save game at any arbitrary point in the game
	SAVE_FILE_TYPE_MISSION,		///< a save game in between missions (a mission save)

	SAVE_FILE_TYPE_NUM_TYPES
};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
class SaveGameInfo
{

public:

	SaveGameInfo( void );
	~SaveGameInfo( void );

	AsciiString saveGameMapName;			// map name of the "scratch pad" map extracted from save file
	AsciiString pristineMapName;			// pristine map in the map or user maps directory
	AsciiString mapLabel;							// pretty name of this level set in the editor
	SaveDate date;										// date of file save
	AsciiString campaignSide;					// which campaign side we're playing
	Int missionNumber;								// mission number in campaign
	UnicodeString description;				// user description for save game file
	SaveFileType saveFileType;				// type of save file we're dealing with
	AsciiString missionMapName;				// used for mission saves

};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
struct AvailableGameInfo
{

	AsciiString filename;
	SaveGameInfo saveGameInfo;
	AvailableGameInfo *next;
	AvailableGameInfo *prev;

};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
enum SaveCode
{
	SC_INVALID = -1,
	SC_OK,
	SC_NO_FILE_AVAILABLE,
	SC_FILE_NOT_FOUND,
	SC_UNABLE_TO_OPEN_FILE,
	SC_INVALID_XFER,
	SC_UNKNOWN_BLOCK,
	SC_INVALID_DATA,
	SC_ERROR,
};

enum SnapshotType {
	SNAPSHOT_SAVELOAD,
	SNAPSHOT_DEEPCRC_LOGICONLY,
	SNAPSHOT_DEEPCRC,
	SNAPSHOT_MAX
};

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
class GameState : public SubsystemInterface,
									public Snapshot
{

public:

	GameState( void );
	virtual ~GameState( void );

	// subsystem interface
	virtual void init( void );
	virtual void reset( void );
	virtual void update( void ) { }

	// save game methods
	SaveCode saveGame( AsciiString filename, 
										 UnicodeString desc, 
										 SaveFileType saveType, 
										 SnapshotType which = SNAPSHOT_SAVELOAD  );  ///< save a game
	SaveCode missionSave( void );																	 ///< do a in between mission save
	SaveCode loadGame( AvailableGameInfo gameInfo );							 ///< load a save file
	SaveGameInfo *getSaveGameInfo( void ) { return &m_gameInfo; }

	// snapshot interaction
	void addPostProcessSnapshot( Snapshot *snapshot );					///< add snapshot to post process laod	

	// manipulating files
	Bool doesSaveGameExist( AsciiString filename );							///< does the save file exist
	void populateSaveGameListbox( GameWindow *listbox, SaveLoadLayoutType layoutType );	///< populate listbox with available save games
	void getSaveGameInfoFromFile( AsciiString filename, SaveGameInfo *saveGameInfo );		///< get save game info from file

	void friend_xferSaveDataForCRC( Xfer *xfer, SnapshotType which );		///< This should only be called to DeepCRC sanity checking

	Bool isInLoadGame(void) { return m_isInLoadGame; } // Brutal hack to allow bone pos validation while loading games

	void setPristineMapName( AsciiString name ) { m_gameInfo.pristineMapName = name; }
	AsciiString getPristineMapName( void ) { return m_gameInfo.pristineMapName; }

	AsciiString getSaveDirectory() const;
	AsciiString getFilePathInSaveDirectory(const AsciiString& leaf) const;
	Bool isInSaveDirectory(const AsciiString& path) const;

	AsciiString realMapPathToPortableMapPath(const AsciiString& in) const;
	AsciiString portableMapPathToRealMapPath(const AsciiString& in) const;

	AsciiString getMapLeafName(const AsciiString& in) const;

protected:

	// snapshot methods
	virtual void crc( Xfer *xfer ) { }
	virtual void xfer( Xfer *xfer );
	virtual void loadPostProcess( void ) { }

private:

	AsciiString findNextSaveFilename( UnicodeString desc );			///< find next acceptable filename for a new save game
	void iterateSaveFiles( IterateSaveFileCallback callback, void *userData );	///< iterate save files on disk

	void xferSaveData( Xfer *xfer, SnapshotType which );				///< save/load the file data

	void gameStatePostProcessLoad( void );											///< post process entry point after a game load

	void clearAvailableGames( void );		///< clear any available games resources we got in our list

	struct SnapshotBlock
	{
		Snapshot *snapshot;								///< the snapshot object that handles this block
		AsciiString blockName;						///< the block name
	};	
	typedef std::list< SnapshotBlock > SnapshotBlockList;
	typedef SnapshotBlockList::iterator SnapshotBlockListIterator;
	void addSnapshotBlock( AsciiString blockName, Snapshot *snapshot, SnapshotType which );
	SnapshotBlock *findBlockInfoByToken( AsciiString token, SnapshotType which );

	SnapshotBlockList m_snapshotBlockList[SNAPSHOT_MAX];	///< list of snapshot blocks of save file data
	SaveGameInfo m_gameInfo;						///< save game info struct					

	typedef std::list< Snapshot * > SnapshotList;
	typedef SnapshotList::iterator SnapshotListIterator;
	typedef SnapshotList::reverse_iterator SnapshotListReverseIterator;
	SnapshotList m_snapshotPostProcessList;

	AvailableGameInfo *m_availableGames;		///< list of available games we can save over or load from

	Bool m_isInLoadGame; // Brutal hack to allow bone pos validation while loading games
};

// EXTERNALS //////////////////////////////////////////////////////////////////////////////////////
extern GameState *TheGameState;	


UnicodeString getUnicodeTimeBuffer(SYSTEMTIME timeVal); 
UnicodeString getUnicodeDateBuffer(SYSTEMTIME timeVal); 


#endif  // end __GAME_STATE_H_