Restructured saving/loading and added a stub for Woodruff

svn-id: r31989

1 files changed, 238 insertions, 165 deletions

diff --git a/engines/gob/saveload_v2.cpp b/engines/gob/saveload_v2.cpp
index ab7211b216..2754646198 100644
--- a/engines/gob/saveload_v2.cpp
+++ b/engines/gob/saveload_v2.cpp
@@ -24,273 +24,346 @@
  */
 
 #include "common/endian.h"
-#include "common/file.h"
+#include "common/savefile.h"
 
 #include "gob/gob.h"
 #include "gob/saveload.h"
 #include "gob/global.h"
 #include "gob/game.h"
+#include "gob/draw.h"
 
 namespace Gob {
 
+SaveLoad_v2::SaveFile SaveLoad_v2::_saveFiles[] = {
+	{  "cat.inf", 0, kSaveModeSave, kSaveGame},
+	{  "cat.cat", 0, kSaveModeSave, kSaveGame},
+	{ "save.inf", 0, kSaveModeSave, kSaveTempSprite},
+	{ "bloc.inf", 0, kSaveModeSave, kSaveNotes}
+};
+
 SaveLoad_v2::SaveLoad_v2(GobEngine *vm, const char *targetName) :
-	SaveLoad(vm, targetName) {
+		SaveLoad(vm, targetName) {
+
+	_saveFiles[0].destName = new char[strlen(targetName) + 5];
+	_saveFiles[1].destName = _saveFiles[0].destName;
+	_saveFiles[2].destName = 0;
+	_saveFiles[3].destName = new char[strlen(targetName) + 5];
 
-	_stagesCount = 1;
+	sprintf(_saveFiles[0].destName, "%s.s00", targetName);
+	sprintf(_saveFiles[3].destName, "%s.blo", targetName);
+
+	_varSize = 0;
+	_hasIndex = false;
 }
 
-SaveType SaveLoad_v2::getSaveType(const char *fileName) {
-	const char *backSlash;
-	if ((backSlash = strrchr(fileName, '\\')))
-		fileName = backSlash + 1;
-
-	if (!scumm_stricmp(fileName, "cat.inf"))
-		return kSaveGame;
-	if (!scumm_stricmp(fileName, "cat.cat"))
-		return kSaveGame;
-	if (!scumm_stricmp(fileName, "save.inf"))
-		return kSaveTempSprite;
-	if (!scumm_stricmp(fileName, "bloc.inf"))
-		return kSaveNotes;
-
-	return kSaveNone;
+SaveLoad_v2::~SaveLoad_v2() {
+	delete[] _saveFiles[0].destName;
+	delete[] _saveFiles[3].destName;
 }
 
-uint32 SaveLoad_v2::getSaveGameSize() {
-	return 80 + (READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4) * 2;
+SaveLoad::SaveMode SaveLoad_v2::getSaveMode(const char *fileName) {
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return _saveFiles[i].mode;
+
+	return kSaveModeNone;
 }
 
-int32 SaveLoad_v2::getSizeNotes() {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	int32 size = -1;
+int SaveLoad_v2::getSaveType(const char *fileName) {
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return i;
 
-	in = saveMan->openForLoading(_saveFiles[(int) kSaveNotes]);
-	if (in) {
-		size = in->size();
-		delete in;
+	return -1;
+}
+
+int32 SaveLoad_v2::getSizeVersioned(int type) {
+	assertInited();
+
+	switch (_saveFiles[type].type) {
+	case kSaveGame:
+		return getSizeGame(_saveFiles[type]);
+	case kSaveTempSprite:
+		return getSizeTempSprite(_saveFiles[type]);
+	case kSaveNotes:
+		return getSizeNotes(_saveFiles[type]);
 	}
 
-	return size;
+	return -1;
 }
 
-int32 SaveLoad_v2::getSizeGame() {
+bool SaveLoad_v2::loadVersioned(int type, int16 dataVar, int32 size, int32 offset) {
+	assertInited();
+
+	switch (_saveFiles[type].type) {
+	case kSaveGame:
+		if (loadGame(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While loading from slot %d", getSlot(offset));
+		break;
+
+	case kSaveTempSprite:
+		if(loadTempSprite(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While loading the temporary sprite");
+		break;
+
+	case kSaveNotes:
+		if (loadNotes(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While loading the notes");
+		break;
+	}
+
+	return false;
+}
+
+bool SaveLoad_v2::saveVersioned(int type, int16 dataVar, int32 size, int32 offset) {
+	assertInited();
+
+	switch (_saveFiles[type].type) {
+	case kSaveGame:
+		if (saveGame(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While saving to slot %d", getSlot(offset));
+		break;
+
+	case kSaveTempSprite:
+		if(saveTempSprite(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While saving the temporary sprite");
+		break;
+
+	case kSaveNotes:
+		if (saveNotes(_saveFiles[type], dataVar, size, offset))
+			return true;
+
+		warning("While saving the notes");
+		break;
+	}
+
+	return false;
+}
+
+int SaveLoad_v2::getSlot(int32 offset) const {
+	return ((offset - 600) / _varSize);
+}
+
+int SaveLoad_v2::getSlotRemainder(int32 offset) const {
+	return ((offset - 600) % _varSize);
+}
+
+int32 SaveLoad_v2::getSizeGame(SaveFile &saveFile) {
 	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
 	Common::InSaveFile *in;
 
 	for (int i = 14; i >= 0; i--) {
-		in = saveMan->openForLoading(setCurSlot(i));
+		in = saveMan->openForLoading(setCurrentSlot(saveFile.destName, i));
 		if (in) {
 			delete in;
-			return (i + 1) * READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) *
-				4 + 600;
+			return (i + 1) * _varSize + 600;
 		}
 	}
 
 	return -1;
 }
 
-int32 SaveLoad_v2::getSizeScreenshot() {
-	return -1;
+int32 SaveLoad_v2::getSizeTempSprite(SaveFile &saveFile) {
+	return _tmpSprite.getSize();
 }
 
-bool SaveLoad_v2::loadGame(int16 dataVar, int32 size, int32 offset) {
+int32 SaveLoad_v2::getSizeNotes(SaveFile &saveFile) {
 	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
 	Common::InSaveFile *in;
-	int32 varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
+	int32 size = -1;
+
+	in = saveMan->openForLoading(saveFile.destName);
+	if (in) {
+		size = in->size();
+		delete in;
+	}
+
+	return size;
+}
+
+bool SaveLoad_v2::loadGame(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
 
 	if (size == 0) {
 		dataVar = 0;
-		size = varSize;
+		size = _varSize;
 	}
 
-	int slot = (offset - 600) / varSize;
-	int slotR = (offset - 600) % varSize;
-
-	if ((offset == 0) && (size == 600)) {
+	if (offset == 0) {
+		debugC(3, kDebugSaveLoad, "Loading save index");
 
-		byte *varBuf = _vm->_global->_inter_variables + dataVar;
-		for (int i = 0; i < 15; i++, varBuf += 40) {
-			in = saveMan->openForLoading(setCurSlot(i));
-			if (in) {
-				in->read(varBuf, 40);
-				delete in;
-			} else
-				memset(varBuf, 0, 40);
+		if (size != 600) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
 		}
+
+		SaveLoad::buildIndex(_vm->_global->_inter_variables + dataVar,
+				saveFile.destName, 15, 40);
 		memset(_vm->_global->_inter_variablesSizes + dataVar, 0, 600);
-		return true;
 
-	} else if ((offset > 0) && (slot < 15) &&
-			(slotR == 0) && (size == varSize)) {
+	} else {
+		int slot = getSlot(offset);
+		int slotRem = getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot); 
 
-		in = saveMan->openForLoading(setCurSlot(slot));
-		if (!in) {
-			warning("Can't open file for slot %d", slot);
+		SaveLoad::setCurrentSlot(saveFile.destName, slot);
+
+		if ((slot >= 15) || (slotRem != 0)) {
+			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
 			return false;
 		}
 
-		uint32 sGameSize = getSaveGameSize();
-		uint32 fSize = in->size();
-		if (fSize != sGameSize) {
-			warning("Can't load from slot %d: Wrong size (%d, %d)", slot,
-					fSize, sGameSize);
-			delete in;
+		if (!_save.load(dataVar, size, 40, saveFile.destName,
+					_vm->_global->_inter_variables, _vm->_global->_inter_variablesSizes))
 			return false;
-		}
+	}
 
-		in->seek(80);
-		if (loadDataEndian(*in, dataVar, size)) {
-			delete in;
-			debugC(1, kDebugFileIO, "Loading from slot %d", slot);
-			return true;
-		}
-		delete in;
+	return true;
+}
 
-	} else
-		warning("Invalid loading procedure (%d, %d, %d, %d)",
-				offset, size, slot, slotR);
+bool SaveLoad_v2::loadTempSprite(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
 
-	return false;
-}
+	debugC(3, kDebugSaveLoad, "Loading from the temporary sprite");
 
-bool SaveLoad_v2::loadNotes(int16 dataVar, int32 size, int32 offset) {
-	bool retVal;
+	int index;
+	bool palette;
 
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid attempt at loading the notes (%d, %d)", size, offset);
+	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
 		return false;
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	char *sName = _saveFiles[(int) kSaveNotes];
 
-	Common::InSaveFile *in = saveMan->openForLoading(sName);
-	if (!in) {
-		warning("Can't open file \"%s\" for reading", sName);
+	if (!_tmpSprite.loadSprite(*_vm->_draw->_spritesArray[index]))
 		return false;
+
+	if (palette) {
+		if (!_tmpSprite.loadPalette(_vm->_global->_pPaletteDesc->vgaPal))
+			return false;
+
+		_vm->_video->setFullPalette(_vm->_global->_pPaletteDesc);
 	}
 
-	retVal = loadDataEndian(*in, dataVar, size);
-	delete in;
-	return retVal;
-}
+	if (index == 21) {
+		_vm->_draw->forceBlit();
+		_vm->_video->retrace();
+	}
 
-bool SaveLoad_v2::loadScreenshot(int16 dataVar, int32 size, int32 offset) {
-	return false;
+	return true;
 }
 
-bool SaveLoad_v2::saveGame(int16 dataVar, int32 size, int32 offset) {
-	int32 varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
+bool SaveLoad_v2::loadNotes(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
+
+	debugC(2, kDebugSaveLoad, "Loading the notes");
+
+	return _notes.load(dataVar, size, offset, saveFile.destName,
+			_vm->_global->_inter_variables, _vm->_global->_inter_variablesSizes);
+}
 
-	initBuffer();
+bool SaveLoad_v2::saveGame(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
 
 	if (size == 0) {
 		dataVar = 0;
-		size = varSize;
+		size = _varSize;
 	}
 
-	int slot = (offset - 600) / varSize;
-	int slotR = (offset - 600) % varSize;
+	if (offset == 0) {
+		debugC(3, kDebugSaveLoad, "Saving save index");
 
-	if ((offset == 0) && (size == 600)) {
+		if (size != 600) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
 
-		delete[] _buffer[0];
-		_buffer[0] = new byte[1200];
-		assert(_buffer[0]);
+		memcpy(_indexBuffer, _vm->_global->_inter_variables + dataVar, 600);
+		_hasIndex = true;
 
-		memcpy(_buffer[0], _vm->_global->_inter_variables + dataVar, 600);
-		memset(_buffer[0] + 600, 0, 600);
+	} else {
+		int slot = getSlot(offset);
+		int slotRem = getSlotRemainder(offset);
 
-		return true;
+		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
 
-	} else if ((offset > 0) && (slot < 15) &&
-			(slotR == 0) && (size == varSize)) {
+		SaveLoad::setCurrentSlot(saveFile.destName, slot);
 
-		if (!_buffer[0]) {
-			warning("Tried to save without writing the index first");
+		if ((slot >= 15) || (slotRem != 0)) {
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
 			return false;
 		}
 
-		Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-		Common::OutSaveFile *out;
-
-		out = saveMan->openForSaving(setCurSlot(slot));
-		if (!out) {
-			warning("Can't open file for slot %d for writing", slot);
-			delete[] _buffer[0];
-			_buffer[0] = 0;
+		if (!_hasIndex) {
+			warning("No index written yet");
 			return false;
 		}
 
-		bool retVal = false;
+		_hasIndex = false;
 
-		if (out->write(_buffer[0] + slot * 40, 40) == 40)
-			if (out->write(_buffer[0] + 600 + slot * 40, 40) == 40)
-				if (saveDataEndian(*out, dataVar, size)) {
-					out->finalize();
-					if (!out->ioFailed())
-						retVal = true;
-				}
-
-		if (!retVal)
-			warning("Can't save to slot %d", slot);
-		else
-			debugC(1, kDebugFileIO, "Saved to slot %d", slot);
-
-		delete[] _buffer[0];
-		_buffer[0] = 0;
-		delete out;
+		byte sizes[40];
+		memset(sizes, 0, 40);
+		if(!_save.save(0, 40, 0, saveFile.destName, _indexBuffer + (slot * 40), sizes))
+			return false;
 
-		return retVal;
+		if (!_save.save(dataVar, size, 40, saveFile.destName,
+					_vm->_global->_inter_variables, _vm->_global->_inter_variablesSizes))
+			return false;
 
-	} else
-		warning("Invalid saving procedure (%d, %d, %d, %d)",
-				offset, size, slot, slotR);
+	}
 
-	return false;
+	return true;
 }
 
-bool SaveLoad_v2::saveNotes(int16 dataVar, int32 size, int32 offset) {
-	bool retVal;
+bool SaveLoad_v2::saveTempSprite(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
 
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid attempt at saving the notes (%d, %d)", size, offset);
-		return false;
-	}
+	debugC(3, kDebugSaveLoad, "Saving to the temporary sprite");
 
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	char *sName = _saveFiles[(int) kSaveNotes];
+	int index;
+	bool palette;
 
-	Common::OutSaveFile *out = saveMan->openForSaving(sName);
-	if (!out) {
-		warning("Can't open file \"%s\" for writing", sName);
+	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
 		return false;
-	}
 
-	retVal = saveDataEndian(*out, dataVar, size);
+	if (!_tmpSprite.saveSprite(*_vm->_draw->_spritesArray[index]))
+		return false;
 
-	out->finalize();
-	if (out->ioFailed()) {
-		warning("Can't save notes");
-		retVal = false;
-	}
+	if (palette)
+		if (!_tmpSprite.savePalette(_vm->_global->_pPaletteDesc->vgaPal))
+			return false;
 
-	delete out;
-	return retVal;
+	return true;
 }
 
-bool SaveLoad_v2::saveScreenshot(int16 dataVar, int32 size, int32 offset) {
+bool SaveLoad_v2::saveNotes(SaveFile &saveFile,
+		int16 dataVar, int32 size, int32 offset) {
+
+	debugC(2, kDebugSaveLoad, "Saving the notes");
+
+	return _notes.save(dataVar, size, offset, saveFile.destName,
+			_vm->_global->_inter_variables, _vm->_global->_inter_variablesSizes);
 	return false;
 }
 
-void SaveLoad_v2::initBuffer() {
-	if (_buffer)
+void SaveLoad_v2::assertInited() {
+	if (_varSize > 0)
 		return;
 
-	_buffer = new byte*[_stagesCount];
-	assert(_buffer);
-	_buffer[0] = 0;
+	_varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
+
+	_save.addStage(40);
+	_save.addStage(_varSize);
 }
 
 } // End of namespace Gob