Initial commit

src/save/Date.cpp

@@ -0,0 +1,91 @@
+#include "common.h"
+#include "Date.h"
+
+CDate::CDate()
+{
+	m_nYear = 0;
+	m_nSecond = 0;
+	m_nMinute = 0;
+	m_nHour = 0;
+	m_nDay = 0;
+	m_nMonth = 0;
+}
+
+bool
+CDate::operator>(const CDate &right)
+{
+	if (m_nYear > right.m_nYear)
+		return true;
+	if (m_nYear != right.m_nYear)
+		return false;
+
+	if (m_nMonth > right.m_nMonth)
+		return true;
+	if (m_nMonth != right.m_nMonth)
+		return false;
+
+	if (m_nDay > right.m_nDay)
+		return true;
+	if (m_nDay != right.m_nDay)
+		return false;
+
+	if (m_nHour > right.m_nHour)
+		return true;
+	if (m_nHour != right.m_nHour)
+		return false;
+
+	if (m_nMinute > right.m_nMinute)
+		return true;
+	if (m_nMinute != right.m_nMinute)
+		return false;
+	return m_nSecond > right.m_nSecond;
+}
+
+bool
+CDate::operator<(const CDate &right)
+{
+	if (m_nYear < right.m_nYear)
+		return true;
+	if (m_nYear != right.m_nYear)
+		return false;
+
+	if (m_nMonth < right.m_nMonth)
+		return true;
+	if (m_nMonth != right.m_nMonth)
+		return false;
+
+	if (m_nDay < right.m_nDay)
+		return true;
+	if (m_nDay != right.m_nDay)
+		return false;
+
+	if (m_nHour < right.m_nHour)
+		return true;
+	if (m_nHour != right.m_nHour)
+		return false;
+
+	if (m_nMinute < right.m_nMinute)
+		return true;
+	if (m_nMinute != right.m_nMinute)
+		return false;
+	return m_nSecond < right.m_nSecond;
+}
+
+bool
+CDate::operator==(const CDate &right)
+{
+	if (m_nYear != right.m_nYear || m_nMonth != right.m_nMonth || m_nDay != right.m_nDay || m_nHour != right.m_nHour || m_nMinute != right.m_nMinute)
+		return false;
+	return m_nSecond == right.m_nSecond;
+}
+
+void
+CDate::PopulateDateFields(int8 &second, int8 &minute, int8 &hour, int8 &day, int8 &month, int16 year)
+{
+	m_nSecond = second;
+	m_nMinute = minute;
+	m_nHour = hour;
+	m_nDay = day;
+	m_nMonth = month;
+	m_nYear = year;
+}

src/save/Date.h

@@ -0,0 +1,18 @@
+#pragma once
+
+class CDate
+{
+public:
+	int m_nSecond;
+	int m_nMinute;
+	int m_nHour;
+	int m_nDay;
+	int m_nMonth;
+	int m_nYear;
+	
+	CDate();
+	bool operator>(const CDate &right);
+	bool operator<(const CDate &right);
+	bool operator==(const CDate &right);
+	void PopulateDateFields(int8 &second, int8 &minute, int8 &hour, int8 &day, int8 &month, int16 year);
+};

src/save/GenericGameStorage.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "Game.h"
+#include "PCSave.h"
+
+#define SLOT_COUNT (8)
+
+bool GenericSave(int file);
+bool GenericLoad();
+bool ReadInSizeofSaveFileBuffer(int32 &file, uint32 &size);
+bool ReadDataFromFile(int32 file, uint8 *buf, uint32 size);
+bool CloseFile(int32 file);
+void DoGameSpecificStuffAfterSucessLoad();
+bool CheckSlotDataValid(int32 slot);
+void MakeSpaceForSizeInBufferPointer(uint8 *&presize, uint8 *&buf, uint8 *&postsize);
+void CopySizeAndPreparePointer(uint8 *&buf, uint8 *&postbuf, uint8 *&postbuf2, uint32 &unused, uint32 &size);
+void DoGameSpecificStuffBeforeSave();
+void MakeValidSaveName(int32 slot);
+wchar *GetSavedGameDateAndTime(int32 slot);
+wchar *GetNameOfSavedGame(int32 slot);
+bool CheckDataNotCorrupt(int32 slot, char *name);
+bool RestoreForStartLoad();
+int align4bytes(int32 size);
+
+#ifdef FIX_INCOMPATIBLE_SAVES
+uint8 GetSaveType(char *savename);
+bool FixSave(int32 slot, uint8 save_type);
+#endif
+
+extern class CDate CompileDateAndTime;
+
+extern char DefaultPCSaveFileName[260];
+extern char ValidSaveName[260];
+extern char LoadFileName[256];
+extern wchar SlotFileName[SLOT_COUNT][260];
+extern wchar SlotSaveDate[SLOT_COUNT][70];
+extern int CheckSum;
+extern enum eLevelName m_LevelToLoad;
+extern int Slots[SLOT_COUNT+1];
+
+extern bool b_FoundRecentSavedGameWantToLoad;
+extern bool JustLoadedDontFadeInYet;
+extern bool StillToFadeOut;
+extern uint32 TimeStartedCountingForFade;
+extern uint32 TimeToStayFadedBeforeFadeOut;
+
+extern char SaveFileNameJustSaved[260]; // 8F2570
+
+const char TopLineEmptyFile[] = "THIS FILE IS NOT VALID YET";
+
+#ifdef MISSION_REPLAY
+extern int8 IsQuickSave; // originally int
+
+bool SaveGameForPause(int);
+
+enum {
+	SAVE_TYPE_NORMAL,
+	SAVE_TYPE_QUICKSAVE,
+	SAVE_TYPE_2,
+	SAVE_TYPE_QUICKSAVE_FOR_MISSION_REPLAY
+};
+
+#endif

src/save/MemoryCard.h

@@ -0,0 +1,197 @@
+#pragma once
+#include "common.h"
+#ifdef PS2_MENU
+#include "Date.h"
+
+#if defined(PS2)
+#include <libcdvd.h>
+#include <sifdev.h>
+#include <libvu0.h>
+#endif
+
+enum
+{
+	CARD_ONE = 0,
+	CARD_TWO,
+	MAX_CARDS,
+};
+
+class CMemoryCardInfo
+{
+public:
+	int port;
+	int slot;
+	int type;
+	int free;
+	int format;
+	char dir[40];
+#if defined(PS2)
+	sceMcTblGetDir table[15];
+#else
+	struct
+	{
+		typedef struct {unsigned char Sec,Min,Hour; unsigned char Day,Month; unsigned short Year;} _time;
+		_time _Create;
+		_time _Modify;
+		unsigned int FileSizeByte;
+		unsigned short AttrFile;
+		unsigned char EntryName[32];
+	}table[15];
+#endif
+	CMemoryCardInfo(void);
+};
+
+
+#define GUFF_FILE_SIZE 147096
+#define SAVE_FILE_SIZE 201729
+
+class CMemoryCard
+{
+public:
+	enum
+	{
+		MAX_SLOTS = 8,
+	};
+	
+	enum MCSTATE
+	{
+		MCSTATE_OK = 0,
+		MCSTATE_NEED_500KB,
+		MCSTATE_NEED_200KB,
+		MCSTATE_NOCARD,
+	};
+	
+	enum SLOTINFO
+	{
+		SLOT_PRESENT = 0,
+		SLOT_NOTPRESENT,
+		SLOT_CORRUPTED,
+	};
+
+	int             _unk0;
+	int             _unk1;
+	bool            m_bWantToLoad;
+	bool            JustLoadedDontFadeInYet;
+	bool            StillToFadeOut;
+	bool            b_FoundRecentSavedGameWantToLoad;
+	uint32          TimeStartedCountingForFade;
+	uint32          TimeToStayFadedBeforeFadeOut;
+	uint32          LastBlockSize;
+	bool            _bunk2;
+	char            ValidSaveName        [30];
+	char            MostRecentFile       [30];
+	char            _unkName3            [30];
+	char            SaveFileNameJustSaved[30];
+	char _pad0[3];
+	wchar          *pErrorMsg;
+	char            _unk4[32];
+	bool            _bunk5;
+	bool            _bunk6;
+	bool            _bunk7;
+	bool            _bunk8;
+	int             nError;
+	wchar           _unk9[30];
+	char            LoadFileName[30];
+	char _pad1[2];
+	CDate           CompileDateAndTime;
+	int             m_LanguageToLoad;
+	int             m_LevelToLoad;
+	int             CurrentCard;
+	CMemoryCardInfo Cards       [MAX_CARDS];
+	int             Slots       [MAX_SLOTS];
+	wchar           SlotFileName[MAX_SLOTS][30];
+	wchar           SlotSaveDate[MAX_SLOTS][30];
+	char            _unk10[32];
+			
+	enum
+	{
+		ERR_NONE = 0,
+		ERR_NOFORMAT = 1,
+		ERR_DIRNOENTRY = 2,
+		ERR_OPENNOENTRY = 3,
+		ERR_DELETENOENTRY = 4,
+		ERR_DELETEDENIED = 5,
+		ERR_DELETEFAILED = 6,
+		ERR_WRITEFULLDEVICE = 7,
+		ERR_WRITENOENTRY = 8,
+		ERR_WRITEDENIED = 9,
+		ERR_FLUSHNOENTRY,
+		ERR_WRITEFAILED,
+		ERR_FORMATFAILED = 12,
+		ERR_FILETABLENOENTRY = 13,
+		ERR_DIRFULLDEVICE = 14,
+		ERR_DIRBADENTRY = 15,
+		ERR_FILEFULLDEVICE = 16,
+		ERR_FILENOPATHENTRY = 17,
+		ERR_FILEDENIED = 18,
+		ERR_FILEUPLIMIT = 19,
+		ERR_READNOENTRY = 20,
+		ERR_READDENIED = 21,
+		ERR_LOADFAILED = 22, // unused
+		ERR_SAVEFAILED = 23,
+		ERR_DATACORRUPTED = 24,
+		ERR_NOROOTDIR = 25,
+		NO_ERR_SUCCESS = 26,
+	};
+	
+	enum
+	{
+		RES_SUCCESS = 1,
+		RES_FAILED  = -1,
+	};
+
+	int32 GetError()
+	{
+		return nError;
+	}
+
+	wchar *GetErrorMessage()
+	{
+		return pErrorMsg;
+	}
+	
+	int32 Init(void);
+	CMemoryCard(void);
+	int32 RestoreForStartLoad(void);
+	int32 LoadSavedGame(void);
+	int32 CheckCardInserted(int32 cardID);
+	int32 PopulateCardFlags(int32 cardID, bool bSlotFlag, bool bTypeFlag, bool bFreeFlag, bool bFormatFlag);
+	int32 FormatCard(int32 cardID);
+	int32 PopulateFileTable(int32 cardID);
+	int32 CreateRootDirectory(int32 cardID);
+	int32 ChangeDirectory(int32 cardID, char *dir);
+	int32 CreateIconFiles(int32 cardID, char *icon_one, char *icon_two, char *icon_three);
+	int32 LoadIconFiles(int32 cardID, char *icon_one, char *icon_two, char *icon_three);
+	int32 CloseMemCardFile(int32 file);
+	int32 CreateMemCardFileReadWrite(int32 cardID, char *filename);
+	int32 OpenMemCardFileForReading(int32 cardID, char *filename);
+	int32 ReadFromMemCard(int32 file, void *buff, int32 size);
+	int32 DeleteMemoryCardFile(int32 cardID, char *filename);
+	void PopulateErrorMessage();
+	int32 WritetoMemCard(int32 file, void *buff, int32 size);
+	bool SaveGame(void);
+	bool DoHackRoundSTUPIDSonyDateTimeStuff(int32 port, char *filename);
+	int32 LookForRootDirectory(int32 cardID);
+	int32 FillFirstFileWithGuff(int32 cardID);
+	bool FindMostRecentFileName(int32 cardID, char *filename);
+	void ClearFileTableBuffer(int32 cardID);
+	int32 GetClusterAmountForFileCreation(int32 port);
+	bool DeleteEverythingInGameRoot(int32 cardID);
+	int32 CheckDataNotCorrupt(char *filename);
+	int32 GetLanguageToLoad(void);
+	int32 GetLevelToLoad(void);
+	bool CreateGameDirectoryFromScratch(int32 cardID);
+	bool CheckGameDirectoryThere(int32 cardID);
+	void PopulateSlotInfo(int32 cardID);
+	int32 GetInfoOnSpecificSlot(int32 slotID);
+	wchar *GetDateAndTimeOfSavedGame(int32 slotID);
+	int32 CheckCardStateAtGameStartUp(int32 cardID);
+	void SaveSlot(int32 slotID);
+	void DeleteSlot(int32 slotID);
+	void LoadSlotToBuffer(int32 slotID);
+	wchar *GetNameOfSavedGame(int32 slotID);
+	int32 DoClassSaveRoutine(int32 file, uint8 *data, uint32 size);
+};
+
+extern CMemoryCard TheMemoryCard;
+#endif

src/save/PCSave.cpp

@@ -0,0 +1,166 @@
+#define WITHWINDOWS
+#include "common.h"
+#include "crossplatform.h"
+
+#include "FileMgr.h"
+#include "Font.h"
+#ifdef MORE_LANGUAGES
+#include "Game.h"
+#endif
+#include "GenericGameStorage.h"
+#include "Messages.h"
+#include "PCSave.h"
+#include "Text.h"
+
+const char* _psGetUserFilesFolder();
+
+C_PcSave PcSaveHelper;
+
+void
+C_PcSave::SetSaveDirectory(const char *path)
+{
+	sprintf(DefaultPCSaveFileName, "%s\\%s", path, "GTA3sf");
+}
+
+bool
+C_PcSave::DeleteSlot(int32 slot)
+{
+#ifdef FIX_BUGS
+	char FileName[MAX_PATH];
+#else
+	char FileName[200];
+#endif
+
+	PcSaveHelper.nErrorCode = SAVESTATUS_SUCCESSFUL;
+	sprintf(FileName, "%s%i.b", DefaultPCSaveFileName, slot + 1);
+	DeleteFile(FileName);
+	SlotSaveDate[slot][0] = '\0';
+	return true;
+}
+
+bool
+C_PcSave::SaveSlot(int32 slot)
+{
+	MakeValidSaveName(slot);
+	PcSaveHelper.nErrorCode = SAVESTATUS_SUCCESSFUL;
+	_psGetUserFilesFolder();
+	int file = CFileMgr::OpenFile(ValidSaveName, "wb");
+	if (file != 0) {
+#ifdef MISSION_REPLAY
+		if (!IsQuickSave)
+#endif
+			DoGameSpecificStuffBeforeSave();
+		if (GenericSave(file)) {
+			if (!!CFileMgr::CloseFile(file))
+				nErrorCode = SAVESTATUS_ERR_SAVE_CLOSE;
+			return true;
+		}
+
+		return false;
+	}
+	PcSaveHelper.nErrorCode = SAVESTATUS_ERR_SAVE_CREATE;
+	return false;
+}
+
+bool
+C_PcSave::PcClassSaveRoutine(int32 file, uint8 *data, uint32 size)
+{
+	CFileMgr::Write(file, (const char*)&size, sizeof(size));
+	if (CFileMgr::GetErrorReadWrite(file)) {
+		nErrorCode = SAVESTATUS_ERR_SAVE_WRITE;
+		strncpy(SaveFileNameJustSaved, ValidSaveName, sizeof(ValidSaveName) - 1);
+		return false;
+	}
+
+	CFileMgr::Write(file, (const char*)data, align4bytes(size));
+	CheckSum += (uint8) size;
+	CheckSum += (uint8) (size >> 8);
+	CheckSum += (uint8) (size >> 16);
+	CheckSum += (uint8) (size >> 24);
+	for (int i = 0; i < align4bytes(size); i++) {
+		CheckSum += *data++;
+	}
+	if (CFileMgr::GetErrorReadWrite(file)) {
+		nErrorCode = SAVESTATUS_ERR_SAVE_WRITE;
+		strncpy(SaveFileNameJustSaved, ValidSaveName, sizeof(ValidSaveName) - 1);
+		return false;
+	}
+
+	return true;
+}
+
+void
+C_PcSave::PopulateSlotInfo()
+{
+	for (int i = 0; i < SLOT_COUNT; i++) {
+		Slots[i + 1] = SLOT_EMPTY;
+		SlotFileName[i][0] = '\0';
+		SlotSaveDate[i][0] = '\0';
+	}
+	for (int i = 0; i < SLOT_COUNT; i++) {
+#ifdef FIX_BUGS
+		char savename[MAX_PATH];
+#else
+		char savename[52];
+#endif
+		struct {
+			int size;
+			wchar FileName[24];
+			SYSTEMTIME SaveDateTime;
+		} header;
+		sprintf(savename, "%s%i%s", DefaultPCSaveFileName, i + 1, ".b");
+		int file = CFileMgr::OpenFile(savename, "rb");
+		if (file != 0) {
+			CFileMgr::Read(file, (char*)&header, sizeof(header));
+			if (strncmp((char*)&header, TopLineEmptyFile, sizeof(TopLineEmptyFile)-1) != 0) {
+				Slots[i + 1] = SLOT_OK;
+				memcpy(SlotFileName[i], &header.FileName, sizeof(header.FileName));
+				
+				SlotFileName[i][24] = '\0';
+			}
+			CFileMgr::CloseFile(file);
+		}
+		if (Slots[i + 1] == SLOT_OK) {
+			if (CheckDataNotCorrupt(i, savename)) {
+#ifdef FIX_INCOMPATIBLE_SAVES
+				if (!FixSave(i, GetSaveType(savename))) {
+					CMessages::InsertNumberInString(TheText.Get("FEC_SLC"), i + 1, -1, -1, -1, -1, -1, SlotFileName[i]);
+					Slots[i + 1] = SLOT_CORRUPTED;
+					continue;
+				}
+#endif
+				SYSTEMTIME st;
+				memcpy(&st, &header.SaveDateTime, sizeof(SYSTEMTIME));
+				const char *month;
+				switch (st.wMonth)
+				{
+				case 1: month = "JAN"; break;
+				case 2: month = "FEB"; break;
+				case 3: month = "MAR"; break;
+				case 4: month = "APR"; break;
+				case 5: month = "MAY"; break;
+				case 6: month = "JUN"; break;
+				case 7: month = "JUL"; break;
+				case 8: month = "AUG"; break;
+				case 9: month = "SEP"; break;
+				case 10: month = "OCT"; break;
+				case 11: month = "NOV"; break;
+				case 12: month = "DEC"; break;
+				default: assert(0);
+				}
+				char date[70];
+#ifdef MORE_LANGUAGES
+				if (CGame::japaneseGame)
+					sprintf(date, "%02d %02d %04d %02d:%02d:%02d", st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
+				else
+#endif // MORE_LANGUAGES
+					sprintf(date, "%02d %s %04d %02d:%02d:%02d", st.wDay, UnicodeToAsciiForSaveLoad(TheText.Get(month)), st.wYear, st.wHour, st.wMinute, st.wSecond);
+				AsciiToUnicode(date, SlotSaveDate[i]);
+
+			} else {
+				CMessages::InsertNumberInString(TheText.Get("FEC_SLC"), i + 1, -1, -1, -1, -1, -1, SlotFileName[i]);
+				Slots[i + 1] = SLOT_CORRUPTED;
+			}
+		}
+	}
+}

src/save/PCSave.h

@@ -0,0 +1,40 @@
+#pragma once
+
+enum eSaveStatus
+{
+	SAVESTATUS_SUCCESSFUL = 0,
+	SAVESTATUS_ERR_SAVE_CREATE,
+	SAVESTATUS_ERR_SAVE_WRITE,
+	SAVESTATUS_ERR_SAVE_CLOSE,
+	SAVESTATUS_ERR_LOAD_OPEN,
+	SAVESTATUS_ERR_LOAD_READ,
+	SAVESTATUS_ERR_LOAD_CLOSE,
+	SAVESTATUS_ERR_DATA_INVALID,
+
+	// unused
+	SAVESTATUS_DELETEFAILED8,
+	SAVESTATUS_DELETEFAILED9,
+	SAVESTATUS_DELETEFAILED10,
+};
+
+enum
+{
+	SLOT_OK = 0,
+	SLOT_EMPTY,
+	SLOT_CORRUPTED
+};
+
+class C_PcSave
+{
+public:
+	eSaveStatus nErrorCode;
+
+	C_PcSave() : nErrorCode(SAVESTATUS_SUCCESSFUL) {}
+	void PopulateSlotInfo();
+	bool DeleteSlot(int32 slot);
+	bool SaveSlot(int32 slot);
+	bool PcClassSaveRoutine(int32 file, uint8 *data, uint32 size);
+	static void SetSaveDirectory(const char *path);
+};
+
+extern C_PcSave PcSaveHelper;

src/save/SaveBuf.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#ifdef VALIDATE_SAVE_SIZE
+extern int32 _saveBufCount;
+#define INITSAVEBUF _saveBufCount = 0;
+#define VALIDATESAVEBUF(b) assert(_saveBufCount == b);
+#else
+#define INITSAVEBUF
+#define VALIDATESAVEBUF(b)
+#endif
+
+inline void
+SkipSaveBuf(uint8 *&buf, int32 skip)
+{
+	buf += skip;
+#ifdef VALIDATE_SAVE_SIZE
+	_saveBufCount += skip;
+#endif
+}
+
+template <typename T>
+inline void
+ReadSaveBuf(T* out, uint8 *&buf)
+{
+	*out = *(T *)buf;
+	SkipSaveBuf(buf, sizeof(T));
+}
+
+template <typename T>
+inline T *
+WriteSaveBuf(uint8 *&buf, const T &value)
+{
+	T *p = (T *)buf;
+	*p = value;
+	SkipSaveBuf(buf, sizeof(T));
+	return p;
+}
+
+#ifdef COMPATIBLE_SAVES
+inline void
+ZeroSaveBuf(uint8 *&buf, uint32 length)
+{
+	memset(buf, 0, length);
+	SkipSaveBuf(buf, length);
+}
+#endif
+
+#define SAVE_HEADER_SIZE (4 * sizeof(char) + sizeof(uint32))
+
+#define WriteSaveHeader(buf, a, b, c, d, size) \
+	WriteSaveBuf(buf, a); \
+	WriteSaveBuf(buf, b); \
+	WriteSaveBuf(buf, c); \
+	WriteSaveBuf(buf, d); \
+	WriteSaveBuf(buf, (uint32)(size));
+
+#ifdef VALIDATE_SAVE_SIZE
+#define CheckSaveHeader(buf, a, b, c, d, size) do { \
+	char _c; uint32 _size;\
+	ReadSaveBuf(&_c, buf);\
+	assert(_c == a);\
+	ReadSaveBuf(&_c, buf);\
+	assert(_c == b);\
+	ReadSaveBuf(&_c, buf);\
+	assert(_c == c);\
+	ReadSaveBuf(&_c, buf);\
+	assert(_c == d);\
+	ReadSaveBuf(&_size, buf);\
+	assert(_size == size);\
+	} while(0)
+#else
+#define CheckSaveHeader(buf, a, b, c, d, size) SkipSaveBuf(buf, 8);
+#endif