- A new save system for the GobEngine, one that is not fundamentally broken and is versioned. Unfortunately, this invalidates most save games created on big-endian machines, since endian-issues was a main problem with the old system

- Removed the now superfluous variables sizes

svn-id: r41056

37 files changed, 5760 insertions, 3219 deletions

diff --git a/engines/gob/gob.cpp b/engines/gob/gob.cpp
index fbdc339c12..ec8b0989a3 100644
--- a/engines/gob/gob.cpp
+++ b/engines/gob/gob.cpp
@@ -47,7 +47,7 @@
 #include "gob/parse.h"
 #include "gob/scenery.h"
 #include "gob/videoplayer.h"
-#include "gob/saveload.h"
+#include "gob/save/saveload.h"
 
 namespace Gob {
 
@@ -368,7 +368,7 @@ bool GobEngine::initGameParts() {
 		_map = new Map_v2(this);
 		_goblin = new Goblin_v3(this);
 		_scenery = new Scenery_v2(this);
-		_saveLoad = new SaveLoad_v3(this, _targetName.c_str());
+		_saveLoad = new SaveLoad_v3(this, _targetName.c_str(), SaveLoad_v3::kScreenshotTypeGob3);
 		break;
 
 	case kGameTypeLostInTime:
@@ -382,7 +382,7 @@ bool GobEngine::initGameParts() {
 		_map = new Map_v2(this);
 		_goblin = new Goblin_v3(this);
 		_scenery = new Scenery_v2(this);
-		_saveLoad = new SaveLoad_v3(this, _targetName.c_str(), 4768, 0, 50);
+		_saveLoad = new SaveLoad_v3(this, _targetName.c_str(), SaveLoad_v3::kScreenshotTypeLost);
 		break;
 
 	case kGameTypeWoodruff:
@@ -413,7 +413,7 @@ bool GobEngine::initGameParts() {
 		_map = new Map_v4(this);
 		_goblin = new Goblin_v4(this);
 		_scenery = new Scenery_v2(this);
-		_saveLoad = new SaveLoad_v4(this, _targetName.c_str());
+		_saveLoad = new SaveLoad(this, _targetName.c_str());
 		break;
 
 	case kGameTypeAdibou4:
diff --git a/engines/gob/gob.h b/engines/gob/gob.h
index d13c334906..8a6985b0dd 100644
--- a/engines/gob/gob.h
+++ b/engines/gob/gob.h
@@ -65,8 +65,8 @@ class SaveLoad;
 #define READ_VARO_UINT32(off)       _vm->_inter->_variables->readOff32(off)
 #define READ_VARO_UINT16(off)       _vm->_inter->_variables->readOff16(off)
 #define READ_VARO_UINT8(off)        _vm->_inter->_variables->readOff8(off)
-#define GET_VAR_STR(var)            _vm->_inter->_variables->getAddressVarString(var, 0)
-#define GET_VARO_STR(off)           _vm->_inter->_variables->getAddressOffString(off, 0)
+#define GET_VAR_STR(var)            _vm->_inter->_variables->getAddressVarString(var)
+#define GET_VARO_STR(off)           _vm->_inter->_variables->getAddressOffString(off)
 #define GET_VAR_FSTR(var)           _vm->_inter->_variables->getAddressVarString(var)
 #define GET_VARO_FSTR(off)          _vm->_inter->_variables->getAddressOffString(off)
 
@@ -78,11 +78,14 @@ class SaveLoad;
 #define VAR(var)                    READ_VAR_UINT32(var)
 
 
+// WARNING: Reordering these will invalidate save games!
 enum Endianness {
 	kEndiannessLE,
 	kEndiannessBE
 };
 
+// WARNING: Reordering these will invalidate save games!
+//          Add new games to the bottom of the list.
 enum GameType {
 	kGameTypeNone = 0,
 	kGameTypeGob1,
diff --git a/engines/gob/helper.h b/engines/gob/helper.h
index 3e4e3387bc..5bedf81014 100644
--- a/engines/gob/helper.h
+++ b/engines/gob/helper.h
@@ -49,6 +49,22 @@ inline char *strdupcpy(const char *str) {
 	return nstr;
 }
 
+/** A strcat that new[]s the buffer. */
+inline char *strdupcat(const char *str1, const char *str2) {
+	if (!str1 || !str2)
+		return 0;
+
+	size_t len1 = strlen(str1);
+	size_t len2 = strlen(str2);
+
+	char *nstr = new char[len1 + len2 + 1];
+
+	memcpy(nstr, str1, len1);
+	memcpy(nstr + len1, str2, len2 + 1);
+
+	return nstr;
+}
+
 /** A "smart" reference counting templated class. */
 template<typename T>
 class ReferenceCounter {
diff --git a/engines/gob/inter.cpp b/engines/gob/inter.cpp
index 4bcf3c81cd..ce7f2ba319 100644
--- a/engines/gob/inter.cpp
+++ b/engines/gob/inter.cpp
@@ -56,7 +56,6 @@ Inter::Inter(GobEngine *vm) : _vm(vm) {
 	_soundStopVal = 0;
 
 	memset(_varStack, 0, 300);
-	memset(_varSizesStack, 0, 300);
 	_varStackPos = 0;
 
 	_noBusyWait = false;
diff --git a/engines/gob/inter.h b/engines/gob/inter.h
index 1ba98141f4..ee49658318 100644
--- a/engines/gob/inter.h
+++ b/engines/gob/inter.h
@@ -92,7 +92,6 @@ protected:
 	int16 _animPalDir[8];
 
 	byte _varStack[300];
-	byte _varSizesStack[300];
 	int16 _varStackPos;
 
 	// The busy-wait detection in o1_keyFunc breaks fast scrolling in Ween
diff --git a/engines/gob/inter_v1.cpp b/engines/gob/inter_v1.cpp
index ecc5ad48c5..a9b4519cca 100644
--- a/engines/gob/inter_v1.cpp
+++ b/engines/gob/inter_v1.cpp
@@ -948,8 +948,7 @@ void Inter_v1::o1_initMult() {
 			_vm->_mult->_objects[i].pPosY = new VariableReference(*_vm->_inter->_variables, offPosY);
 
 			_vm->_mult->_objects[i].pAnimData =
-				(Mult::Mult_AnimData *) _variables->getAddressOff8(offAnim,
-						_vm->_global->_inter_animDataSize);
+				(Mult::Mult_AnimData *) _variables->getAddressOff8(offAnim);
 
 			_vm->_mult->_objects[i].pAnimData->isStatic = 1;
 			_vm->_mult->_objects[i].tick = 0;
@@ -2234,7 +2233,7 @@ bool Inter_v1::o1_readData(OpFuncParams &params) {
 		if (((dataVar >> 2) == 59) && (size == 4))
 			WRITE_VAR(59, stream->readUint32LE());
 		else
-			retSize = stream->read((byte *) _variables->getAddressOff8(dataVar, size), size);
+			retSize = stream->read((byte *) _variables->getAddressOff8(dataVar), size);
 
 		if (retSize == size)
 			WRITE_VAR(1, 0);
diff --git a/engines/gob/inter_v2.cpp b/engines/gob/inter_v2.cpp
index e0ccc06d94..2f501772dc 100644
--- a/engines/gob/inter_v2.cpp
+++ b/engines/gob/inter_v2.cpp
@@ -42,7 +42,7 @@
 #include "gob/parse.h"
 #include "gob/scenery.h"
 #include "gob/video.h"
-#include "gob/saveload.h"
+#include "gob/save/saveload.h"
 #include "gob/videoplayer.h"
 #include "gob/sound/sound.h"
 
@@ -890,8 +890,7 @@ void Inter_v2::o2_initMult() {
 			_vm->_mult->_objects[i].pPosY = new VariableReference(*_vm->_inter->_variables, offPosY);
 
 			_vm->_mult->_objects[i].pAnimData =
-				(Mult::Mult_AnimData *) _variables->getAddressOff8(offAnim,
-						_vm->_global->_inter_animDataSize);
+				(Mult::Mult_AnimData *) _variables->getAddressOff8(offAnim);
 
 			_vm->_mult->_objects[i].pAnimData->isStatic = 1;
 			_vm->_mult->_objects[i].tick = 0;
@@ -1162,23 +1161,18 @@ void Inter_v2::o2_pushVars() {
 			varOff = _vm->_parse->parseVarIndex();
 			_vm->_global->_inter_execPtr++;
 
-			_variables->copyTo(varOff, _varStack + _varStackPos,
-					_varSizesStack + _varStackPos,
-					_vm->_global->_inter_animDataSize * 4);
+			_variables->copyTo(varOff, _varStack + _varStackPos, _vm->_global->_inter_animDataSize * 4);
 
 			_varStackPos += _vm->_global->_inter_animDataSize * 4;
 			_varStack[_varStackPos] = _vm->_global->_inter_animDataSize * 4;
-			_varSizesStack[_varStackPos] = _vm->_global->_inter_animDataSize * 4;
 
 		} else {
 			if (evalExpr(&varOff) != 20)
 				_vm->_global->_inter_resVal = 0;
 
 			memcpy(_varStack + _varStackPos, &_vm->_global->_inter_resVal, 4);
-			memcpy(_varSizesStack + _varStackPos, &_vm->_global->_inter_resVal, 4);
 			_varStackPos += 4;
 			_varStack[_varStackPos] = 4;
-			_varSizesStack[_varStackPos] = 4;
 		}
 	}
 }
@@ -1186,19 +1180,15 @@ void Inter_v2::o2_pushVars() {
 void Inter_v2::o2_popVars() {
 	byte count;
 	int16 varOff;
-	int16 sizeV;
-	int16 sizeS;
+	int16 size;
 
 	count = *_vm->_global->_inter_execPtr++;
 	for (int i = 0; i < count; i++) {
 		varOff = _vm->_parse->parseVarIndex();
-		sizeV = _varStack[--_varStackPos];
-		sizeS = _varSizesStack[_varStackPos];
-		assert(sizeV == sizeS);
+		size = _varStack[--_varStackPos];
 
-		_varStackPos -= sizeV;
-		_variables->copyFrom(varOff, _varStack + _varStackPos,
-				_varSizesStack + _varStackPos, sizeV);
+		_varStackPos -= size;
+		_variables->copyFrom(varOff, _varStack + _varStackPos, size);
 	}
 }
 
@@ -1934,7 +1924,7 @@ bool Inter_v2::o2_readData(OpFuncParams &params) {
 		size = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
 	}
 
-	buf = _variables->getAddressOff8(dataVar, size);
+	buf = _variables->getAddressOff8(dataVar);
 
 	if (_vm->_global->_inter_resStr[0] == 0) {
 		WRITE_VAR(1, size);
diff --git a/engines/gob/map_v2.cpp b/engines/gob/map_v2.cpp
index bd9f5b3efc..db4f2075e1 100644
--- a/engines/gob/map_v2.cpp
+++ b/engines/gob/map_v2.cpp
@@ -56,12 +56,12 @@ void Map_v2::loadMapObjects(const char *avjFile) {
 	uint32 passPos;
 
 	var = _vm->_parse->parseVarIndex();
-	variables = _vm->_inter->_variables->getAddressOff8(var, 0);
+	variables = _vm->_inter->_variables->getAddressOff8(var);
 
 	id = _vm->_inter->load16();
 
 	if (id == -1) {
-		_passMap = (int8 *) _vm->_inter->_variables->getAddressOff8(var, 0);
+		_passMap = (int8 *) _vm->_inter->_variables->getAddressOff8(var);
 		return;
 	}
 
@@ -105,7 +105,7 @@ void Map_v2::loadMapObjects(const char *avjFile) {
 	tmpPos = mapData.pos();
 	mapData.seek(passPos);
 	if ((variables != 0) &&
-	    (variables != _vm->_inter->_variables->getAddressOff8(0, 0))) {
+	    (variables != _vm->_inter->_variables->getAddressOff8(0))) {
 
 		_passMap = (int8 *) variables;
 		mapHeight = _screenHeight / _tilesHeight;
@@ -114,7 +114,7 @@ void Map_v2::loadMapObjects(const char *avjFile) {
 		for (int i = 0; i < mapHeight; i++) {
 			for (int j = 0; j < mapWidth; j++)
 				setPass(j, i, mapData.readSByte());
-			_vm->_inter->_variables->getAddressOff8(var + i * _passWidth, mapWidth);
+			_vm->_inter->_variables->getAddressOff8(var + i * _passWidth);
 		}
 	}
 	mapData.seek(tmpPos);
diff --git a/engines/gob/map_v4.cpp b/engines/gob/map_v4.cpp
index 3a74c4b6aa..858e7972bc 100644
--- a/engines/gob/map_v4.cpp
+++ b/engines/gob/map_v4.cpp
@@ -54,7 +54,7 @@ void Map_v4::loadMapObjects(const char *avjFile) {
 	uint32 passPos;
 
 	var = _vm->_parse->parseVarIndex();
-	variables = _vm->_inter->_variables->getAddressOff8(var, 0);
+	variables = _vm->_inter->_variables->getAddressOff8(var);
 
 	id = _vm->_inter->load16();
 
@@ -62,7 +62,7 @@ void Map_v4::loadMapObjects(const char *avjFile) {
 		warning("Woodruff Stub: loadMapObjects ID >= 65520");
 		return;
 	} else if (id == -1) {
-		_passMap = (int8 *) _vm->_inter->_variables->getAddressOff8(var, 0);
+		_passMap = (int8 *) _vm->_inter->_variables->getAddressOff8(var);
 		return;
 	}
 
@@ -121,7 +121,7 @@ void Map_v4::loadMapObjects(const char *avjFile) {
 	tmpPos = mapData.pos();
 	mapData.seek(passPos);
 	if ((variables != 0) &&
-	    (variables != _vm->_inter->_variables->getAddressOff8(0, 0))) {
+	    (variables != _vm->_inter->_variables->getAddressOff8(0))) {
 
 		_passMap = (int8 *) variables;
 		mapHeight = _screenHeight / _tilesHeight;
@@ -130,7 +130,7 @@ void Map_v4::loadMapObjects(const char *avjFile) {
 		for (int i = 0; i < mapHeight; i++) {
 			for (int j = 0; j < mapWidth; j++)
 				setPass(j, i, mapData.readSByte());
-			_vm->_inter->_variables->getAddressOff8(var + i * _passWidth, mapWidth);
+			_vm->_inter->_variables->getAddressOff8(var + i * _passWidth);
 		}
 	}
 	mapData.seek(tmpPos);
diff --git a/engines/gob/module.mk b/engines/gob/module.mk
index 3cc16fa5fd..9111db9121 100644
--- a/engines/gob/module.mk
+++ b/engines/gob/module.mk
@@ -46,11 +46,6 @@ MODULE_OBJS := \
 	parse.o \
 	parse_v1.o \
 	parse_v2.o \
-	saveload.o \
-	saveload_v2.o \
-	saveload_v3.o \
-	saveload_v4.o \
-	saveload_v6.o \
 	scenery.o \
 	scenery_v1.o \
 	scenery_v2.o \
@@ -63,6 +58,18 @@ MODULE_OBJS := \
 	demos/demoplayer.o \
 	demos/scnplayer.o \
 	demos/batplayer.o \
+	save/savefile.o \
+	save/savehandler.o \
+	save/saveload.o \
+	save/saveload_v2.o \
+	save/saveload_v3.o \
+	save/saveload_v4.o \
+	save/saveload_v6.o \
+	save/saveconverter.o \
+	save/saveconverter_v2.o \
+	save/saveconverter_v3.o \
+	save/saveconverter_v4.o \
+	save/saveconverter_v6.o \
 	sound/sound.o \
 	sound/sounddesc.o \
 	sound/pcspeaker.o \
diff --git a/engines/gob/parse.cpp b/engines/gob/parse.cpp
index 4c949183e0..81a7da6389 100644
--- a/engines/gob/parse.cpp
+++ b/engines/gob/parse.cpp
@@ -44,7 +44,7 @@ int32 Parse::encodePtr(byte *ptr, int type) {
 		offset = ptr - _vm->_game->_totFileData;
 		break;
 	case kInterVar:
-		offset = ptr - ((byte *) _vm->_inter->_variables->getAddressOff8(0, 0));
+		offset = ptr - ((byte *) _vm->_inter->_variables->getAddressOff8(0));
 		break;
 	case kResStr:
 		offset = ptr - ((byte *) _vm->_global->_inter_resStr);
@@ -64,7 +64,7 @@ byte *Parse::decodePtr(int32 n) {
 		ptr = _vm->_game->_totFileData;
 		break;
 	case kInterVar:
-		ptr = (byte *) _vm->_inter->_variables->getAddressOff8(0, 0);
+		ptr = (byte *) _vm->_inter->_variables->getAddressOff8(0);
 		break;
 	case kResStr:
 		ptr = (byte *) _vm->_global->_inter_resStr;
diff --git a/engines/gob/parse_v1.cpp b/engines/gob/parse_v1.cpp
index 427a2b5184..c993d6ca70 100644
--- a/engines/gob/parse_v1.cpp
+++ b/engines/gob/parse_v1.cpp
@@ -375,7 +375,7 @@ int16 Parse_v1::parseExpr(byte stopToken, byte *arg_2) {
 			case OP_LOAD_VAR_STR:
 				*operPtr = OP_LOAD_IMM_STR;
 				temp = _vm->_inter->load16() * 4;
-				*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(temp, 0),
+				*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(temp),
 						kInterVar);
 				if (*_vm->_global->_inter_execPtr == 13) {
 					_vm->_global->_inter_execPtr++;
@@ -404,7 +404,7 @@ int16 Parse_v1::parseExpr(byte stopToken, byte *arg_2) {
 					break;
 				}
 				*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(
-							temp * 4 + offset * _vm->_global->_inter_animDataSize * 4, 0),
+							temp * 4 + offset * _vm->_global->_inter_animDataSize * 4),
 						kInterVar);
 				if (*_vm->_global->_inter_execPtr == 13) {
 					_vm->_global->_inter_execPtr++;
diff --git a/engines/gob/parse_v2.cpp b/engines/gob/parse_v2.cpp
index 327638194e..e7f91650b5 100644
--- a/engines/gob/parse_v2.cpp
+++ b/engines/gob/parse_v2.cpp
@@ -554,7 +554,7 @@ int16 Parse_v2::parseExpr(byte stopToken, byte *arg_2) {
 					*valPtr = (int16) READ_VARO_UINT16(varPos + temp * 2 + offset * 2);
 				else if (operation == OP_ARRAY_STR) {
 					*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(
-								varPos + temp * 4 + offset * _vm->_global->_inter_animDataSize * 4, 0),
+								varPos + temp * 4 + offset * _vm->_global->_inter_animDataSize * 4),
 							kInterVar);
 					if (*_vm->_global->_inter_execPtr == 13) {
 						_vm->_global->_inter_execPtr++;
@@ -612,7 +612,7 @@ int16 Parse_v2::parseExpr(byte stopToken, byte *arg_2) {
 			case OP_LOAD_VAR_STR:
 				*operPtr = OP_LOAD_IMM_STR;
 				temp = _vm->_inter->load16() * 4;
-				*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(varPos + temp, 0), kInterVar);
+				*valPtr = encodePtr(_vm->_inter->_variables->getAddressOff8(varPos + temp), kInterVar);
 				if (*_vm->_global->_inter_execPtr == 13) {
 					_vm->_global->_inter_execPtr++;
 					temp += parseValExpr(OP_END_MARKER);
diff --git a/engines/gob/save/saveconverter.cpp b/engines/gob/save/saveconverter.cpp
new file mode 100644
index 0000000000..4b24311e93
--- /dev/null
+++ b/engines/gob/save/saveconverter.cpp
@@ -0,0 +1,443 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveconverter.h"
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+#include "gob/helper.h"
+
+namespace Gob {
+
+SaveConverter::SaveConverter(GobEngine *vm, const char *fileName) : _vm(vm) {
+	_fileName = strdupcpy(fileName);
+
+	_data = 0;
+	_stream = 0;
+}
+
+SaveConverter::~SaveConverter() {
+	delete[] _fileName;
+
+	delete _stream;
+	delete[] _data;
+}
+
+void SaveConverter::clear() {
+	delete[] _data;
+	delete _stream;
+
+	_data = 0;
+	_stream = 0;
+}
+
+void SaveConverter::setFileName(const char *fileName) {
+	clear();
+
+	delete[] _fileName;
+
+	_fileName = strdupcpy(fileName);
+}
+
+Common::InSaveFile *SaveConverter::openSave() const {
+	if (!_fileName)
+		return 0;
+
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+	return saveMan->openForLoading(_fileName);
+}
+
+void SaveConverter::displayWarning() const {
+	warning("Old save format detected, trying to convert. If this does not work, your "
+	        "save is broken and can't be used anymore. Sorry for the inconvenience");
+}
+
+char *SaveConverter::getDescription(const char *fileName) {
+	setFileName(fileName);
+	return getDescription();
+}
+
+char *SaveConverter::getDescription() const {
+	Common::InSaveFile *save;
+
+	// Test if it's an old savd
+	if (!isOldSave(&save) || !save)
+		return 0;
+
+	char *desc = getDescription(*save);
+
+	delete save;
+	return desc;
+}
+
+uint32 SaveConverter::getActualSize(Common::InSaveFile **save) const {
+	Common::InSaveFile *saveFile = openSave();
+
+	if (!saveFile)
+		return false;
+
+	// Is it a valid new save?
+	if (SaveContainer::isSave(*saveFile)) {
+		delete saveFile;
+		return false;
+	}
+
+	int32 saveSize = saveFile->size();
+
+	if (saveSize <= 0) {
+		delete saveFile;
+		return 0;
+	}
+
+	if (save)
+		*save = saveFile;
+	else
+		delete saveFile;
+
+	return saveSize;
+}
+
+bool SaveConverter::swapDataEndian(byte *data, const byte *sizes, uint32 count) {
+	if (!data || !sizes || (count == 0))
+		return false;
+
+	while (count-- > 0) {
+		if      (*sizes == 3) // 32bit value (3 additional bytes)
+			*((uint32 *) data) = SWAP_BYTES_32(*((uint32 *) data));
+		else if (*sizes == 1) // 16bit value (1 additional byte)
+			*((uint16 *) data) = SWAP_BYTES_16(*((uint16 *) data));
+		else if (*sizes != 0) // else, it has to be an 8bit value
+			return false;
+
+		count -= *sizes;
+		data += *sizes + 1;
+		sizes += *sizes + 1;
+	}
+
+	return true;
+}
+
+SavePartInfo *SaveConverter::readInfo(Common::SeekableReadStream &stream,
+	uint32 descLength, bool hasSizes) const {
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return 0;
+
+	char *desc = getDescription(stream);
+	if (!desc)
+		return 0;
+
+	// If it has sizes, skip them
+	if (hasSizes)
+		if (!stream.skip(descLength)) {
+			delete[] desc;
+			return 0;
+		}
+
+	SavePartInfo *info = new SavePartInfo(descLength, (uint32) _vm->getGameType(),
+			0, _vm->getEndianness(), varSize);
+
+	info->setDesc(desc);
+
+	delete[] desc;
+
+	return info;
+}
+
+byte *SaveConverter::readData(Common::SeekableReadStream &stream,
+		uint32 count, bool endian) const {
+
+	byte *data = new byte[count];
+
+	// Read variable data
+	if (stream.read(data, count) != count) {
+		delete[] data;
+		return 0;
+	}
+
+	/* Check the endianness. The old save data was always written
+	 * as little endian, so we might need to swap the bytes. */
+
+	if (endian && (_vm->getEndianness() == kEndiannessBE)) {
+		// Big endian => swapping needed
+
+		// Read variable sizes
+		byte *sizes = new byte[count];
+		if (stream.read(sizes, count) != count) {
+			delete[] data;
+			delete[] sizes;
+			return 0;
+		}
+
+		// Swap bytes
+		if (!swapDataEndian(data, sizes, count)) {
+			delete[] data;
+			delete[] sizes;
+			return 0;
+		}
+
+		delete[] sizes;
+
+	} else {
+		// Little endian => just skip the sizes part
+
+		if (!stream.skip(count)) {
+			delete[] data;
+			return 0;
+		}
+	}
+
+	return data;
+}
+
+SavePartVars *SaveConverter::readVars(Common::SeekableReadStream &stream,
+		uint32 count, bool endian) const {
+
+	byte *data = readData(stream, count, endian);
+	if (!data)
+		return 0;
+
+	SavePartVars *vars = new SavePartVars(_vm, count);
+
+	// Read variables into part
+	if (!vars->readFromRaw(data, count)) {
+		delete[] data;
+		delete vars;
+		return 0;
+	}
+
+	delete[] data;
+	return vars;
+}
+
+SavePartMem *SaveConverter::readMem(Common::SeekableReadStream &stream,
+		uint32 count, bool endian) const {
+
+	byte *data = readData(stream, count, endian);
+	if (!data)
+		return 0;
+
+	SavePartMem *mem = new SavePartMem(count);
+
+	// Read mem into part
+	if (!mem->readFrom(data, 0, count)) {
+		delete[] data;
+		delete mem;
+		return 0;
+	}
+
+	delete[] data;
+	return mem;
+}
+
+SavePartSprite *SaveConverter::readSprite(Common::SeekableReadStream &stream,
+		uint32 width, uint32 height, bool palette) const {
+
+	assert((width > 0) && (height > 0));
+
+	uint32 spriteSize = width * height;
+
+	byte pal[768];
+	if (palette)
+		if (stream.read(pal, 768) != 768)
+			return 0;
+
+	byte *data = new byte[spriteSize];
+
+	// Read variable data
+	if (stream.read(data, spriteSize) != spriteSize) {
+		delete[] data;
+		return 0;
+	}
+
+	SavePartSprite *sprite = new SavePartSprite(width, height);
+
+	if (!sprite->readSpriteRaw(data, spriteSize)) {
+		delete[] data;
+		return 0;
+	}
+
+	delete[] data;
+
+	if (palette)
+		if (!sprite->readPalette(pal))
+			return 0;
+
+	return sprite;
+}
+
+bool SaveConverter::createStream(SaveWriter &writer) {
+	// Allocate memory for the internal new save data
+	uint32 contSize = writer.getSize();
+	_data = new byte[contSize];
+
+	// Save the newly created new save data
+	Common::MemoryWriteStream writeStream(_data, contSize);
+	if (!writer.save(writeStream))
+		return false;
+
+	// Create a reading stream upon that new save data
+	_stream = new Common::MemoryReadStream(_data, contSize);
+
+	return true;
+}
+
+/* Stream functions. If the new save data stream is available, redirect the stream
+ * operations to that stream. Normal stream error behaviour if not. */
+
+bool SaveConverter::err() const {
+	if (!_data || !_stream)
+		return true;
+
+	return _stream->err();
+}
+
+void SaveConverter::clearErr() {
+	if (!_data || !_stream)
+		return;
+
+	_stream->clearErr();
+}
+
+bool SaveConverter::eos() const {
+	if (!_data || !_stream)
+		return true;
+
+	return _stream->eos();
+}
+
+uint32 SaveConverter::read(void *dataPtr, uint32 dataSize) {
+	if (!_data || !_stream)
+		return 0;
+
+	return _stream->read(dataPtr, dataSize);
+}
+
+int32 SaveConverter::pos() const {
+	if (!_data || !_stream)
+		return -1;
+
+	return _stream->pos();
+}
+
+int32 SaveConverter::size() const {
+	if (!_data || !_stream)
+		return -1;
+
+	return _stream->size();
+}
+
+bool SaveConverter::seek(int32 offset, int whence) {
+	if (!_data || !_stream)
+		return false;
+
+	return _stream->seek(offset, whence);
+}
+
+
+SaveConverter_Notes::SaveConverter_Notes(GobEngine *vm, uint32 notesSize,
+		const char *fileName) : SaveConverter(vm, fileName) {
+
+	_size = notesSize;
+}
+
+SaveConverter_Notes::~SaveConverter_Notes() {
+}
+
+int SaveConverter_Notes::isOldSave(Common::InSaveFile **save) const {
+	if (_size == 0)
+		return 0;
+
+	uint32 saveSize = getActualSize(save);
+	if (saveSize == 0)
+		return 0;
+
+	// The size of the old save always follows that rule
+	if (saveSize == (_size * 2))
+		return 1;
+
+	// Not an old save, clean up
+	if (save) {
+		delete *save;
+		*save = 0;
+	}
+
+	return 0;
+}
+
+char *SaveConverter_Notes::getDescription(Common::SeekableReadStream &save) const  {
+	return 0;
+}
+
+bool SaveConverter_Notes::loadFail(SavePartVars *vars, Common::InSaveFile *save) {
+	delete vars;
+	delete save;
+
+	clear();
+
+	return false;
+}
+
+// Loads the old save by constructing a new save containing the old save's data
+bool SaveConverter_Notes::load() {
+	if (_size == 0)
+		return false;
+
+	Common::InSaveFile *save;
+
+	// Test if it's an old savd
+	if (!isOldSave(&save) || !save)
+		return false;
+
+	displayWarning();
+
+	SaveWriter writer(1, 0);
+
+	SavePartVars *vars = readVars(*save, _size, false);
+	if (!vars)
+		return loadFail(0, save);
+
+	// We don't need the save anymore
+	delete save;
+
+	// Write all parts
+	if (!writer.writePart(0, vars))
+		return loadFail(0, 0);
+
+	// We don't need this anymore
+	delete vars;
+
+	// Create the final read stream
+	if (!createStream(writer))
+		return loadFail(0, 0);
+
+	return true;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveconverter.h b/engines/gob/save/saveconverter.h
new file mode 100644
index 0000000000..f40a2d4b40
--- /dev/null
+++ b/engines/gob/save/saveconverter.h
@@ -0,0 +1,206 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef GOB_SAVE_SAVECONVERTER_H
+#define GOB_SAVE_SAVECONVERTER_H
+
+#include "common/stream.h"
+
+namespace Gob {
+
+class GobEngine;
+class SavePartInfo;
+class SavePartVars;
+class SavePartMem;
+class SavePartSprite;
+class SaveWriter;
+
+/** A wrapping stream class for old saves. */
+class SaveConverter : public Common::SeekableReadStream {
+public:
+	SaveConverter(GobEngine *vm, const char *fileName = 0);
+	virtual ~SaveConverter();
+
+	/** Clear the converter. */
+	virtual void clear();
+	/** Set the filename on which to operate. */
+	virtual void setFileName(const char *fileName);
+
+	/** Is it actually an old save? */
+	virtual int isOldSave(Common::InSaveFile **save = 0) const = 0;
+	/** Directly return the description without processing the whole save. */
+	virtual char *getDescription(Common::SeekableReadStream &save) const = 0;
+	/** Load the whole save. */
+	virtual bool load() = 0;
+
+	/** Set the name and return the description. */
+	char *getDescription(const char *fileName);
+	/** Get the current fileName's description. */
+	char *getDescription() const;
+
+	// Stream
+	virtual bool err() const;
+	virtual void clearErr();
+	// ReadStream
+	virtual bool eos() const;
+	virtual uint32 read(void *dataPtr, uint32 dataSize);
+	// SeekableReadStream
+	virtual int32 pos() const;
+	virtual int32 size() const;
+	virtual bool seek(int32 offset, int whence = SEEK_SET);
+
+protected:
+	GobEngine *_vm;
+
+	char *_fileName;
+
+	byte *_data;
+	Common::MemoryReadStream *_stream;
+
+	Common::InSaveFile *openSave() const;
+
+	/** Write a warning to stdout to notify the user what's going on. */
+	virtual void displayWarning() const;
+
+	virtual uint32 getActualSize(Common::InSaveFile **save = 0) const;
+
+	SavePartInfo *readInfo(Common::SeekableReadStream &stream,
+		uint32 descLength, bool hasSizes = true) const;
+	SavePartVars *readVars(Common::SeekableReadStream &stream,
+			uint32 count, bool endian) const;
+	SavePartMem *readMem(Common::SeekableReadStream &stream,
+			uint32 count, bool endian) const;
+	SavePartSprite *readSprite(Common::SeekableReadStream &stream,
+			uint32 width, uint32 height, bool palette) const;
+
+	bool createStream(SaveWriter &writer);
+
+	/** Swap the endianness of the complete data area. */
+	static bool swapDataEndian(byte *data, const byte *sizes, uint32 count);
+
+private:
+	byte *readData(Common::SeekableReadStream &stream,
+			uint32 count, bool endian) const;
+};
+
+/** A wrapper for old notes saves. */
+class SaveConverter_Notes : public SaveConverter {
+public:
+	SaveConverter_Notes(GobEngine *vm, uint32 notesSize, const char *fileName = 0);
+	~SaveConverter_Notes();
+
+	int isOldSave(Common::InSaveFile **save = 0) const;
+	char *getDescription(Common::SeekableReadStream &save) const;
+
+	bool load();
+
+private:
+	uint32 _size;
+
+	bool loadFail(SavePartVars *vars, Common::InSaveFile *save);
+};
+
+/** A wrapper for old v2-style saves (Gobliins 2, Ween: The Prophecy and Bargon Attack). */
+class SaveConverter_v2 : public SaveConverter {
+public:
+	SaveConverter_v2(GobEngine *vm, const char *fileName = 0);
+	~SaveConverter_v2();
+
+	int isOldSave(Common::InSaveFile **save = 0) const;
+	char *getDescription(Common::SeekableReadStream &save) const;
+
+	bool load();
+
+private:
+	static const uint32 kSlotCount = 15;
+	static const uint32 kSlotNameLength = 40;
+
+	bool loadFail(SavePartInfo *info, SavePartVars *vars,
+			Common::InSaveFile *save);
+};
+
+/** A wrapper for old v3-style saves (Goblins 3 and Lost in Time). */
+class SaveConverter_v3 : public SaveConverter {
+public:
+	SaveConverter_v3(GobEngine *vm, const char *fileName = 0);
+	~SaveConverter_v3();
+
+	int isOldSave(Common::InSaveFile **save = 0) const;
+	char *getDescription(Common::SeekableReadStream &save) const;
+
+	bool load();
+
+private:
+	static const uint32 kSlotCount = 30;
+	static const uint32 kSlotNameLength = 40;
+
+	bool loadFail(SavePartInfo *info, SavePartVars *vars,
+			SavePartSprite *sprite, Common::InSaveFile *save);
+
+	void getScreenShotProps(int type,
+			bool &used, uint32 &width, uint32 &height);
+};
+
+/** A wrapper for old v4-style saves (Woodruff). */
+class SaveConverter_v4 : public SaveConverter {
+public:
+	SaveConverter_v4(GobEngine *vm, const char *fileName = 0);
+	~SaveConverter_v4();
+
+	int isOldSave(Common::InSaveFile **save = 0) const;
+	char *getDescription(Common::SeekableReadStream &save) const;
+
+	bool load();
+
+private:
+	static const uint32 kSlotCount = 60;
+	static const uint32 kSlotNameLength = 40;
+
+	bool loadFail(SavePartInfo *info, SavePartVars *vars,
+			SavePartMem *props, Common::InSaveFile *save);
+};
+
+/** A wrapper for old v6-style saves (Urban Runner). */
+class SaveConverter_v6 : public SaveConverter {
+public:
+	SaveConverter_v6(GobEngine *vm, const char *fileName = 0);
+	~SaveConverter_v6();
+
+	int isOldSave(Common::InSaveFile **save = 0) const;
+	char *getDescription(Common::SeekableReadStream &save) const;
+
+	bool load();
+
+private:
+	static const uint32 kSlotCount = 15;
+	static const uint32 kSlotNameLength = 40;
+
+	bool loadFail(SavePartInfo *info, SavePartVars *vars,
+			Common::InSaveFile *save);
+};
+
+} // End of namespace Gob
+
+#endif // GOB_SAVE_SAVECONVERTER_H
diff --git a/engines/gob/save/saveconverter_v2.cpp b/engines/gob/save/saveconverter_v2.cpp
new file mode 100644
index 0000000000..96ed949753
--- /dev/null
+++ b/engines/gob/save/saveconverter_v2.cpp
@@ -0,0 +1,135 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveconverter.h"
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+
+namespace Gob {
+
+SaveConverter_v2::SaveConverter_v2(GobEngine *vm, const char *fileName) :
+	SaveConverter(vm, fileName) {
+}
+
+SaveConverter_v2::~SaveConverter_v2() {
+}
+
+int SaveConverter_v2::isOldSave(Common::InSaveFile **save) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return 0;
+
+	uint32 saveSize = getActualSize(save);
+	if (saveSize == 0)
+		return 0;
+
+	// The size of the old save always follows that rule
+	if (saveSize == (varSize * 2 + kSlotNameLength * 2))
+		return 1;
+
+	// Not an old save, clean up
+	if (save) {
+		delete *save;
+		*save = 0;
+	}
+
+	return 0;
+}
+
+char *SaveConverter_v2::getDescription(Common::SeekableReadStream &save) const {
+	char *desc = new char[kSlotNameLength];
+
+	// Read the description
+	if (save.read(desc, kSlotNameLength) != kSlotNameLength) {
+		delete desc;
+		return 0;
+	}
+
+	return desc;
+}
+
+bool SaveConverter_v2::loadFail(SavePartInfo *info, SavePartVars *vars,
+		Common::InSaveFile *save) {
+
+	delete info;
+	delete vars;
+	delete save;
+
+	clear();
+
+	return false;
+}
+
+// Loads the old save by constructing a new save containing the old save's data
+bool SaveConverter_v2::load() {
+	clear();
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return false;
+
+	Common::InSaveFile *save;
+
+	// Test if it's an old savd
+	if (!isOldSave(&save) || !save)
+		return false;
+
+	displayWarning();
+
+	SaveWriter writer(2, 0);
+
+	SavePartInfo *info = readInfo(*save, kSlotNameLength);
+	if (!info)
+		return loadFail(0, 0, save);
+
+	SavePartVars *vars = readVars(*save, varSize, true);
+	if (!vars)
+		return loadFail(info, 0, save);
+
+	// We don't need the save anymore
+	delete save;
+
+	// Write all parts
+	if (!writer.writePart(0, info))
+		return loadFail(info, vars, 0);
+	if (!writer.writePart(1, vars))
+		return loadFail(info, vars, 0);
+
+	// We don't need those anymore
+	delete info;
+	delete vars;
+
+	// Create the final read stream
+	if (!createStream(writer))
+		return loadFail(0, 0, 0);
+
+	return true;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveconverter_v3.cpp b/engines/gob/save/saveconverter_v3.cpp
new file mode 100644
index 0000000000..d707268d9c
--- /dev/null
+++ b/engines/gob/save/saveconverter_v3.cpp
@@ -0,0 +1,188 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveconverter.h"
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+
+namespace Gob {
+
+SaveConverter_v3::SaveConverter_v3(GobEngine *vm, const char *fileName) :
+	SaveConverter(vm, fileName) {
+}
+
+SaveConverter_v3::~SaveConverter_v3() {
+}
+
+int SaveConverter_v3::isOldSave(Common::InSaveFile **save) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return 0;
+
+	uint32 saveSize = getActualSize(save);
+	if (saveSize == 0)
+		return 0;
+
+	// The size of the old save always follows one of these rules
+	if (saveSize == (varSize * 2 + kSlotNameLength + 1000))
+		return 1; // No screenshot
+	if (saveSize == (varSize * 2 + kSlotNameLength + 1000 + 19968))
+		return 2; // Big screenshot, Goblins 3
+	if (saveSize == (varSize * 2 + kSlotNameLength + 1000 + 4768))
+		return 3; // Small screenshot, Lost in Time
+
+	// Not an old save, clean up
+	if (save) {
+		delete *save;
+		*save = 0;
+	}
+
+	return 0;
+}
+
+char *SaveConverter_v3::getDescription(Common::SeekableReadStream &save) const {
+	// The description starts at 1000
+	if (!save.seek(1000))
+		return 0;
+
+	char *desc = new char[kSlotNameLength];
+
+	// Read the description
+	if (save.read(desc, kSlotNameLength) != kSlotNameLength) {
+		delete desc;
+		return 0;
+	}
+
+	return desc;
+}
+
+bool SaveConverter_v3::loadFail(SavePartInfo *info, SavePartVars *vars,
+		SavePartSprite *sprite, Common::InSaveFile *save) {
+
+	delete info;
+	delete vars;
+	delete sprite;
+	delete save;
+
+	clear();
+
+	return false;
+}
+
+void SaveConverter_v3::getScreenShotProps(int type,
+		bool &used, uint32 &width, uint32 &height) {
+
+	switch (type) {
+	case 2:
+		used   = true;
+		width  = 120;
+		height = 160;
+		break;
+
+	case 3:
+		used   = true;
+		width  = 80;
+		height = 50;
+		break;
+
+	default:
+		used   = false;
+		width  = 0;
+		height = 0;
+		break;
+	}
+}
+
+// Loads the old save by constructing a new save containing the old save's data
+bool SaveConverter_v3::load() {
+	clear();
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return false;
+
+	Common::InSaveFile *save;
+
+	int type = isOldSave(&save);
+
+	// Test if it's an old savd
+	if ((type == 0) || !save)
+		return false;
+
+	displayWarning();
+
+	bool screenShot;
+	uint32 screenShotWidth;
+	uint32 screenShotHeight;
+
+	getScreenShotProps(type, screenShot, screenShotWidth, screenShotHeight);
+
+	SaveWriter writer(screenShot ? 3 : 2, 0);
+
+	SavePartInfo *info = readInfo(*save, kSlotNameLength, false);
+	if (!info)
+		return loadFail(0, 0, 0, save);
+
+	SavePartVars *vars = readVars(*save, varSize, true);
+	if (!vars)
+		return loadFail(info, 0, 0, save);
+
+	if (screenShot) {
+		SavePartSprite *sprite = readSprite(*save, screenShotWidth, screenShotHeight, true);
+
+		if (!sprite)
+			return loadFail(info, vars, 0, save);
+
+		if (!writer.writePart(2, sprite))
+			return loadFail(info, vars, sprite, save);
+
+		delete sprite;
+	}
+
+	// We don't need the save anymore
+	delete save;
+
+	// Write all parts
+	if (!writer.writePart(0, info))
+		return loadFail(info, vars, 0, 0);
+	if (!writer.writePart(1, vars))
+		return loadFail(info, vars, 0, 0);
+
+	// We don't need those anymore
+	delete info;
+	delete vars;
+
+	// Create the final read stream
+	if (!createStream(writer))
+		return loadFail(0, 0, 0, 0);
+
+	return true;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveconverter_v4.cpp b/engines/gob/save/saveconverter_v4.cpp
new file mode 100644
index 0000000000..23273446d1
--- /dev/null
+++ b/engines/gob/save/saveconverter_v4.cpp
@@ -0,0 +1,147 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveconverter.h"
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+
+namespace Gob {
+
+SaveConverter_v4::SaveConverter_v4(GobEngine *vm, const char *fileName) :
+	SaveConverter(vm, fileName) {
+}
+
+SaveConverter_v4::~SaveConverter_v4() {
+}
+
+int SaveConverter_v4::isOldSave(Common::InSaveFile **save) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return 0;
+
+	uint32 saveSize = getActualSize(save);
+	if (saveSize == 0)
+		return 0;
+
+	// The size of the old save always follows that rule
+	if (saveSize == (varSize * 2 + kSlotNameLength + 1000 + 512000))
+		return 1;
+
+	// Not an old save, clean up
+	if (save) {
+		delete *save;
+		*save = 0;
+	}
+
+	return 0;
+}
+
+char *SaveConverter_v4::getDescription(Common::SeekableReadStream &save) const {
+	// The description starts at 1000
+	if (!save.seek(1000))
+		return 0;
+
+	char *desc = new char[kSlotNameLength];
+
+	// Read the description
+	if (save.read(desc, kSlotNameLength) != kSlotNameLength) {
+		delete desc;
+		return 0;
+	}
+
+	return desc;
+}
+
+bool SaveConverter_v4::loadFail(SavePartInfo *info, SavePartVars *vars,
+		SavePartMem *props, Common::InSaveFile *save) {
+
+	delete info;
+	delete vars;
+	delete props;
+	delete save;
+
+	clear();
+
+	return false;
+}
+
+// Loads the old save by constructing a new save containing the old save's data
+bool SaveConverter_v4::load() {
+	clear();
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return false;
+
+	Common::InSaveFile *save;
+
+	// Test if it's an old savd
+	if (!isOldSave(&save) || !save)
+		return false;
+
+	displayWarning();
+
+	SaveWriter writer(3, 0);
+
+	SavePartInfo *info = readInfo(*save, kSlotNameLength, false);
+	if (!info)
+		return loadFail(0, 0, 0, save);
+
+	SavePartVars *vars = readVars(*save, varSize, true);
+	if (!vars)
+		return loadFail(info, 0, 0, save);
+
+	SavePartMem *props = readMem(*save, 256000, true);
+	if (!props)
+		return loadFail(info, vars, 0, save);
+
+	// We don't need the save anymore
+	delete save;
+
+	// Write all parts
+	if (!writer.writePart(0, info))
+		return loadFail(info, vars, props, 0);
+	if (!writer.writePart(1, vars))
+		return loadFail(info, vars, props, 0);
+	if (!writer.writePart(2, props))
+		return loadFail(info, vars, props, 0);
+
+	// We don't need those anymore
+	delete info;
+	delete vars;
+	delete props;
+
+	// Create the final read stream
+	if (!createStream(writer))
+		return loadFail(0, 0, 0, 0);
+
+	return true;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveconverter_v6.cpp b/engines/gob/save/saveconverter_v6.cpp
new file mode 100644
index 0000000000..01818e8191
--- /dev/null
+++ b/engines/gob/save/saveconverter_v6.cpp
@@ -0,0 +1,135 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveconverter.h"
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+
+namespace Gob {
+
+SaveConverter_v6::SaveConverter_v6(GobEngine *vm, const char *fileName) :
+	SaveConverter(vm, fileName) {
+}
+
+SaveConverter_v6::~SaveConverter_v6() {
+}
+
+int SaveConverter_v6::isOldSave(Common::InSaveFile **save) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return 0;
+
+	uint32 saveSize = getActualSize(save);
+	if (saveSize == 0)
+		return 0;
+
+	// The size of the old save always follows that rule
+	if (saveSize == (varSize * 2 + kSlotNameLength * 2))
+		return 1;
+
+	// Not an old save, clean up
+	if (save) {
+		delete *save;
+		*save = 0;
+	}
+
+	return 0;
+}
+
+char *SaveConverter_v6::getDescription(Common::SeekableReadStream &save) const {
+	char *desc = new char[kSlotNameLength];
+
+	// Read the description
+	if (save.read(desc, kSlotNameLength) != kSlotNameLength) {
+		delete desc;
+		return 0;
+	}
+
+	return desc;
+}
+
+bool SaveConverter_v6::loadFail(SavePartInfo *info, SavePartVars *vars,
+		Common::InSaveFile *save) {
+
+	delete info;
+	delete vars;
+	delete save;
+
+	clear();
+
+	return false;
+}
+
+// Loads the old save by constructing a new save containing the old save's data
+bool SaveConverter_v6::load() {
+	clear();
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+	if (varSize == 0)
+		return false;
+
+	Common::InSaveFile *save;
+
+	// Test if it's an old savd
+	if (!isOldSave(&save) || !save)
+		return false;
+
+	displayWarning();
+
+	SaveWriter writer(2, 0);
+
+	SavePartInfo *info = readInfo(*save, kSlotNameLength);
+	if (!info)
+		return loadFail(0, 0, save);
+
+	SavePartVars *vars = readVars(*save, varSize, true);
+	if (!vars)
+		return loadFail(info, 0, save);
+
+	// We don't need the save anymore
+	delete save;
+
+	// Write all parts
+	if (!writer.writePart(0, info))
+		return loadFail(info, vars, 0);
+	if (!writer.writePart(1, vars))
+		return loadFail(info, vars, 0);
+
+	// We don't need those anymore
+	delete info;
+	delete vars;
+
+	// Create the final read stream
+	if (!createStream(writer))
+		return loadFail(0, 0, 0);
+
+	return true;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/savefile.cpp b/engines/gob/save/savefile.cpp
new file mode 100644
index 0000000000..0f7ebfd0bf
--- /dev/null
+++ b/engines/gob/save/savefile.cpp
@@ -0,0 +1,979 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/util.h"
+#include "common/endian.h"
+#include "common/system.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/savefile.h"
+#include "gob/video.h"
+#include "gob/helper.h"
+#include "gob/inter.h"
+#include "gob/variables.h"
+
+namespace Gob {
+
+static inline bool flushStream(Common::WriteStream &stream) {
+	// Flush and check for errors
+
+	if (!stream.flush())
+		return false;
+	if (stream.err())
+		return false;
+
+	return true;
+}
+
+SaveHeader::SaveHeader(uint32 type, uint32 version, uint32 size) {
+	_type = type;
+	_version = version;
+	_size = size;
+}
+
+bool SaveHeader::read(Common::ReadStream &stream) {
+	// Read the header and verify the global IDs
+	if (stream.readUint32BE() != kID1)
+		return false;
+	if (stream.readUint32BE() != kID2)
+		return false;
+
+	_type = stream.readUint32BE();
+	_version = stream.readUint32LE();
+	_size = stream.readUint32LE();
+
+	return !stream.err();
+}
+
+bool SaveHeader::verify(Common::ReadStream &stream) const {
+	// Compare the header with the stream's content
+
+	if (stream.readUint32BE() != kID1)
+		return false;
+	if (stream.readUint32BE() != kID2)
+		return false;
+	if (stream.readUint32BE() != _type)
+		return false;
+	if (stream.readUint32LE() != _version)
+		return false;
+	if (stream.readUint32LE() != _size)
+		return false;
+
+	return !stream.err();
+}
+
+bool SaveHeader::verifyReadSize(Common::ReadStream &stream) {
+	// Compare the header with the stream's content, expect for the size
+
+	if (stream.readUint32BE() != kID1)
+		return false;
+	if (stream.readUint32BE() != kID2)
+		return false;
+	if (stream.readUint32BE() != _type)
+		return false;
+	if (stream.readUint32LE() != _version)
+		return false;
+
+	// Read the size out of the stream instead
+	_size = stream.readUint32LE();
+
+	return !stream.err();
+}
+
+bool SaveHeader::write(Common::WriteStream &stream) const {
+	stream.writeUint32BE(kID1);
+	stream.writeUint32BE(kID2);
+	stream.writeUint32BE(_type);
+	stream.writeUint32LE(_version);
+	stream.writeUint32LE(_size);
+
+	return flushStream(stream);
+}
+
+uint32 SaveHeader::getType() const {
+	return _type;
+}
+
+uint32 SaveHeader::getVersion() const {
+	return _version;
+}
+
+uint32 SaveHeader::getSize() const {
+	return _size;
+}
+
+void SaveHeader::setType(uint32 type) {
+	_type = type;
+}
+
+void SaveHeader::setVersion(uint32 version) {
+	_version = version;
+}
+
+void SaveHeader::setSize(uint32 size) {
+	_size = size;
+}
+
+SavePart::SavePart() {
+}
+
+SavePart::~SavePart() {
+}
+
+uint32 SavePart::getSize() const {
+	// A part's size is the content's size plus the header's size
+	return _header.getSize() + SaveHeader::kSize;
+}
+
+SavePartMem::SavePartMem(uint32 size) : SavePart(), _size(size) {
+	_header.setType(kID);
+	_header.setVersion(kVersion);
+	_header.setSize(size);
+
+	_data = new byte[size];
+}
+
+SavePartMem::~SavePartMem() {
+	delete[] _data;
+}
+
+bool SavePartMem::read(Common::ReadStream &stream) {
+	if (!_header.verify(stream))
+		return false;
+
+	if (stream.read(_data, _size) != _size)
+		return false;
+
+	return !stream.err();
+}
+
+bool SavePartMem::write(Common::WriteStream &stream) const {
+	if (!_header.write(stream))
+		return false;
+
+	if (stream.write(_data, _size) != _size)
+		return false;
+
+	return flushStream(stream);
+}
+
+bool SavePartMem::readFrom(const byte *data, uint32 offset, uint32 size) {
+	if ((offset + size) > _size)
+		return false;
+
+	memcpy(_data + offset, data, size);
+
+	return true;
+}
+
+bool SavePartMem::writeInto(byte *data, uint32 offset, uint32 size) const {
+	if ((offset + size) > _size)
+		return false;
+
+	memcpy(data, _data + offset, size);
+
+	return true;
+}
+
+SavePartVars::SavePartVars(GobEngine *vm, uint32 size) : SavePart(), _size(size), _vm(vm) {
+	_header.setType(kID);
+	_header.setVersion(kVersion);
+	_header.setSize(size);
+
+	_data = new byte[size];
+}
+
+SavePartVars::~SavePartVars() {
+	delete[] _data;
+}
+
+bool SavePartVars::read(Common::ReadStream &stream) {
+	if (!_header.verify(stream))
+		return false;
+
+	if (stream.read(_data, _size) != _size)
+		return false;
+
+	return !stream.err();
+}
+
+bool SavePartVars::write(Common::WriteStream &stream) const {
+	if (!_header.write(stream))
+		return false;
+
+	if (stream.write(_data, _size) != _size)
+		return false;
+
+	return flushStream(stream);
+}
+
+bool SavePartVars::readFrom(uint32 var, uint32 offset, uint32 size) {
+	if (!_vm->_inter->_variables)
+		return false;
+
+	if ((offset + size) > _size)
+		return false;
+
+	// Get raw variables
+	return _vm->_inter->_variables->copyTo(var, _data + offset, size);
+}
+
+bool SavePartVars::readFromRaw(const byte *data, uint32 size) {
+	if (size != _size)
+		return false;
+
+	memcpy(_data, data, size);
+	return true;
+}
+
+bool SavePartVars::writeInto(uint32 var, uint32 offset, uint32 size) const {
+	if (!_vm->_inter->_variables)
+		return false;
+
+	if ((offset + size) > _size)
+		return false;
+
+	// Write raw variables
+	if (!_vm->_inter->_variables->copyFrom(var, _data + offset, size))
+		return false;
+
+	return true;
+}
+
+SavePartSprite::SavePartSprite(uint32 width, uint32 height) {
+	assert((width > 0) && (height > 0));
+
+	_width = width;
+	_height = height;
+
+	_header.setType(kID);
+	_header.setVersion(kVersion);
+	//            width + height +      sprite      + palette
+	_header.setSize(4   +   4    + _width * _height +  768);
+
+	_dataSprite  = new byte[_width * _height];
+	_dataPalette = new byte[768];
+
+	memset(_dataSprite,  0, _width * _height);
+	memset(_dataPalette, 0, 768);
+}
+
+SavePartSprite::~SavePartSprite() {
+	delete[] _dataSprite;
+	delete[] _dataPalette;
+}
+
+bool SavePartSprite::read(Common::ReadStream &stream) {
+	if (!_header.verify(stream))
+		return false;
+
+	// The sprite's dimensions have to fit
+	if (stream.readUint32LE() != _width)
+		return false;
+	if (stream.readUint32LE() != _height)
+		return false;
+
+	// Sprite data
+	if (stream.read(_dataSprite, _width * _height) != (_width * _height))
+		return false;
+
+	// Palette data
+	if (stream.read(_dataPalette, 768) != 768)
+		return false;
+
+	return !stream.err();
+}
+
+bool SavePartSprite::write(Common::WriteStream &stream) const {
+	if (!_header.write(stream))
+		return false;
+
+	// The sprite's dimensions
+	stream.writeUint32LE(_width);
+	stream.writeUint32LE(_height);
+
+	// Sprite data
+	if (stream.write(_dataSprite, _width * _height) != (_width * _height))
+		return false;
+
+	// Palette data
+	if (stream.write(_dataPalette, 768) != 768)
+		return false;
+
+	return flushStream(stream);
+}
+
+bool SavePartSprite::readPalette(const byte *palette) {
+	memcpy(_dataPalette, palette, 768);
+
+	return true;
+}
+
+bool SavePartSprite::readSprite(const SurfaceDesc *sprite) {
+	if (!sprite)
+		return false;
+
+	// The sprite's dimensions have to fit
+	if (((uint32) sprite->getWidth()) != _width)
+		return false;
+	if (((uint32) sprite->getHeight()) != _height)
+		return false;
+
+	memcpy(_dataSprite, sprite->getVidMem(), _width * _height);
+
+	return true;
+}
+
+bool SavePartSprite::readSpriteRaw(const byte *data, uint32 size) {
+	if (size != (_width * _height))
+		return false;
+
+	memcpy(_dataSprite, data, size);
+	return true;
+}
+
+bool SavePartSprite::writePalette(byte *palette) const {
+	memcpy(palette, _dataPalette, 768);
+
+	return true;
+}
+
+bool SavePartSprite::writeSprite(SurfaceDesc *sprite) const {
+	if (!sprite)
+		return false;
+
+	// The sprite's dimensions have to fit
+	if (((uint32) sprite->getWidth()) != _width)
+		return false;
+	if (((uint32) sprite->getHeight()) != _height)
+		return false;
+
+	memcpy(sprite->getVidMem(), _dataSprite, _width * _height);
+
+	return true;
+}
+
+SavePartInfo::SavePartInfo(uint32 descMaxLength, uint32 gameID,
+		uint32 gameVersion, byte endian, uint32 varCount) {
+
+	_header.setType(kID);
+	_header.setVersion(kVersion);
+	//                        descMaxLength + gameID + gameVersion + endian + varCount
+	_header.setSize(descMaxLength + 4       +   4    +     4       +    1   +    4);
+
+	_descMaxLength = descMaxLength;
+	_gameID = gameID;
+	_gameVersion = gameVersion;
+	_endian = endian;
+	_varCount = varCount;
+
+	_desc = new char[_descMaxLength + 1];
+	memset(_desc, 0, _descMaxLength + 1);
+}
+
+SavePartInfo::~SavePartInfo() {
+	delete[] _desc;
+}
+
+const char *SavePartInfo::getDesc() const {
+	return _desc;
+}
+
+uint32 SavePartInfo::getDescMaxLength() const {
+	return _descMaxLength;
+}
+
+void SavePartInfo::setVarCount(uint32 varCount) {
+	_varCount = varCount;
+}
+
+void SavePartInfo::setDesc(const char *desc) {
+	if (!desc) {
+		memset(_desc, 0, _descMaxLength + 1);
+		return;
+	}
+
+	uint32 n = MIN<uint32>(strlen(desc), _descMaxLength);
+
+	// Copy the description and fill with 0
+	memcpy(_desc, desc, n);
+	memset(_desc + n, 0, _descMaxLength + 1 - n);
+}
+
+void SavePartInfo::setDesc(const byte *desc, uint32 size) {
+	if (!desc || !size) {
+		memset(_desc, 0, _descMaxLength + 1);
+		return;
+	}
+
+	uint32 n = MIN<uint32>(size, _descMaxLength);
+	memcpy(_desc, desc, n);
+	memset(_desc + n, 0, _descMaxLength + 1 - n);
+}
+
+bool SavePartInfo::read(Common::ReadStream &stream) {
+	if (!_header.verify(stream))
+		return false;
+
+	if (stream.readUint32LE() != _gameID)
+		return false;
+	if (stream.readUint32LE() != _gameVersion)
+		return false;
+	if (stream.readByte() != _endian)
+		return false;
+	if (stream.readUint32LE() != _varCount)
+		return false;
+	if (stream.readUint32LE() != _descMaxLength)
+		return false;
+
+	if (stream.read(_desc, _descMaxLength) != _descMaxLength)
+		return false;
+
+	_desc[_descMaxLength] = 0;
+
+	return !stream.err();
+}
+
+bool SavePartInfo::write(Common::WriteStream &stream) const {
+	if (!_header.write(stream))
+		return false;
+
+	stream.writeUint32LE(_gameID);
+	stream.writeUint32LE(_gameVersion);
+	stream.writeByte(_endian);
+	stream.writeUint32LE(_varCount);
+	stream.writeUint32LE(_descMaxLength);
+
+	if (stream.write(_desc, _descMaxLength) != _descMaxLength)
+		return false;
+
+	return flushStream(stream);
+}
+
+SaveContainer::Part::Part(uint32 s) {
+	size = s;
+	data = new byte[size];
+}
+
+SaveContainer::Part::~Part() {
+	delete[] data;
+}
+
+Common::WriteStream *SaveContainer::Part::createWriteStream() {
+	return new Common::MemoryWriteStream(data, size);
+}
+
+Common::ReadStream *SaveContainer::Part::createReadStream() const {
+	return new Common::MemoryReadStream(data, size);
+}
+
+SaveContainer::SaveContainer(uint32 partCount, uint32 slot) {
+	assert(partCount > 0);
+
+	_slot = slot;
+	_partCount = partCount;
+
+	_parts.resize(partCount);
+	for (PartIterator it = _parts.begin(); it != _parts.end(); ++it)
+		*it = 0;
+
+	_header.setType(kID);
+	_header.setVersion(kVersion);
+	_header.setSize(4); // uint32 # of parts
+}
+
+SaveContainer::~SaveContainer() {
+	clear();
+}
+
+uint32 SaveContainer::getSlot() const {
+	return _slot;
+}
+
+uint32 SaveContainer::getSize() const {
+	return _header.getSize() + SaveHeader::kSize;
+}
+
+bool SaveContainer::hasAllParts() const {
+	for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it)
+		if (!*it)
+			return false;
+
+	return true;
+}
+
+uint32 SaveContainer::calcSize() const {
+	uint32 size = 4; // uint32 # of parts
+
+	for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it)
+		if (*it)
+			//              uint32 part size
+			size += (*it)->size + 4;
+
+	return size;
+}
+
+void SaveContainer::clear() {
+	for (PartIterator it = _parts.begin(); it != _parts.end(); ++it) {
+		Part *&p = *it;
+
+		delete p;
+		p = 0;
+	}
+}
+
+bool SaveContainer::writePart(uint32 partN, const SavePart *part) {
+	// Sanity checks
+	if (!part)
+		return false;
+	if (partN >= _partCount)
+		return false;
+
+	Part *&p = _parts[partN];
+
+	delete p;
+	// Create the part
+	p = new Part(part->getSize());
+
+	Common::WriteStream *pStream = p->createWriteStream();
+
+	// Write
+	if (!part->write(*pStream)) {
+		delete p;
+		p = 0;
+
+		delete pStream;
+		return false;
+	}
+
+	delete pStream;
+
+	// Update size
+	_header.setSize(calcSize());
+
+	return true;
+}
+
+bool SaveContainer::readPart(uint32 partN, SavePart *part) const {
+	// Sanity checks
+	if (!part)
+		return false;
+	if (partN >= _partCount)
+		return false;
+
+	const Part * const &p = _parts[partN];
+
+	// Check if the part actually exists
+	if (!p)
+		return false;
+
+	Common::ReadStream *pStream = p->createReadStream();
+
+	// Read
+	if (!part->read(*pStream)) {
+		delete pStream;
+		return false;
+	}
+
+	delete pStream;
+	return true;
+}
+
+bool SaveContainer::readPartHeader(uint32 partN, SaveHeader *header) const {
+	// Sanity checks
+	if (!header)
+		return false;
+	if (partN >= _partCount)
+		return false;
+
+	const Part * const &p = _parts[partN];
+
+	// Check if the part actually exists
+	if (!p)
+		return false;
+
+	Common::ReadStream *pStream = p->createReadStream();
+
+	// Read
+	if (!header->read(*pStream)) {
+		delete pStream;
+		return false;
+	}
+
+	delete pStream;
+	return true;
+}
+
+bool SaveContainer::read(Common::ReadStream &stream) {
+	// Verify the header and get the container's size
+	if (!_header.verifyReadSize(stream))
+		return false;
+
+	// The part count has to be correct
+	if (stream.readUint32LE() != _partCount)
+		return false;
+
+	// Iterate over all parts
+	for (PartIterator it = _parts.begin(); it != _parts.end(); ++it) {
+		// Read the size
+		uint32 size = stream.readUint32LE();
+
+		if (stream.err()) {
+			clear();
+			return false;
+		}
+
+		Part *&p = *it;
+
+		delete p;
+		// Create a suitable part
+		p = new Part(size);
+	}
+
+	// Update size
+	_header.setSize(calcSize());
+
+	// Iterate over all parts
+	for (PartIterator it = _parts.begin(); it != _parts.end(); ++it) {
+		Part *&p = *it;
+
+		// Read the part
+		if (stream.read(p->data, p->size) != p->size) {
+			clear();
+			return false;
+		}
+	}
+
+	return !stream.err();
+}
+
+bool SaveContainer::write(Common::WriteStream &stream) const {
+	// Write the header
+	if (!_header.write(stream))
+		return false;
+
+	// Write the part count
+	stream.writeUint32LE(_partCount);
+
+	// Iterate over all parts
+	for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it) {
+		// Part doesn't actually exist => error
+		if (!*it)
+			return false;
+
+		// Write the part's size
+		stream.writeUint32LE((*it)->size);
+	}
+
+	if (!flushStream(stream))
+		return false;
+
+	// Iterate over all parts
+	for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it) {
+		Part * const &p = *it;
+
+		// Write the part
+		if (stream.write(p->data, p->size) != p->size)
+			return false;
+	}
+
+	return flushStream(stream);
+}
+
+Common::Array<SaveContainer::PartInfo> *SaveContainer::getPartsInfo(Common::SeekableReadStream &stream) {
+	Common::Array<PartInfo> *parts = 0;
+
+	// Remember the stream's position to seek back to
+	uint32 startPos = stream.pos();
+
+	SaveHeader header;
+
+	header.setType(kID);
+	header.setVersion(kVersion);
+
+	// Verify the header
+	if (!header.verifyReadSize(stream)) {
+		// Seek back
+		stream.seek(startPos);
+		return 0;
+	}
+
+	// Read the part count
+	uint32 partCount = stream.readUint32LE();
+
+	// Create a part information array
+	parts = new Common::Array<PartInfo>;
+	parts->resize(partCount);
+
+	// Read all part sizes
+	for (uint32 i = 0; i < partCount; i++)
+		(*parts)[i].size = stream.readUint32LE();
+
+	// Iterate over all parts
+	for (uint32 i = 0; i < partCount; i++) {
+		// The part's offset (from the starting point of the stream)
+		(*parts)[i].offset = stream.pos() - startPos;
+
+		SaveHeader partHeader;
+
+		// Read the header
+		if (!partHeader.read(stream)) {
+			// Seek back
+			stream.seek(startPos);
+			delete parts;
+			return 0;
+		}
+
+		// Fill in the ID
+		(*parts)[i].id = partHeader.getType();
+
+		// Skip the part's content
+		stream.skip(partHeader.getSize());
+	}
+
+	if (stream.err()) {
+		delete parts;
+		parts = 0;
+	}
+
+	// Seek back
+	stream.seek(startPos);
+
+	return parts;
+}
+
+bool SaveContainer::isSave(Common::SeekableReadStream &stream) {
+	// Remember the stream's position to seek back to
+	uint32 startPos = stream.pos();
+
+	SaveHeader header;
+
+	header.setType(kID);
+	header.setVersion(kVersion);
+
+	bool result = header.verifyReadSize(stream);
+
+	// Seek back
+	stream.seek(startPos);
+
+	return result;
+}
+
+
+SaveReader::SaveReader(uint32 partCount, uint32 slot, const char *fileName) :
+	SaveContainer(partCount, slot) {
+
+	_fileName = strdupcpy(fileName);
+	_stream = 0;
+
+	_loaded = false;
+}
+
+SaveReader::SaveReader(uint32 partCount, uint32 slot, Common::SeekableReadStream &stream) :
+	SaveContainer(partCount, slot) {
+
+	_fileName = 0;
+	_stream = &stream;
+
+	_loaded = false;
+}
+
+SaveReader::~SaveReader() {
+	delete[] _fileName;
+}
+
+// Open the save and read it
+bool SaveReader::load() {
+
+	Common::InSaveFile *in = 0;
+	Common::SeekableReadStream *stream;
+
+	if (_fileName) {
+		in = openSave();
+
+		if (!in)
+			return false;
+
+		stream = in;
+	} else if (_stream)
+		stream = _stream;
+	else
+		return false;
+
+	if (!SaveContainer::read(*stream)) {
+		delete in;
+		return false;
+	}
+
+	delete in;
+	_loaded = true;
+	return true;
+}
+
+bool SaveReader::readPartHeader(uint32 partN, SaveHeader *header) const {
+	// The save has to be loaded
+	if (!_loaded)
+		return false;
+
+	return SaveContainer::readPartHeader(partN, header);
+}
+
+bool SaveReader::readPart(uint32 partN, SavePart *part) const {
+	// The save has to be loaded
+	if (!_loaded)
+		return false;
+
+	if (!SaveContainer::readPart(partN, part))
+		return false;
+
+	return true;
+}
+
+Common::InSaveFile *SaveReader::openSave(const char *fileName) {
+	if (!fileName)
+		return 0;
+
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+	return saveMan->openForLoading(fileName);
+}
+
+Common::InSaveFile *SaveReader::openSave() {
+	return openSave(_fileName);
+}
+
+bool SaveReader::getInfo(Common::SeekableReadStream &stream, SavePartInfo &info) {
+	// Remeber the stream's starting position to seek back to
+	uint32 startPos = stream.pos();
+
+	// Get parts' basic information
+	Common::Array<SaveContainer::PartInfo> *partsInfo = getPartsInfo(stream);
+
+	// No parts => fail
+	if (!partsInfo) {
+		stream.seek(startPos);
+		return false;
+	}
+
+	bool result = false;
+	// Iterate over all parts
+	for (Common::Array<SaveContainer::PartInfo>::iterator it = partsInfo->begin();
+	     it != partsInfo->end(); ++it) {
+
+		// Check for the info part
+		if (it->id == SavePartInfo::kID) {
+			if (!stream.seek(it->offset))
+				break;
+
+			// Read it
+			result = info.read(stream);
+			break;
+		}
+	}
+
+	stream.seek(startPos);
+
+	delete partsInfo;
+	return result;
+}
+
+bool SaveReader::getInfo(const char *fileName, SavePartInfo &info) {
+	Common::InSaveFile *in = openSave(fileName);
+
+	if (!in)
+		return false;
+
+	bool result = getInfo(*in, info);
+
+	delete in;
+
+	return result;
+}
+
+SaveWriter::SaveWriter(uint32 partCount, uint32 slot, const char *fileName) :
+	SaveContainer(partCount, slot) {
+
+	_fileName = strdupcpy(fileName);
+}
+
+SaveWriter::~SaveWriter() {
+	delete[] _fileName;
+}
+
+bool SaveWriter::writePart(uint32 partN, const SavePart *part) {
+	// Write the part
+	if (!SaveContainer::writePart(partN, part))
+		return false;
+
+	// If all parts have been written, save and clear
+	if (hasAllParts() && canSave()) {
+		if (save()) {
+			clear();
+			return true;
+		}
+
+		return false;
+	}
+
+	return true;
+}
+
+bool SaveWriter::save(Common::WriteStream &stream) {
+	return SaveContainer::write(stream);
+}
+
+bool SaveWriter::save() {
+	Common::OutSaveFile *out = openSave();
+
+	if (!out)
+		return false;
+
+	bool success = save(*out);
+
+	delete out;
+
+	return success;
+}
+
+bool SaveWriter::canSave() const {
+	if (!_fileName)
+		return false;
+	
+	return true;
+}
+
+Common::OutSaveFile *SaveWriter::openSave(const char *fileName) {
+	if (!fileName)
+		return 0;
+
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+	return saveMan->openForSaving(fileName);
+}
+
+Common::OutSaveFile *SaveWriter::openSave() {
+	return openSave(_fileName);
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/savefile.h b/engines/gob/save/savefile.h
new file mode 100644
index 0000000000..a263d97b0e
--- /dev/null
+++ b/engines/gob/save/savefile.h
@@ -0,0 +1,347 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef GOB_SAVE_SAVEFILE_H
+#define GOB_SAVE_SAVEFILE_H
+
+#include "common/endian.h"
+#include "common/array.h"
+#include "common/savefile.h"
+
+namespace Gob {
+
+class GobEngine;
+class SurfaceDesc;
+
+/** A class wrapping a save part header.
+  *
+  * A save part header consists of 4 fields:
+  * ID      : The 8 character ID \0SCVMGOB
+  * Type    : The 4 character ID for this part's type
+  * Version : This part's version. Each type has its own version counter
+  * Size    : The size of the contents, i.e. excluding this header
+*/
+class SaveHeader {
+public:
+	/** The size of the header. */
+	static const int kSize = 20;
+	static const uint32 kID1 = MKID_BE('\0SCV');
+	static const uint32 kID2 = MKID_BE('MGOB');
+
+	SaveHeader(uint32 type = 0, uint32 version = 0, uint32 size = 0);
+
+	/** Read the header out of a stream into this class. */
+	bool read(Common::ReadStream &stream);
+	/** Read the header out of a stream and checks it against this class's contents. */
+	bool verify(Common::ReadStream &stream) const;
+	/** Read the header out of a stream and checks it against this class's contents,
+	 *  but read the size field instead.
+	 */
+	bool verifyReadSize(Common::ReadStream &stream);
+	/** Write this class's contents into a stream. */
+	bool write(Common::WriteStream &stream) const;
+
+	uint32 getType() const;
+	uint32 getVersion() const;
+	uint32 getSize() const;
+
+	void setType(uint32 type);
+	void setVersion(uint32 version);
+	void setSize(uint32 size);
+
+private:
+	/** An ID specifying the part's type. */
+	uint32 _type;
+	/** The part's version. */
+	uint32 _version;
+	/** The size of the contents. */
+	uint32 _size;
+};
+
+/** An abstract class for a part in a save file. */
+class SavePart {
+public:
+	SavePart();
+	virtual ~SavePart();
+
+	/** Return the total size of the part. */
+	virtual uint32 getSize() const;
+
+	/** Read the part (with header) out of the stream. */
+	virtual bool read(Common::ReadStream &stream) = 0;
+	/** Write the part (with header) into the stream. */
+	virtual bool write(Common::WriteStream &stream) const = 0;
+
+protected:
+	SaveHeader _header;
+};
+
+/** A save part consisting of plain memory. */
+class SavePartMem : public SavePart {
+public:
+	static const uint32 kVersion = 1;
+	static const uint32 kID = MKID_BE('PMEM');
+
+	SavePartMem(uint32 size);
+	~SavePartMem();
+
+	bool read(Common::ReadStream &stream);
+	bool write(Common::WriteStream &stream) const;
+
+	/** Read size bytes of data into the part at the specified offset. */
+	bool readFrom(const byte *data, uint32 offset, uint32 size);
+	/** Write size bytes of the part at the specified offset int data. */
+	bool writeInto(byte *data, uint32 offset, uint32 size) const;
+
+private:
+	uint32 _size;
+	byte *_data;
+};
+
+/** A save part holding script variables. */
+class SavePartVars : public SavePart {
+public:
+	static const uint32 kVersion = 1;
+	static const uint32 kID = MKID_BE('VARS');
+
+	SavePartVars(GobEngine *vm, uint32 size);
+	~SavePartVars();
+
+	bool read(Common::ReadStream &stream);
+	bool write(Common::WriteStream &stream) const;
+
+	/** Read size bytes of variables starting at var into the part at the specified offset. */
+	bool readFrom(uint32 var, uint32 offset, uint32 size);
+	/** Write size bytes of the part at the specified offset into the variable starting at var. */
+	bool writeInto(uint32 var, uint32 offset, uint32 size) const;
+
+	/** Read size bytes of raw data into the part. */
+	bool readFromRaw(const byte *data, uint32 size);
+
+private:
+	GobEngine *_vm;
+
+	uint32 _size;
+	byte *_data;
+};
+
+/** A save part holding a sprite. */
+class SavePartSprite : public SavePart {
+public:
+	static const uint32 kVersion = 1;
+	static const uint32 kID = MKID_BE('SPRT');
+
+	SavePartSprite(uint32 width, uint32 height);
+	~SavePartSprite();
+
+	bool read(Common::ReadStream &stream);
+	bool write(Common::WriteStream &stream) const;
+
+	/** Read a palette into the part. */
+	bool readPalette(const byte *palette);
+	/** Read a sprite into the part. */
+	bool readSprite(const SurfaceDesc *sprite);
+	
+	/** Read size bytes of raw data into the sprite. */
+	bool readSpriteRaw(const byte *data, uint32 size);
+
+	/** Write a palette out of the part. */
+	bool writePalette(byte *palette) const;
+	/** Write a sprite out of the part. */
+	bool writeSprite(SurfaceDesc *sprite) const;
+
+private:
+	uint32 _width;
+	uint32 _height;
+
+	byte *_dataSprite;
+	byte *_dataPalette;
+};
+
+/** A save part containing informations about the save's game. */
+class SavePartInfo : public SavePart {
+public:
+	static const uint32 kVersion = 1;
+	static const uint32 kID = MKID_BE('INFO');
+
+	/** The constructor.
+	 *
+	 *  @param descMaxLength The maximal number of bytes that fit into the description.
+	 *  @param gameID An ID for the game (Gob1, Gob2, Gob3, ...).
+	 *  @param gameVersion An ID for game specific versioning
+	 *  @param endian Endianness of the platform the game originally ran on.
+	 *  @param varCount The number of script variables.
+	 */
+	SavePartInfo(uint32 descMaxLength, uint32 gameID,
+			uint32 gameVersion, byte endian, uint32 varCount);
+	~SavePartInfo();
+
+	/** Return the save's description. */
+	const char *getDesc() const;
+	/** Return the description's maximal length. */
+	uint32 getDescMaxLength() const;
+
+	/** Set the variable count. */
+	void setVarCount(uint32 varCount);
+	/** Set the save's description. */
+	void setDesc(const char *desc = 0);
+	/** Set the save's description. */
+	void setDesc(const byte *desc, uint32 size);
+
+	bool read(Common::ReadStream &stream);
+	bool write(Common::WriteStream &stream) const;
+
+private:
+	char *_desc;
+	uint32 _descMaxLength;
+	uint32 _gameID;
+	uint32 _gameVersion;
+	uint32 _varCount;
+	byte _endian;
+};
+
+/** A container for several save parts. */
+class SaveContainer {
+public:
+	static const uint32 kVersion = 1;
+	static const uint32 kID = MKID_BE('CONT');
+
+	/** The constructor.
+	 *
+	 *  @param partCount The number parts this container shall hold.
+	 *  @param slot The save slot this save's for.
+	 */
+	SaveContainer(uint32 partCount, uint32 slot);
+	~SaveContainer();
+
+	uint32 getSlot() const;
+	uint32 getSize() const;
+
+	/** All parts filled? */
+	bool hasAllParts() const;
+
+	/** Empty all parts. */
+	void clear();
+
+	/** Write a SavePart into the container's part. */
+	bool writePart(uint32 partN, const SavePart *part);
+	/** Read the container's part's content into a SavePart. */
+	bool readPart(uint32 partN, SavePart *part) const;
+	/** Read only the container's part's header. */
+	bool readPartHeader(uint32 partN, SaveHeader *header) const;
+
+	/** Checks if the stream is a valid save container. */
+	static bool isSave(Common::SeekableReadStream &stream);
+
+protected:
+	/** A part. */
+	struct Part {
+		uint32 size;
+		byte *data;
+
+		Part(uint32 s);
+		~Part();
+
+		Common::WriteStream *createWriteStream();
+		Common::ReadStream *createReadStream() const;
+	};
+
+	/** Basic information about a part. */
+	struct PartInfo {
+		uint32 id;
+		uint32 offset;
+		uint32 size;
+	};
+
+	typedef Common::Array<Part *>::iterator PartIterator;
+	typedef Common::Array<Part *>::const_iterator PartConstIterator;
+
+	uint32 _partCount;
+	uint32 _slot;
+
+	SaveHeader _header;
+	Common::Array<Part *> _parts;
+
+	uint32 calcSize() const;
+
+	bool read(Common::ReadStream &stream);
+	bool write(Common::WriteStream &stream) const;
+
+	/** Get an array containing basic information about all parts in the container in the stream. */
+	static Common::Array<PartInfo> *getPartsInfo(Common::SeekableReadStream &stream);
+};
+
+/** Reads a save. */
+class SaveReader : public SaveContainer {
+public:
+	SaveReader(uint32 partCount, uint32 slot, const char *fileName);
+	SaveReader(uint32 partCount, uint32 slot, Common::SeekableReadStream &stream);
+	~SaveReader();
+
+	bool load();
+
+	bool readPart(uint32 partN, SavePart *part) const;
+	bool readPartHeader(uint32 partN, SaveHeader *header) const;
+
+	/** Find and read the save's info part. */
+	static bool getInfo(Common::SeekableReadStream &stream, SavePartInfo &info);
+	/** Find and read the save's info part. */
+	static bool getInfo(const char *fileName, SavePartInfo &info);
+
+protected:
+	char *_fileName;
+	Common::SeekableReadStream *_stream;
+
+	bool _loaded;
+
+	static Common::InSaveFile *openSave(const char *fileName);
+	Common::InSaveFile *openSave();
+};
+
+/** Writes a save. */
+class SaveWriter: public SaveContainer {
+public:
+	SaveWriter(uint32 partCount, uint32 slot, const char *fileName = 0);
+	~SaveWriter();
+
+	bool writePart(uint32 partN, const SavePart *part);
+
+	bool save(Common::WriteStream &stream);
+
+protected:
+	bool save();
+
+	char *_fileName;
+
+	/** Is everything ready for saving? */
+	bool canSave() const;
+
+	static Common::OutSaveFile *openSave(const char *fileName);
+	Common::OutSaveFile *openSave();
+};
+
+} // End of namespace Gob
+
+#endif // GOB_SAVE_SAVEFILE_H
diff --git a/engines/gob/save/savehandler.cpp b/engines/gob/save/savehandler.cpp
new file mode 100644
index 0000000000..744b839653
--- /dev/null
+++ b/engines/gob/save/savehandler.cpp
@@ -0,0 +1,503 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+
+#include "gob/gob.h"
+#include "gob/save/savehandler.h"
+#include "gob/save/savefile.h"
+#include "gob/save/saveconverter.h"
+#include "gob/global.h"
+#include "gob/video.h"
+#include "gob/draw.h"
+#include "gob/variables.h"
+#include "gob/inter.h"
+
+namespace Gob {
+
+SlotFile::SlotFile(GobEngine *vm, uint32 slotCount, const char *base) : _vm(vm) {
+	_base = strdupcpy(base);
+	_slotCount = slotCount;
+}
+
+SlotFile::~SlotFile() {
+	delete[] _base;
+}
+
+const char *SlotFile::getBase() const {
+	return _base;
+}
+
+uint32 SlotFile::getSlotMax() const {
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+	Common::InSaveFile *in;
+
+	// Find the last filled save slot and base the save file size calculate on that
+	for (int i = (_slotCount - 1); i >= 0; i--) {
+		char *slotFile = build(i);
+
+		if (!slotFile)
+			continue;
+
+		in = saveMan->openForLoading(slotFile);
+		delete[] slotFile;
+
+		if (in) {
+			delete in;
+			return i + 1;
+		}
+	}
+
+	return 0;
+}
+
+int32 SlotFile::tallyUpFiles(uint32 slotSize, uint32 indexSize) const {
+	uint32 maxSlot = getSlotMax();
+
+	if (maxSlot == 0)
+		return -1;
+
+	return ((maxSlot * slotSize) + indexSize);
+}
+
+void SlotFile::buildIndex(byte *buffer, SavePartInfo &info,
+		SaveConverter *converter) const {
+
+	uint32 descLength = info.getDescMaxLength();
+
+	// Iterate over all files
+	for (uint32 i = 0; i < _slotCount; i++, buffer += descLength) {
+		char *slotFile = build(i);
+
+		if (slotFile) {
+			char *desc = 0;
+
+			if (converter && (desc = converter->getDescription(slotFile)))
+				// Old style save
+				memcpy(buffer, desc, descLength);
+			else if (SaveReader::getInfo(slotFile, info))
+				// New style save
+				memcpy(buffer, info.getDesc(), descLength);
+			else
+				// No known format, fill with 0
+				memset(buffer, 0, descLength);
+
+			delete[] desc;
+
+		} else
+			// No valid slot, fill with 0
+			memset(buffer, 0, descLength);
+
+		delete[] slotFile;
+	}
+}
+
+bool SlotFile::exists(const char *name) const {
+	Common::InSaveFile *in = openRead(name);
+	bool result = (in != 0);
+	delete in;
+	return result;
+}
+
+bool SlotFile::exists(int slot) const {
+	Common::InSaveFile *in = openRead(slot);
+	bool result = (in != 0);
+	delete in;
+	return result;
+}
+
+bool SlotFile::exists() const {
+	Common::InSaveFile *in = openRead();
+	bool result = (in != 0);
+	delete in;
+	return result;
+}
+
+Common::InSaveFile *SlotFile::openRead(const char *name) const {
+	if (!name)
+		return 0;
+
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+
+	return saveMan->openForLoading(name);
+}
+
+Common::InSaveFile *SlotFile::openRead(int slot) const {
+	char *name = build(slot);
+	Common::InSaveFile *result = openRead(name);
+	delete[] name;
+	return result;
+}
+
+Common::InSaveFile *SlotFile::openRead() const {
+	char *name = build();
+	Common::InSaveFile *result = openRead(name);
+	delete[] name;
+	return result;
+}
+
+Common::OutSaveFile *SlotFile::openWrite(const char *name) const {
+	if (!name)
+		return 0;
+
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+
+	return saveMan->openForSaving(name);
+}
+
+Common::OutSaveFile *SlotFile::openWrite(int slot) const {
+	char *name = build(slot);
+	Common::OutSaveFile *result = openWrite(name);
+	delete[] name;
+	return result;
+}
+
+Common::OutSaveFile *SlotFile::openWrite() const {
+	char *name = build();
+	Common::OutSaveFile *result = openWrite(name);
+	delete[] name;
+	return result;
+}
+
+
+SlotFileIndexed::SlotFileIndexed(GobEngine *vm, uint32 slotCount,
+		const char *base, const char *extStub) : SlotFile(vm, slotCount, base) {
+
+	_ext = strdupcpy(extStub);
+}
+
+SlotFileIndexed::~SlotFileIndexed() {
+	delete[] _ext;
+}
+
+char *SlotFileIndexed::build(int slot) const {
+	if ((slot < 0) || (((uint32) slot) >= _slotCount))
+		return 0;
+
+	size_t len = strlen(_base) + strlen(_ext) + 4;
+
+	char *slotFile = new char[len];
+
+	snprintf(slotFile, len, "%s.%s%02d", _base, _ext, slot);
+
+	return slotFile;
+}
+
+char *SlotFileIndexed::build() const {
+	return 0;
+}
+
+
+SlotFileStatic::SlotFileStatic(GobEngine *vm, const char *base,
+		const char *ext) : SlotFile(vm, 1, base) {
+
+	_ext = strdupcat(".", ext);
+}
+
+SlotFileStatic::~SlotFileStatic() {
+	delete[] _ext;
+}
+
+int SlotFileStatic::getSlot(int32 offset) const {
+	return -1;
+}
+
+int SlotFileStatic::getSlotRemainder(int32 offset) const {
+	return -1;
+}
+
+char *SlotFileStatic::build(int slot) const {
+	return 0;
+}
+
+char *SlotFileStatic::build() const {
+	return strdupcat(_base, _ext);
+}
+
+
+SaveHandler::SaveHandler(GobEngine *vm) : _vm(vm) {
+}
+
+SaveHandler::~SaveHandler() {
+}
+
+uint32 SaveHandler::getVarSize(GobEngine *vm) {
+	// Sanity checks
+	if (!vm || !vm->_inter || !vm->_inter->_variables)
+		return 0;
+
+	return vm->_inter->_variables->getSize();
+}
+
+
+TempSpriteHandler::TempSpriteHandler(GobEngine *vm) : SaveHandler(vm) {
+	_sprite = 0;
+}
+
+TempSpriteHandler::~TempSpriteHandler() {
+	delete _sprite;
+}
+
+int32 TempSpriteHandler::getSize() {
+	if (!_sprite)
+		return -1;
+
+	return _sprite->getSize();
+}
+
+bool TempSpriteHandler::load(int16 dataVar, int32 size, int32 offset) {
+	// Sprite available?
+	if (!_sprite)
+		return false;
+
+	// Sprite requested?
+	if (!isSprite(size))
+		return false;
+
+	// Index sane?
+	int index = getIndex(size);
+	if ((index < 0) || (index >= SPRITES_COUNT))
+		return false;
+
+	SurfaceDesc *sprite = _vm->_draw->_spritesArray[index];
+
+	// Target sprite exists?
+	if (!sprite)
+		return false;
+
+	// Load the sprite
+	if (!_sprite->writeSprite(sprite))
+		return false;
+
+	// Handle palette
+	if (usesPalette(size)) {
+		if (!_sprite->writePalette((byte *) _vm->_global->_pPaletteDesc->vgaPal))
+			return false;
+
+		_vm->_video->setFullPalette(_vm->_global->_pPaletteDesc);
+	}
+
+	if (index == 21) {
+		// We wrote into the backbuffer, blit
+		_vm->_draw->forceBlit();
+		_vm->_video->retrace();
+	} else if (index == 20)
+		// We wrote into the frontbuffer, retrace
+		_vm->_video->retrace();
+
+	return true;
+}
+
+bool TempSpriteHandler::save(int16 dataVar, int32 size, int32 offset) {
+	SurfaceDesc *sprite;
+
+	if (!createSprite(dataVar, size, offset, &sprite))
+		return false;
+
+	// Save the sprite
+	if (!_sprite->readSprite(sprite))
+		return false;
+
+	// Handle palette
+	if (usesPalette(size)) {
+		if (!_sprite->readPalette((const byte *) _vm->_global->_pPaletteDesc->vgaPal))
+			return false;
+	}
+
+	return true;
+}
+
+bool TempSpriteHandler::createSprite(int16 dataVar, int32 size,
+		int32 offset, SurfaceDesc **sprite) {
+
+	delete _sprite;
+	_sprite = 0;
+
+	// Sprite requested?
+	if (!isSprite(size))
+		return false;
+
+	// Index sane?
+	int index = getIndex(size);
+	if ((index < 0) || (index >= SPRITES_COUNT))
+		return false;
+
+	SurfaceDesc *sprt = _vm->_draw->_spritesArray[index];
+
+	// Sprite exists?
+	if (!sprt)
+		return false;
+
+	// Create a new temporary sprite
+	_sprite = new SavePartSprite(sprt->getWidth(), sprt->getHeight());
+
+	if (sprite)
+		*sprite = sprt;
+
+	return true;
+}
+
+// A negative size is the flag for using a sprite
+bool TempSpriteHandler::isSprite(int32 size) {
+	return (size < 0);
+}
+
+// Contruct the index
+int TempSpriteHandler::getIndex(int32 size) {
+	// Palette flag
+	if (size < -1000)
+		size += 1000;
+
+	return (-size - 1);
+}
+
+// A size smaller than -1000 indicates palette usage
+bool TempSpriteHandler::usesPalette(int32 size) {
+	return (size < -1000);
+}
+
+
+NotesHandler::File::File(GobEngine *vm, const char *base) :
+	SlotFileStatic(vm, base, "blo") {
+}
+
+NotesHandler::File::~File() {
+}
+
+NotesHandler::NotesHandler(uint32 notesSize, GobEngine *vm, const char *target) :
+	SaveHandler(vm) {
+
+	_notesSize = notesSize;
+
+	_file = new File(vm, target);
+
+	_notes = new SavePartVars(vm, _notesSize);
+}
+
+NotesHandler::~NotesHandler() {
+	delete _file;
+	delete _notes;
+}
+
+int32 NotesHandler::getSize() {
+	char *fileName = _file->build();
+
+	if (!fileName)
+		return -1;
+
+	Common::InSaveFile *saveFile;
+
+	SaveConverter_Notes converter(_vm, _notesSize, fileName);
+	if (converter.isOldSave(&saveFile)) {
+		// Old save, get the size olden-style
+
+		int32 size = saveFile->size();
+
+		delete saveFile;
+		return size;
+	}
+
+	SaveReader reader(1, 0, fileName);
+	SaveHeader header;
+
+	delete[] fileName;
+
+	if (!reader.load())
+		return -1;
+
+	if (!reader.readPartHeader(0, &header))
+		return -1;
+
+	// Return the part's size
+	return header.getSize();
+}
+
+bool NotesHandler::load(int16 dataVar, int32 size, int32 offset) {
+	if ((dataVar < 0) || (size < 0) || (offset < 0))
+		return false;
+
+	char *fileName = _file->build();
+
+	if (!fileName)
+		return false;
+
+	SaveReader *reader;
+
+	SaveConverter_Notes converter(_vm, _notesSize, fileName);
+	if (converter.isOldSave()) {
+		// Old save, plug the converter in
+		if (!converter.load())
+			return false;
+
+		reader = new SaveReader(1, 0, converter);
+
+	} else
+		// New save, load directly
+		reader = new SaveReader(1, 0, fileName);
+
+	SavePartVars vars(_vm, _notesSize);
+
+	delete[] fileName;
+
+	if (!reader->load()) {
+		delete reader;
+		return false;
+	}
+
+	if (!reader->readPart(0, &vars)) {
+		delete reader;
+		return false;
+	}
+
+	if (!vars.writeInto(dataVar, offset, size)) {
+		delete reader;
+		return false;
+	}
+
+	delete reader;
+	return true;
+}
+
+bool NotesHandler::save(int16 dataVar, int32 size, int32 offset) {
+	if ((dataVar < 0) || (size < 0) || (offset < 0))
+		return false;
+
+	char *fileName = _file->build();
+
+	if (!fileName)
+		return false;
+
+	SaveWriter writer(1, 0, fileName);
+	SavePartVars vars(_vm, _notesSize);
+
+	delete[] fileName;
+
+	if (!vars.readFrom(dataVar, offset, size))
+		return false;
+
+	return writer.writePart(0, &vars);
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/savehandler.h b/engines/gob/save/savehandler.h
new file mode 100644
index 0000000000..06c6c39cf8
--- /dev/null
+++ b/engines/gob/save/savehandler.h
@@ -0,0 +1,191 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef GOB_SAVE_SAVEHANDLER_H
+#define GOB_SAVE_SAVEHANDLER_H
+
+#include "common/savefile.h"
+
+namespace Gob {
+
+class GobEngine;
+class SurfaceDesc;
+class SavePartInfo;
+class SavePartVars;
+class SavePartSprite;
+class SaveConverter;
+
+/** Slot file related class. */
+class SlotFile {
+public:
+	/** The constructor.
+	 *
+	 *  @param slotCount Number of slots.
+	 *  @param base The file's base string.
+	 */
+	SlotFile(GobEngine *vm, uint32 slotCount, const char *base);
+	virtual ~SlotFile();
+
+	/** Returns the base string. */
+	virtual const char *getBase() const;
+
+	/** Calculates which slot to use. */
+	virtual int getSlot(int32 offset) const = 0;
+	/** Calculates the slot remainder, for error checking. */
+	virtual int getSlotRemainder(int32 offset) const = 0;
+
+	/** Build the save file name. */
+	virtual char *build(int slot) const = 0;
+	/** Build the save file name. */
+	virtual char *build() const = 0;
+
+	/** Returns the highest filled slot number. */
+	virtual uint32 getSlotMax() const;
+
+	/** Returns the size of all existing slots + the index. */
+	virtual int32 tallyUpFiles(uint32 slotSize, uint32 indexSize) const;
+
+	/** Creates an index in buffer. */
+	virtual void buildIndex(byte *buffer, SavePartInfo &info,
+			SaveConverter *converter = 0) const;
+
+	virtual bool exists(const char *name) const;
+	virtual bool exists(int slot) const;
+	virtual bool exists() const;
+
+	virtual Common::InSaveFile *openRead(const char *name) const;
+	virtual Common::InSaveFile *openRead(int slot) const;
+	virtual Common::InSaveFile *openRead() const;
+
+	virtual Common::OutSaveFile *openWrite(const char *name) const;
+	virtual Common::OutSaveFile *openWrite(int slot) const;
+	virtual Common::OutSaveFile *openWrite() const;
+
+protected:
+	GobEngine *_vm;
+	char *_base;
+
+	uint32 _slotCount;
+};
+
+/** An indexed slot file ("foobar.s00", "foobar.s01", ...). */
+class SlotFileIndexed : public SlotFile {
+public:
+	SlotFileIndexed(GobEngine *vm, uint32 slotCount, const char *base,
+			const char *extStub);
+	~SlotFileIndexed();
+
+	char *build(int slot) const;
+	char *build() const;
+
+protected:
+	char *_ext;
+};
+
+/** A static slot file ("foo.bar"). */
+class SlotFileStatic : public SlotFile {
+public:
+	SlotFileStatic(GobEngine *vm, const char *base, const char *ext);
+	~SlotFileStatic();
+
+	int getSlot(int32 offset) const;
+	int getSlotRemainder(int32 offset) const;
+
+	char *build(int slot) const;
+	char *build() const;
+
+protected:
+	char *_ext;
+};
+
+/** A handler for a specific save file. */
+class SaveHandler {
+public:
+	SaveHandler(GobEngine *vm);
+	virtual ~SaveHandler();
+
+	/** Returns the file's (virtual) size. */
+	virtual int32 getSize() = 0;
+	/** Loads (parts of) the file. */
+	virtual bool load(int16 dataVar, int32 size, int32 offset) = 0;
+	/** Saves (parts of) the file. */
+	virtual bool save(int16 dataVar, int32 size, int32 offset) = 0;
+
+	static uint32 getVarSize(GobEngine *vm);
+
+protected:
+	GobEngine *_vm;
+};
+
+/** A handler for temporary sprites. */
+class TempSpriteHandler : public SaveHandler {
+public:
+	TempSpriteHandler(GobEngine *vm);
+	~TempSpriteHandler();
+
+	int32 getSize();
+	bool load(int16 dataVar, int32 size, int32 offset);
+	bool save(int16 dataVar, int32 size, int32 offset);
+
+	/** Create a fitting sprite. */
+	bool createSprite(int16 dataVar, int32 size,
+			int32 offset, SurfaceDesc **sprite = 0);
+
+protected:
+	SavePartSprite *_sprite;
+
+	/** Determine whether using a sprite was requested. */
+	static bool isSprite(int32 size);
+	/** Determine which sprite is meant. */
+	static int getIndex(int32 size);
+	/** Determine whether the palette should be used too. */
+	static bool usesPalette(int32 size);
+};
+
+/** A handler for notes. */
+class NotesHandler : public SaveHandler {
+public:
+	NotesHandler(uint32 notesSize, GobEngine *vm, const char *target);
+	~NotesHandler();
+
+	int32 getSize();
+	bool load(int16 dataVar, int32 size, int32 offset);
+	bool save(int16 dataVar, int32 size, int32 offset);
+
+private:
+	class File : public SlotFileStatic {
+	public:
+		File(GobEngine *vm, const char *base);
+		~File();
+	};
+
+	uint32 _notesSize;
+	File *_file;
+	SavePartVars *_notes;
+};
+
+} // End of namespace Gob
+
+#endif // GOB_SAVE_SAVEHANDLER_H
diff --git a/engines/gob/save/saveload.cpp b/engines/gob/save/saveload.cpp
new file mode 100644
index 0000000000..26cc952add
--- /dev/null
+++ b/engines/gob/save/saveload.cpp
@@ -0,0 +1,135 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/endian.h"
+#include "common/savefile.h"
+
+#include "gob/gob.h"
+#include "gob/save/saveload.h"
+#include "gob/helper.h"
+#include "gob/global.h"
+#include "gob/video.h"
+#include "gob/draw.h"
+
+namespace Gob {
+
+SaveLoad::SaveLoad(GobEngine *vm, const char *targetName) : _vm(vm) {
+	_targetName = strdupcpy(targetName);
+}
+
+SaveLoad::~SaveLoad() {
+	delete[] _targetName;
+}
+
+const char *SaveLoad::stripPath(const char *fileName) {
+	const char *backSlash;
+	if ((backSlash = strrchr(fileName, '\\')))
+		return backSlash + 1;
+
+	return fileName;
+}
+
+int32 SaveLoad::getSize(const char *fileName) {
+	debugC(3, kDebugSaveLoad, "Requested size of save file \"%s\"", fileName);
+
+	SaveHandler *handler = getHandler(fileName);
+
+	if (!handler) {
+		warning("No save handler for \"%s\"", fileName);
+		return -1;
+	}
+
+	int32 size = handler->getSize();
+
+	debugC(4, kDebugSaveLoad, "Size is %d", size);
+	
+	return size;
+}
+
+bool SaveLoad::load(const char *fileName, int16 dataVar, int32 size, int32 offset) {
+	debugC(3, kDebugSaveLoad, "Requested loading of save file \"%s\" - %d, %d, %d",
+			fileName, dataVar, size, offset);
+
+	SaveHandler *handler = getHandler(fileName);
+
+	if (!handler) {
+		warning("No save handler for \"%s\" (%d, %d, %d)", fileName, dataVar, size, offset);
+		return false;
+	}
+
+	if (!handler->load(dataVar, size, offset)) {
+		const char *desc = getDescription(fileName);
+
+		if (!desc)
+			desc = "Unkown";
+
+		warning("Could not load %s (\"%s\" (%d, %d, %d))",
+				desc, fileName, dataVar, size, offset);
+		return false;
+	}
+
+	debugC(3, kDebugSaveLoad, "Successfully loaded game");
+	return true;
+}
+
+bool SaveLoad::save(const char *fileName, int16 dataVar, int32 size, int32 offset) {
+	debugC(3, kDebugSaveLoad, "Requested saving of save file \"%s\" - %d, %d, %d",
+			fileName, dataVar, size, offset);
+
+	SaveHandler *handler = getHandler(fileName);
+
+	if (!handler) {
+		warning("No save handler for \"%s\" (%d, %d, %d)", fileName, dataVar, size, offset);
+		return false;
+	}
+
+	if (!handler->save(dataVar, size, offset)) {
+		const char *desc = getDescription(fileName);
+
+		if (!desc)
+			desc = "Unkown";
+
+		warning("Could not save %s (\"%s\" (%d, %d, %d))",
+				desc, fileName, dataVar, size, offset);
+		return false;
+	}
+
+	debugC(3, kDebugSaveLoad, "Successfully saved game");
+	return true;
+}
+
+SaveLoad::SaveMode SaveLoad::getSaveMode(const char *fileName) const {
+	return kSaveModeNone;
+}
+
+SaveHandler *SaveLoad::getHandler(const char *fileName) const {
+	return 0;
+}
+
+const char *SaveLoad::getDescription(const char *fileName) const {
+	return 0;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveload.h b/engines/gob/save/saveload.h
new file mode 100644
index 0000000000..55a33272a7
--- /dev/null
+++ b/engines/gob/save/saveload.h
@@ -0,0 +1,452 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef GOB_SAVE_SAVELOAD_H
+#define GOB_SAVE_SAVELOAD_H
+
+#include "gob/save/savefile.h"
+#include "gob/save/savehandler.h"
+
+namespace Gob {
+
+class GobEngine;
+
+/** A system for saving and loading. */
+class SaveLoad {
+public:
+	/** How to handle the specific save. */
+	enum SaveMode {
+		kSaveModeNone,   //!< Don't handle it
+		kSaveModeIgnore, //!< Ignore it
+		kSaveModeExists, //!< Just claim it exists
+		kSaveModeSave    //!< A normal save
+	};
+
+	/** The constructor.
+	 *
+	 *  @param targetName The game's target name. Used as a base for the save names.
+	 */
+	SaveLoad(GobEngine *vm, const char *targetName);
+	virtual ~SaveLoad();
+
+	/** "foo\bar\quux.bla" => "quux.bla". */
+	static const char *stripPath(const char *fileName);
+
+	/** Returns how to handle that file. */
+	virtual SaveMode getSaveMode(const char *fileName) const;
+
+	/** Returns the file's (virtual) size. */
+	int32 getSize(const char *fileName);
+	/** Loads size bytes from offset into the variables starting with dataVar. */
+	bool load(const char *fileName, int16 dataVar, int32 size, int32 offset);
+	/** Saves size bytes from the variables starting with data dataVar at offset. */
+	bool save(const char *fileName, int16 dataVar, int32 size, int32 offset);
+
+protected:
+	GobEngine *_vm;
+
+	char *_targetName;
+
+	virtual SaveHandler *getHandler(const char *fileName) const;
+	virtual const char *getDescription(const char *fileName) const;
+};
+
+/** Save/Load class for Gobliins 2, Ween: The Prophecy and Bargon Attack. */
+class SaveLoad_v2 : public SaveLoad {
+public:
+	SaveLoad_v2(GobEngine *vm, const char *targetName);
+	virtual ~SaveLoad_v2();
+
+	SaveMode getSaveMode(const char *fileName) const;
+
+protected:
+	static const uint32 kSlotCount = 15;
+	static const uint32 kSlotNameLength = 40;
+
+	struct SaveFile {
+		const char *sourceName;
+		SaveMode mode;
+		SaveHandler *handler;
+		const char *description;
+	};
+
+	/** Handles the save slots. */
+	class GameHandler : public SaveHandler {
+	public:
+		GameHandler(GobEngine *vm, const char *target);
+		~GameHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+	private:
+		/** Slot file construction. */
+		class File : public SlotFileIndexed {
+		public:
+			File(GobEngine *vm, const char *base);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+		};
+
+		/** The index. kSlotCount * kSlotNameLength bytes. */
+		byte _index[600];
+		bool _hasIndex;
+
+		File *_slotFile;
+
+		void buildIndex(byte *buffer) const;
+	};
+
+	static SaveFile _saveFiles[];
+
+	GameHandler *_gameHandler;
+	NotesHandler *_notesHandler;
+	TempSpriteHandler *_tempSpriteHandler;
+
+	SaveHandler *getHandler(const char *fileName) const;
+	const char *getDescription(const char *fileName) const;
+
+	const SaveFile *getSaveFile(const char *fileName) const;
+	SaveFile *getSaveFile(const char *fileName);
+};
+
+/** Save/Load class for Goblins 3 and Lost in Time. */
+class SaveLoad_v3 : public SaveLoad {
+public:
+	enum ScreenshotType {
+		kScreenshotTypeGob3, //!< Goblins 3 type screenshot
+		kScreenshotTypeLost  //!< Lost in Time type screenshot
+	};
+
+	SaveLoad_v3(GobEngine *vm, const char *targetName, ScreenshotType sShotType);
+	virtual ~SaveLoad_v3();
+
+	SaveMode getSaveMode(const char *fileName) const;
+
+protected:
+	static const uint32 kSlotCount = 30;
+	static const uint32 kSlotNameLength = 40;
+
+	struct SaveFile {
+		const char *sourceName;
+		SaveMode mode;
+		SaveHandler *handler;
+		const char *description;
+	};
+
+	class ScreenshotHandler;
+
+	/** Handles the save slots. */
+	class GameHandler : public SaveHandler {
+	friend class SaveLoad_v3::ScreenshotHandler;
+	public:
+
+		GameHandler(GobEngine *vm, const char *target, bool usesScreenshots);
+		~GameHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+		bool saveScreenshot(int slot, const SavePartSprite *screenshot);
+		bool loadScreenshot(int slot, SavePartSprite *screenshot);
+
+	private:
+		/** Slot file construction. */
+		class File : public SlotFileIndexed {
+		public:
+			File(GobEngine *vm, const char *base);
+			File(const File &file);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+		};
+
+		File *_slotFile;
+
+		bool _usesScreenshots;
+
+		bool _firstSize;
+
+		/** Global properties. */
+		byte _props[500];
+		/** Index. kSlotCount * kSlotNameLength bytes. */
+		byte _index[1200];
+		bool _hasIndex;
+
+		SaveReader *_reader;
+		SaveWriter *_writer;
+
+		void buildIndex(byte *buffer) const;
+
+		bool createReader(int slot);
+		bool createWriter(int slot);
+
+	};
+
+	/** Handles the screenshots. */
+	class ScreenshotHandler : public TempSpriteHandler {
+	public:
+		ScreenshotHandler(GobEngine *vm, GameHandler *gameHandler, ScreenshotType sShotType);
+		~ScreenshotHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+	private:
+		/** Slot file construction. */
+		class File : public SaveLoad_v3::GameHandler::File {
+		public:
+			File(const SaveLoad_v3::GameHandler::File &file,
+					uint32 shotSize, uint32 shotIndexSize);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+
+			void buildIndex(byte *buffer) const;
+
+		protected:
+			uint32 _shotSize;
+			uint32 _shotIndexSize;
+		};
+
+		File *_file;
+		GameHandler *_gameHandler;
+		ScreenshotType _sShotType;
+
+		uint32 _shotSize;
+		int32 _shotIndexSize;
+		byte _index[80];
+	};
+
+	static SaveFile _saveFiles[];
+
+	ScreenshotType _sShotType;
+
+	GameHandler *_gameHandler;
+	NotesHandler *_notesHandler;
+	TempSpriteHandler *_tempSpriteHandler;
+	ScreenshotHandler *_screenshotHandler;
+
+	SaveHandler *getHandler(const char *fileName) const;
+	const char *getDescription(const char *fileName) const;
+
+	const SaveFile *getSaveFile(const char *fileName) const;
+	SaveFile *getSaveFile(const char *fileName);
+};
+
+/** Save/Load class for Woodruff. */
+class SaveLoad_v4 : public SaveLoad {
+public:
+	SaveLoad_v4(GobEngine *vm, const char *targetName);
+	virtual ~SaveLoad_v4();
+
+	SaveMode getSaveMode(const char *fileName) const;
+
+protected:
+	static const uint32 kSlotCount = 10;
+	static const uint32 kSlotNameLength = 40;
+
+	struct SaveFile {
+		const char *sourceName;
+		SaveMode mode;
+		SaveHandler *handler;
+		const char *description;
+	};
+
+	class ScreenPropsHandler;
+
+	/** Handles the save slots. */
+	class GameHandler : public SaveHandler {
+	friend class SaveLoad_v4::ScreenPropsHandler;
+	public:
+		GameHandler(GobEngine *vm, const char *target);
+		~GameHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+		bool saveScreenProps(int slot, const byte *props);
+		bool loadScreenProps(int slot, byte *props);
+
+	private:
+		/** Slot file construction. */
+		class File : public SlotFileIndexed {
+		public:
+			File(GobEngine *vm, const char *base);
+			File(const File &file);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+		};
+
+		bool _firstSize;
+
+		byte _props[500];
+		/** The index. kSlotCount * kSlotNameLength bytes + 800 bytes 0. */
+		byte _index[1200];
+		bool _hasIndex;
+
+		File *_slotFile;
+
+		SaveReader *_reader;
+		SaveWriter *_writer;
+
+		void buildIndex(byte *buffer) const;
+
+		bool createReader(int slot);
+		bool createWriter(int slot);
+	};
+
+	class CurScreenPropsHandler : public SaveHandler {
+	friend class SaveLoad_v4::ScreenPropsHandler;
+	public:
+		CurScreenPropsHandler(GobEngine *vm);
+		~CurScreenPropsHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+	private:
+		byte *_props;
+	};
+
+	class ScreenPropsHandler : public SaveHandler {
+	public:
+		ScreenPropsHandler(GobEngine *vm, uint32 slot,
+				CurScreenPropsHandler *curProps, GameHandler *gameHandler);
+		~ScreenPropsHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+	private:
+		class File : public SaveLoad_v4::GameHandler::File {
+		public:
+			File(const SaveLoad_v4::GameHandler::File &file, uint32 slot);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+
+		private:
+			uint32 _slot;
+		};
+
+		uint32 _slot;
+		CurScreenPropsHandler *_curProps;
+		GameHandler *_gameHandler;
+
+		File *_file;
+	};
+
+	static SaveFile _saveFiles[];
+
+	GameHandler *_gameHandler;
+	CurScreenPropsHandler *_curProps;
+	ScreenPropsHandler *_props[10];
+
+	SaveHandler *getHandler(const char *fileName) const;
+	const char *getDescription(const char *fileName) const;
+
+	const SaveFile *getSaveFile(const char *fileName) const;
+	SaveFile *getSaveFile(const char *fileName);
+};
+
+/** Save/Load class for Urban Runner. */
+class SaveLoad_v6 : public SaveLoad {
+public:
+	SaveLoad_v6(GobEngine *vm, const char *targetName);
+	virtual ~SaveLoad_v6();
+
+	SaveMode getSaveMode(const char *fileName) const;
+
+protected:
+	static const uint32 kSlotCount = 60;
+	static const uint32 kSlotNameLength = 40;
+
+	struct SaveFile {
+		const char *sourceName;
+		SaveMode mode;
+		SaveHandler *handler;
+		const char *description;
+	};
+
+	/** Handles the save slots. */
+	class GameHandler : public SaveHandler {
+	public:
+		GameHandler(GobEngine *vm, const char *target);
+		~GameHandler();
+
+		int32 getSize();
+		bool load(int16 dataVar, int32 size, int32 offset);
+		bool save(int16 dataVar, int32 size, int32 offset);
+
+	private:
+		/** Slot file construction. */
+		class File : public SlotFileIndexed {
+		public:
+			File(GobEngine *vm, const char *base);
+			~File();
+
+			int getSlot(int32 offset) const;
+			int getSlotRemainder(int32 offset) const;
+		};
+
+		byte _props[500];
+		/** The index. 500 bytes properties + kSlotCount * kSlotNameLength bytes. */
+		byte _index[2400];
+
+		File *_slotFile;
+
+		void buildIndex(byte *buffer) const;
+
+		void refreshProps();
+	};
+
+	static SaveFile _saveFiles[];
+
+	GameHandler *_gameHandler;
+
+	SaveHandler *getHandler(const char *fileName) const;
+	const char *getDescription(const char *fileName) const;
+
+	const SaveFile *getSaveFile(const char *fileName) const;
+	SaveFile *getSaveFile(const char *fileName);
+};
+
+} // End of namespace Gob
+
+#endif // GOB_SAVE_SAVELOAD_H
diff --git a/engines/gob/save/saveload_v2.cpp b/engines/gob/save/saveload_v2.cpp
new file mode 100644
index 0000000000..5746057626
--- /dev/null
+++ b/engines/gob/save/saveload_v2.cpp
@@ -0,0 +1,328 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "gob/save/saveload.h"
+#include "gob/save/saveconverter.h"
+#include "gob/helper.h"
+#include "gob/inter.h"
+#include "gob/variables.h"
+
+namespace Gob {
+
+SaveLoad_v2::SaveFile SaveLoad_v2::_saveFiles[] = {
+	{  "cat.inf", kSaveModeSave, 0, "savegame"},
+	{  "cat.cat", kSaveModeSave, 0, "savegame"}, // Alternative file
+	{ "save.inf", kSaveModeSave, 0, "temporary sprite"},
+	{ "bloc.inf", kSaveModeSave, 0, "notes"}
+};
+
+
+SaveLoad_v2::GameHandler::File::File(GobEngine *vm, const char *base) :
+	SlotFileIndexed(vm, SaveLoad_v2::kSlotCount, base, "s") {
+}
+
+SaveLoad_v2::GameHandler::File::~File() {
+}
+
+int SaveLoad_v2::GameHandler::File::getSlot(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 600) / varSize);
+}
+
+int SaveLoad_v2::GameHandler::File::getSlotRemainder(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 600) % varSize);
+}
+
+
+SaveLoad_v2::GameHandler::GameHandler(GobEngine *vm, const char *target) : SaveHandler(vm) {
+	memset(_index, 0, 600);
+	_hasIndex = false;
+
+	_slotFile = new File(vm, target);
+}
+
+SaveLoad_v2::GameHandler::~GameHandler() {
+	delete _slotFile;
+}
+
+int32 SaveLoad_v2::GameHandler::getSize() {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return _slotFile->tallyUpFiles(varSize, 600);
+}
+
+bool SaveLoad_v2::GameHandler::load(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to load all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset == 0) {
+		// Save index
+
+		if (size != 600) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Create/Fake the index
+		buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar));
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		char *slotFile = _slotFile->build(slot);
+
+		SaveReader *reader = 0;
+		SaveConverter_v2 converter(_vm, slotFile);
+
+		if (converter.isOldSave()) {
+			// Old save, plug the converter in
+			if (!converter.load())
+				return false;
+
+			reader = new SaveReader(2, slot, converter);
+
+		} else
+			// New save, load directly
+			reader = new SaveReader(2, slot, slotFile);
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		if (!reader->load()) {
+			delete reader;
+			return false;
+		}
+
+		delete[] slotFile;
+
+		if (!reader->readPart(0, &info)) {
+			delete reader;
+			return false;
+		}
+		if (!reader->readPart(1, &vars)) {
+			delete reader;
+			return false;
+		}
+
+		// Get all variables
+		if (!vars.writeInto(0, 0, varSize)) {
+			delete reader;
+			return false;
+		}
+
+		delete reader;
+	}
+
+	return true;
+}
+
+bool SaveLoad_v2::GameHandler::save(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to save all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset == 0) {
+		// Save index
+
+		if (size != 600) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Just copy the index into our buffer
+		_vm->_inter->_variables->copyTo(dataVar, _index, 600);
+		_hasIndex = true;
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		// An index is needed for the save slot description
+		if (!_hasIndex) {
+			warning("No index written yet");
+			return false;
+		}
+
+		_hasIndex = false;
+
+		char *slotFile = _slotFile->build(slot);
+
+		SaveWriter writer(2, slot, slotFile);
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		delete[] slotFile;
+
+		// Write the description
+		info.setDesc(_index + (slot * kSlotNameLength), kSlotNameLength);
+		// Write all variables
+		if (!vars.readFrom(0, 0, varSize))
+			return false;
+
+		if (!writer.writePart(0, &info))
+			return false;
+		if (!writer.writePart(1, &vars))
+			return false;
+	}
+
+	return true;
+}
+
+void SaveLoad_v2::GameHandler::buildIndex(byte *buffer) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return;
+
+	SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(),
+			0, _vm->getEndianness(), varSize);
+
+	SaveConverter_v2 converter(_vm);
+
+	_slotFile->buildIndex(buffer, info, &converter);
+}
+
+
+SaveLoad_v2::SaveLoad_v2(GobEngine *vm, const char *targetName) :
+		SaveLoad(vm, targetName) {
+
+	_gameHandler = new GameHandler(vm, _targetName);
+	_notesHandler = new NotesHandler(600, vm, _targetName);
+	_tempSpriteHandler = new TempSpriteHandler(vm);
+
+	_saveFiles[0].handler = _gameHandler;
+	_saveFiles[1].handler = _gameHandler;
+	_saveFiles[2].handler = _tempSpriteHandler;
+	_saveFiles[3].handler = _notesHandler;
+}
+
+SaveLoad_v2::~SaveLoad_v2() {
+	delete _gameHandler;
+	delete _notesHandler;
+	delete _tempSpriteHandler;
+}
+
+const SaveLoad_v2::SaveFile *SaveLoad_v2::getSaveFile(const char *fileName) const {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveLoad_v2::SaveFile *SaveLoad_v2::getSaveFile(const char *fileName) {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveHandler *SaveLoad_v2::getHandler(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->handler;
+
+	return 0;
+}
+
+const char *SaveLoad_v2::getDescription(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->description;
+
+	return 0;
+}
+
+SaveLoad::SaveMode SaveLoad_v2::getSaveMode(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->mode;
+
+	return kSaveModeNone;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveload_v3.cpp b/engines/gob/save/saveload_v3.cpp
new file mode 100644
index 0000000000..e2af420e08
--- /dev/null
+++ b/engines/gob/save/saveload_v3.cpp
@@ -0,0 +1,570 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "gob/save/saveload.h"
+#include "gob/save/saveconverter.h"
+#include "gob/helper.h"
+#include "gob/inter.h"
+#include "gob/variables.h"
+
+namespace Gob {
+
+SaveLoad_v3::SaveFile SaveLoad_v3::_saveFiles[] = {
+	{    "cat.inf", kSaveModeSave  , 0, "savegame"},
+	{    "ima.inf", kSaveModeSave  , 0, "screenshot"},
+	{  "intro.$$$", kSaveModeSave  , 0, "temporary sprite"},
+	{   "bloc.inf", kSaveModeSave  , 0, "notes"},
+	{   "prot",     kSaveModeIgnore, 0, 0},
+	{ "config",     kSaveModeIgnore, 0, 0}
+};
+
+
+SaveLoad_v3::GameHandler::File::File(GobEngine *vm, const char *base) :
+	SlotFileIndexed(vm, SaveLoad_v3::kSlotCount, base, "s") {
+}
+
+SaveLoad_v3::GameHandler::File::File(const File &file) :
+	SlotFileIndexed(file._vm, file._slotCount, file._base, file._ext) {
+}
+
+SaveLoad_v3::GameHandler::File::~File() {
+}
+
+int SaveLoad_v3::GameHandler::File::getSlot(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 1700) / varSize);
+}
+
+int SaveLoad_v3::GameHandler::File::getSlotRemainder(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 1700) % varSize);
+}
+
+
+SaveLoad_v3::GameHandler::GameHandler(GobEngine *vm, const char *target,
+		bool usesScreenshots) : SaveHandler(vm) {
+
+	_slotFile = new File(vm, target);
+
+	_usesScreenshots = usesScreenshots;
+
+	_firstSize = true;
+	memset(_props, 0, 500);
+	memset(_index, 0, 1200);
+	_hasIndex = false;
+
+	_writer = 0;
+	_reader = 0;
+}
+
+SaveLoad_v3::GameHandler::~GameHandler() {
+	delete _slotFile;
+	delete _reader;
+	delete _writer;
+}
+
+int32 SaveLoad_v3::GameHandler::getSize() {
+	// Fake an empty save file for the very first query, to get clear properties
+	if (_firstSize) {
+		_firstSize = false;
+		return -1;
+	}
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return _slotFile->tallyUpFiles(varSize, 1700);
+}
+
+bool SaveLoad_v3::GameHandler::load(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to load all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Global properties, like joker usage
+
+		debugC(3, kDebugSaveLoad, "Loading global properties");
+
+		if ((size + offset) > 500) {
+			warning("Wrong global properties list size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyFrom(dataVar, _props + offset, size);
+
+	} else if (offset == 500) {
+		// Save index
+
+		if (size != 1200) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Create/Fake the index
+		buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar));
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		_hasIndex = false;
+
+		if (!createReader(slot))
+			return false;
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		if (!_reader->readPart(0, &info))
+			return false;
+		if (!_reader->readPart(1, &vars))
+			return false;
+
+		// Get all variables
+		if (!vars.writeInto(0, 0, varSize))
+			return false;
+
+	}
+
+	return true;
+}
+
+bool SaveLoad_v3::GameHandler::save(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to save all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Global properties, like joker usage
+
+		debugC(3, kDebugSaveLoad, "Saving global properties");
+
+		if ((size + offset) > 500) {
+			warning("Wrong global properties list size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyTo(dataVar, _props + offset, size);
+
+	} else if (offset == 500) {
+		// Save index
+
+		if (size != 1200) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Just copy the index into our buffer
+		_vm->_inter->_variables->copyTo(dataVar, _index, 1200);
+		_hasIndex = true;
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		// An index is needed for the save slot description
+		if (!_hasIndex) {
+			warning("No index written yet");
+			return false;
+		}
+
+		_hasIndex = false;
+
+		if (!createWriter(slot))
+			return false;
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		// Write the description
+		info.setDesc(_index + (slot * kSlotNameLength), kSlotNameLength);
+		// Write all variables
+		if (!vars.readFrom(0, 0, varSize))
+			return false;
+
+		if (!_writer->writePart(0, &info))
+			return false;
+		if (!_writer->writePart(1, &vars))
+			return false;
+
+	}
+
+	return true;
+}
+
+bool SaveLoad_v3::GameHandler::saveScreenshot(int slot,
+		const SavePartSprite *screenshot) {
+
+	if (!createWriter(slot))
+		return false;
+
+	return _writer->writePart(2, screenshot);
+}
+
+bool SaveLoad_v3::GameHandler::loadScreenshot(int slot,
+		SavePartSprite *screenshot) {
+
+	if (!createReader(slot))
+		return false;
+
+	return _reader->readPart(2, screenshot);
+}
+
+void SaveLoad_v3::GameHandler::buildIndex(byte *buffer) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return;
+
+	SavePartInfo info(40, (uint32) _vm->getGameType(), 0, _vm->getEndianness(), varSize);
+
+	SaveConverter_v3 converter(_vm);
+
+	_slotFile->buildIndex(buffer, info, &converter);
+}
+
+bool SaveLoad_v3::GameHandler::createReader(int slot) {
+	// If slot < 0, just check if a reader exists
+	if (slot < 0)
+		return (_reader != 0);
+
+	if (!_reader || (_reader->getSlot() != ((uint32) slot))) {
+		char *slotFile = _slotFile->build(slot);
+		
+		if (!slotFile)
+			return false;
+
+		delete _reader;
+
+		SaveConverter_v3 converter(_vm, slotFile);
+		if (converter.isOldSave()) {
+			// Old save, plug the converter in
+			if (!converter.load()) {
+				delete[] slotFile;
+				return false;
+			}
+
+			_reader = new SaveReader(_usesScreenshots ? 3 : 2, slot, converter);
+
+		} else
+			_reader = new SaveReader(_usesScreenshots ? 3 : 2, slot, slotFile);
+		
+		delete[] slotFile;
+
+		if (!_reader->load()) {
+			delete _reader;
+			_reader = 0;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool SaveLoad_v3::GameHandler::createWriter(int slot) {
+	// If slot < 0, just check if a writer exists
+	if (slot < 0)
+		return (_writer != 0);
+
+	if (!_writer || (_writer->getSlot() != ((uint32) slot))) {
+		char *slotFile = _slotFile->build(slot);
+		
+		if (!slotFile)
+			return false;
+
+		delete _writer;
+		_writer = new SaveWriter(_usesScreenshots ? 3 : 2, slot, slotFile);
+		
+		delete[] slotFile;
+	}
+
+	return true;
+}
+
+
+SaveLoad_v3::ScreenshotHandler::File::File(const SaveLoad_v3::GameHandler::File &file,
+		uint32 shotSize, uint32 shotIndexSize) : SaveLoad_v3::GameHandler::File(file) {
+
+	_shotSize = shotSize;
+	_shotIndexSize = shotIndexSize;
+}
+
+SaveLoad_v3::ScreenshotHandler::File::~File() {
+}
+
+int SaveLoad_v3::ScreenshotHandler::File::getSlot(int32 offset) const {
+	return ((offset - _shotIndexSize) / _shotSize);
+}
+
+int SaveLoad_v3::ScreenshotHandler::File::getSlotRemainder(int32 offset) const {
+	return ((offset - _shotIndexSize) % _shotSize);
+}
+
+void SaveLoad_v3::ScreenshotHandler::File::buildIndex(byte *buffer) const {
+	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
+	Common::InSaveFile *in;
+
+	for (uint32 i = 0; i < _slotCount; i++, buffer++) {
+		char *slotFile = build(i);
+
+		if (slotFile && ((in = saveMan->openForLoading(slotFile)))) {
+			delete in;
+			*buffer = 1;
+		} else
+			*buffer = 0;
+
+		delete[] slotFile;
+	}
+}
+
+
+SaveLoad_v3::ScreenshotHandler::ScreenshotHandler(GobEngine *vm,
+		GameHandler *gameHandler, ScreenshotType sShotType) : TempSpriteHandler(vm) {
+
+	assert(gameHandler);
+
+	_gameHandler = gameHandler;
+	_sShotType   = sShotType;
+
+	_shotSize =      (_sShotType == kScreenshotTypeLost) ? 4768 : 19968;
+	_shotIndexSize = (_sShotType == kScreenshotTypeLost) ?   50 :    80;
+
+	_file = new File(*_gameHandler->_slotFile, _shotSize, _shotIndexSize);
+
+	memset(_index, 0, 80);
+}
+
+SaveLoad_v3::ScreenshotHandler::~ScreenshotHandler() {
+	delete _file;
+}
+
+int32 SaveLoad_v3::ScreenshotHandler::getSize() {
+	return _file->tallyUpFiles(_shotSize, _shotIndexSize);
+}
+
+bool SaveLoad_v3::ScreenshotHandler::load(int16 dataVar, int32 size, int32 offset) {
+	if (offset < _shotIndexSize) {
+		// Screenshot index list
+
+		if ((size + offset) > _shotIndexSize) {
+			warning("Wrong screenshot index offset (%d, %d)", size, offset);
+			return false;
+		}
+
+		if (_sShotType == kScreenshotTypeGob3) {
+			// Create/Fake the index
+			_file->buildIndex(_index + 40);
+			// The last 10 bytes are 0
+			memset(_index + 70, 0, 10);
+		} else if (_sShotType == kScreenshotTypeLost) {
+			// Create/Fake the index
+			_file->buildIndex(_index);
+			// The last byte is 0
+			_index[30] = 0;
+		}
+
+		_vm->_inter->_variables->copyFrom(dataVar, _index + offset, size);
+
+	} else {
+		// Screenshot
+
+		uint32 slot = _file->getSlot(offset);
+		int slotRem = _file->getSlotRemainder(offset);
+
+		if ((slot >= kSlotCount) || (slotRem != 0))
+			return false;
+
+		if (!TempSpriteHandler::createSprite(dataVar, size, offset))
+			return false;
+
+		if (!_gameHandler->loadScreenshot(slot, _sprite))
+			return false;
+
+		if (!TempSpriteHandler::load(dataVar, size, offset))
+			return false;
+	}
+
+	return true;
+}
+
+bool SaveLoad_v3::ScreenshotHandler::save(int16 dataVar, int32 size, int32 offset) {
+	if (offset < _shotIndexSize) {
+		// Screenshot index list
+
+		if ((size + offset) > _shotIndexSize) {
+			warning("Wrong screenshot index offset (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyTo(dataVar, _index + offset, size);
+
+	} else {
+		// Screenshot
+
+		if (!TempSpriteHandler::save(dataVar, size, offset))
+			return false;
+
+		uint32 slot = _file->getSlot(offset);
+		int slotRem = _file->getSlotRemainder(offset);
+
+		if ((slot >= kSlotCount) || (slotRem != 0))
+			return false;
+
+		return _gameHandler->saveScreenshot(slot, _sprite);
+	}
+
+	return true;
+}
+
+
+SaveLoad_v3::SaveLoad_v3(GobEngine *vm, const char *targetName, ScreenshotType sShotType) :
+		SaveLoad(vm, targetName) {
+
+	_sShotType = sShotType;
+
+	// The Amiga version doesn't use screenshots
+	if (_vm->getPlatform() == Common::kPlatformAmiga) {
+		_gameHandler = new GameHandler(vm, _targetName, false);
+		_screenshotHandler = 0;
+	} else {
+		_gameHandler = new GameHandler(vm, _targetName, true);
+		_screenshotHandler = new ScreenshotHandler(vm, _gameHandler, sShotType);
+	}
+	
+	_tempSpriteHandler = new TempSpriteHandler(vm);
+	_notesHandler = new NotesHandler(2560, vm, _targetName);
+
+	_saveFiles[0].handler = _gameHandler;
+	_saveFiles[1].handler = _screenshotHandler;
+	_saveFiles[2].handler = _tempSpriteHandler;
+	_saveFiles[3].handler = _notesHandler;
+}
+
+SaveLoad_v3::~SaveLoad_v3() {
+	delete _screenshotHandler;
+	delete _gameHandler;
+	delete _notesHandler;
+	delete _tempSpriteHandler;
+}
+
+const SaveLoad_v3::SaveFile *SaveLoad_v3::getSaveFile(const char *fileName) const {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveLoad_v3::SaveFile *SaveLoad_v3::getSaveFile(const char *fileName) {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveHandler *SaveLoad_v3::getHandler(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->handler;
+
+	return 0;
+}
+
+const char *SaveLoad_v3::getDescription(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->description;
+
+	return 0;
+}
+
+SaveLoad::SaveMode SaveLoad_v3::getSaveMode(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->mode;
+
+	return kSaveModeNone;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveload_v4.cpp b/engines/gob/save/saveload_v4.cpp
new file mode 100644
index 0000000000..fcf9a1fe6f
--- /dev/null
+++ b/engines/gob/save/saveload_v4.cpp
@@ -0,0 +1,555 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "gob/save/saveload.h"
+#include "gob/save/saveconverter.h"
+#include "gob/helper.h"
+#include "gob/inter.h"
+#include "gob/variables.h"
+
+namespace Gob {
+
+SaveLoad_v4::SaveFile SaveLoad_v4::_saveFiles[] = {
+	{   "cat.inf", kSaveModeSave, 0, "savegame"},
+	{  "save.tmp", kSaveModeSave, 0, "current screen properties"},
+	{ "save0.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 0
+	{ "save1.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 1
+	{ "save2.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 2
+	{ "save3.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 3
+	{ "save4.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 4
+	{ "save5.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 5
+	{ "save6.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 6
+	{ "save7.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 7
+	{ "save8.tmp", kSaveModeSave, 0, "savegame screen properties"}, // Slot 8
+	{ "save9.tmp", kSaveModeSave, 0, "savegame screen properties"}  // Slot 9
+};
+
+
+SaveLoad_v4::GameHandler::File::File(GobEngine *vm, const char *base) :
+	SlotFileIndexed(vm, SaveLoad_v4::kSlotCount, base, "s") {
+}
+
+SaveLoad_v4::GameHandler::File::File(const File &file) :
+	SlotFileIndexed(file._vm, file._slotCount, file._base, file._ext) {
+}
+
+SaveLoad_v4::GameHandler::File::~File() {
+}
+
+int SaveLoad_v4::GameHandler::File::getSlot(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 1700) / varSize);
+}
+
+int SaveLoad_v4::GameHandler::File::getSlotRemainder(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 1700) % varSize);
+}
+
+
+SaveLoad_v4::GameHandler::GameHandler(GobEngine *vm, const char *target) : SaveHandler(vm) {
+	_firstSize = true;
+	memset(_props, 0, 500);
+	memset(_index, 0, 1200);
+	_hasIndex = false;
+
+	_slotFile = new File(vm, target);
+
+	_writer = 0;
+	_reader = 0;
+}
+
+SaveLoad_v4::GameHandler::~GameHandler() {
+	delete _slotFile;
+	delete _reader;
+	delete _writer;
+}
+
+int32 SaveLoad_v4::GameHandler::getSize() {
+	// Fake an empty save file for the very first query, to get clear properties
+	if (_firstSize) {
+		_firstSize = false;
+		return -1;
+	}
+
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return _slotFile->tallyUpFiles(varSize, 1700);
+}
+
+bool SaveLoad_v4::GameHandler::load(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to load all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Global properties
+
+		debugC(3, kDebugSaveLoad, "Loading global properties");
+
+		if ((size + offset) > 500) {
+			warning("Wrong global properties list size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyFrom(dataVar, _props + offset, size);
+
+	} else if (offset == 500) {
+		// Save index
+
+		if (size != 1200) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Create/Fake the index
+		buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar));
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		_hasIndex = false;
+
+		if (!createReader(slot))
+			return false;
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		if (!_reader->readPart(0, &info))
+			return false;
+		if (!_reader->readPart(1, &vars))
+			return false;
+
+		// Get all variables
+		if (!vars.writeInto(0, 0, varSize))
+			return false;
+
+	}
+
+	return true;
+}
+
+bool SaveLoad_v4::GameHandler::save(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to load all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Global properties
+
+		debugC(3, kDebugSaveLoad, "Saving global properties");
+
+		if ((size + offset) > 500) {
+			warning("Wrong global properties list size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyTo(dataVar, _props + offset, size);
+
+	} else if (offset == 500) {
+		// Save index
+
+		if (size != 1200) {
+			warning("Requested index has wrong size (%d)", size);
+			return false;
+		}
+
+		// Just copy the index into our buffer
+		_vm->_inter->_variables->copyTo(dataVar, _index, 1200);
+		_hasIndex = true;
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		// An index is needed for the save slot description
+		if (!_hasIndex) {
+			warning("No index written yet");
+			return false;
+		}
+
+		_hasIndex = false;
+
+		if (!createWriter(slot))
+			return false;
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		// Write the description
+		info.setDesc(_index + (slot * kSlotNameLength), kSlotNameLength);
+		// Write all variables
+		if (!vars.readFrom(0, 0, varSize))
+			return false;
+
+		if (!_writer->writePart(0, &info))
+			return false;
+		if (!_writer->writePart(1, &vars))
+			return false;
+
+	}
+
+	return true;
+}
+
+bool SaveLoad_v4::GameHandler::saveScreenProps(int slot, const byte *props) {
+	if (!createWriter(slot))
+		return false;
+
+	SavePartMem mem(256000);
+
+	if (!mem.readFrom(props, 0, 256000))
+		return false;
+
+	return _writer->writePart(2, &mem);
+}
+
+bool SaveLoad_v4::GameHandler::loadScreenProps(int slot, byte *props) {
+	if (!createReader(slot))
+		return false;
+
+	SavePartMem mem(256000);
+
+	if (!_reader->readPart(2, &mem))
+		return false;
+
+	if (!mem.writeInto(props, 0, 256000))
+		return false;
+
+	return true;
+}
+
+void SaveLoad_v4::GameHandler::buildIndex(byte *buffer) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return;
+
+	SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(),
+			0, _vm->getEndianness(), varSize);
+
+	SaveConverter_v4 converter(_vm);
+
+	_slotFile->buildIndex(buffer, info, &converter);
+
+	// 400 bytes index + 800 bytes 0
+	memset(buffer + 400, 0, 800);
+}
+
+bool SaveLoad_v4::GameHandler::createReader(int slot) {
+	// If slot < 0, just check if a reader exists
+	if (slot < 0)
+		return (_reader != 0);
+
+	if (!_reader || (_reader->getSlot() != ((uint32) slot))) {
+		char *slotFile = _slotFile->build(slot);
+		
+		if (!slotFile)
+			return false;
+
+		delete _reader;
+
+		SaveConverter_v4 converter(_vm, slotFile);
+		if (converter.isOldSave()) {
+			// Old save, plug the converter in
+			if (!converter.load()) {
+				delete[] slotFile;
+				return false;
+			}
+
+			_reader = new SaveReader(3, slot, converter);
+
+		} else
+			_reader = new SaveReader(3, slot, slotFile);
+		
+		delete[] slotFile;
+
+		if (!_reader->load()) {
+			delete _reader;
+			_reader = 0;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool SaveLoad_v4::GameHandler::createWriter(int slot) {
+	// If slot < 0, just check if a writer exists
+	if (slot < 0)
+		return (_writer != 0);
+
+	if (!_writer || (_writer->getSlot() != ((uint32) slot))) {
+		char *slotFile = _slotFile->build(slot);
+		
+		if (!slotFile)
+			return false;
+
+		delete _writer;
+		_writer = new SaveWriter(3, slot, slotFile);
+		
+		delete[] slotFile;
+	}
+
+	return true;
+}
+
+
+SaveLoad_v4::CurScreenPropsHandler::CurScreenPropsHandler(GobEngine *vm) :
+	SaveHandler(vm) {
+
+	_props = new byte[256000];
+	memset(_props, 0, 256000);
+}
+
+SaveLoad_v4::CurScreenPropsHandler::~CurScreenPropsHandler() {
+	delete[] _props;
+}
+
+int32 SaveLoad_v4::CurScreenPropsHandler::getSize() {
+	return 256000;
+}
+
+bool SaveLoad_v4::CurScreenPropsHandler::load(int16 dataVar,
+		int32 size, int32 offset) {
+
+	// Using a sprite as a buffer
+	if (size <= 0)
+		return true;
+
+	if ((offset < 0) || (size + offset) > 256000) {
+		warning("Invalid size (%d) or offset (%d)", size, offset);
+		return false;
+	}
+
+	debugC(3, kDebugSaveLoad, "Loading screen properties (%d, %d, %d)",
+			dataVar, size, offset);
+
+	_vm->_inter->_variables->copyFrom(dataVar, _props + offset, size);
+
+	return true;
+}
+
+bool SaveLoad_v4::CurScreenPropsHandler::save(int16 dataVar,
+		int32 size, int32 offset) {
+
+	// Using a sprite as a buffer
+	if (size <= 0)
+		return true;
+
+	if ((offset < 0) || (size + offset) > 256000) {
+		warning("Invalid size (%d) or offset (%d)", size, offset);
+		return false;
+	}
+
+	debugC(3, kDebugSaveLoad, "Saving screen properties (%d, %d, %d)",
+			dataVar, size, offset);
+
+	_vm->_inter->_variables->copyTo(dataVar, _props + offset, size);
+
+	return true;
+}
+
+
+SaveLoad_v4::ScreenPropsHandler::File::File(const SaveLoad_v4::GameHandler::File &file,
+		uint32 slot) : SaveLoad_v4::GameHandler::File(file) {
+
+	_slot = slot;
+}
+
+SaveLoad_v4::ScreenPropsHandler::File::File::~File() {
+}
+
+int SaveLoad_v4::ScreenPropsHandler::File::File::getSlot(int32 offset) const {
+	return _slot;
+}
+
+int SaveLoad_v4::ScreenPropsHandler::File::File::getSlotRemainder(int32 offset) const {
+	return 0;
+}
+
+
+SaveLoad_v4::ScreenPropsHandler::ScreenPropsHandler(GobEngine *vm, uint32 slot,
+		CurScreenPropsHandler *curProps, GameHandler *gameHandler) : SaveHandler(vm) {
+
+	_slot = slot;
+	_curProps = curProps;
+	_gameHandler = gameHandler;
+
+	_file = new File(*_gameHandler->_slotFile, _slot);
+}
+
+SaveLoad_v4::ScreenPropsHandler::~ScreenPropsHandler() {
+	delete _file;
+}
+
+int32 SaveLoad_v4::ScreenPropsHandler::getSize() {
+	if (_file->exists())
+		return 256000;
+
+	return 0;
+}
+
+bool SaveLoad_v4::ScreenPropsHandler::load(int16 dataVar, int32 size, int32 offset) {
+	if (size != -5) {
+		warning("Invalid saving procedure (%d, %d, %d)", dataVar, size, offset);
+		return false;
+	}
+
+	return _gameHandler->loadScreenProps(_file->getSlot(offset), _curProps->_props);
+}
+
+bool SaveLoad_v4::ScreenPropsHandler::save(int16 dataVar, int32 size, int32 offset) {
+	if (size != -5) {
+		warning("Invalid saving procedure (%d, %d, %d)", dataVar, size, offset);
+		return false;
+	}
+
+	return _gameHandler->saveScreenProps(_file->getSlot(offset), _curProps->_props);
+}
+
+
+SaveLoad_v4::SaveLoad_v4(GobEngine *vm, const char *targetName) :
+		SaveLoad(vm, targetName) {
+
+	_gameHandler = new GameHandler(vm, _targetName);
+	_curProps    = new CurScreenPropsHandler(vm);
+	for (int i = 0; i < 10; i++)
+		_props[i] = new ScreenPropsHandler(vm, i, _curProps, _gameHandler);
+
+	_saveFiles[0].handler = _gameHandler;
+	_saveFiles[1].handler = _curProps;
+	for (int i = 0; i < 10; i++)
+		_saveFiles[i + 2].handler = _props[i];
+}
+
+SaveLoad_v4::~SaveLoad_v4() {
+	delete _gameHandler;
+	delete _curProps;
+	for (int i = 0; i < 10; i++)
+		delete _props[i];
+}
+
+const SaveLoad_v4::SaveFile *SaveLoad_v4::getSaveFile(const char *fileName) const {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveLoad_v4::SaveFile *SaveLoad_v4::getSaveFile(const char *fileName) {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveHandler *SaveLoad_v4::getHandler(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->handler;
+
+	return 0;
+}
+
+const char *SaveLoad_v4::getDescription(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->description;
+
+	return 0;
+}
+
+SaveLoad::SaveMode SaveLoad_v4::getSaveMode(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->mode;
+
+	return kSaveModeNone;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/save/saveload_v6.cpp b/engines/gob/save/saveload_v6.cpp
new file mode 100644
index 0000000000..5f772c75f7
--- /dev/null
+++ b/engines/gob/save/saveload_v6.cpp
@@ -0,0 +1,342 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "gob/save/saveload.h"
+#include "gob/save/saveconverter.h"
+#include "gob/helper.h"
+#include "gob/inter.h"
+#include "gob/variables.h"
+
+namespace Gob {
+
+SaveLoad_v6::SaveFile SaveLoad_v6::_saveFiles[] = {
+	{  "cat.inf", kSaveModeSave,   0, "savegame"}, // Save file
+	{  "mdo.def", kSaveModeExists, 0, 0},
+	{"no_cd.txt", kSaveModeExists, 0, 0},
+};
+
+
+SaveLoad_v6::GameHandler::File::File(GobEngine *vm, const char *base) :
+	SlotFileIndexed(vm, SaveLoad_v6::kSlotCount, base, "s") {
+}
+
+SaveLoad_v6::GameHandler::File::~File() {
+}
+
+int SaveLoad_v6::GameHandler::File::getSlot(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 2900) / varSize);
+}
+
+int SaveLoad_v6::GameHandler::File::getSlotRemainder(int32 offset) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return ((offset - 2900) % varSize);
+}
+
+
+SaveLoad_v6::GameHandler::GameHandler(GobEngine *vm, const char *target) : SaveHandler(vm) {
+	memset(_props, 0,  500);
+	memset(_index, 0, 2400);
+
+	_slotFile = new File(vm, target);
+}
+
+SaveLoad_v6::GameHandler::~GameHandler() {
+	delete _slotFile;
+}
+
+int32 SaveLoad_v6::GameHandler::getSize() {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return -1;
+
+	return _slotFile->tallyUpFiles(varSize, 2900);
+}
+
+bool SaveLoad_v6::GameHandler::load(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to load all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Properties
+
+		refreshProps();
+
+		if ((offset + size) > 500) {
+			warning("Wrong index size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyFrom(dataVar, _props + offset, size);
+
+	} else if (offset < 2900) {
+		// Save index
+
+		if (size != 2400) {
+			warning("Wrong index size (%d, %d)", size, offset);
+			return false;
+		}
+
+		buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar));
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		char *slotFile = _slotFile->build(slot);
+
+		SaveReader *reader = 0;
+		SaveConverter_v6 converter(_vm, slotFile);
+
+		if (converter.isOldSave()) {
+			// Old save, plug the converter in
+			if (!converter.load())
+				return false;
+
+			reader = new SaveReader(2, slot, converter);
+
+		} else
+			// New save, load directly
+			reader = new SaveReader(2, slot, slotFile);
+
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		if (!reader->load()) {
+			delete reader;
+			return false;
+		}
+
+		delete[] slotFile;
+
+		if (!reader->readPart(0, &info)) {
+			delete reader;
+			return false;
+		}
+		if (!reader->readPart(1, &vars)) {
+			delete reader;
+			return false;
+		}
+
+		// Get all variables
+		if (!vars.writeInto(0, 0, varSize)) {
+			delete reader;
+			return false;
+		}
+
+		delete reader;
+	}
+
+	return true;
+}
+
+bool SaveLoad_v6::GameHandler::save(int16 dataVar, int32 size, int32 offset) {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return false;
+
+	if (size == 0) {
+		// Indicator to save all variables
+		dataVar = 0;
+		size = varSize;
+	}
+
+	if (offset < 500) {
+		// Properties
+
+		if ((offset + size) > 500) {
+			warning("Wrong index size (%d, %d)", size, offset);
+			return false;
+		}
+
+		_vm->_inter->_variables->copyTo(dataVar, _props + offset, size);
+
+		refreshProps();
+
+	}  else if (offset < 2900) {
+		// Save index
+
+		if (size != 2400) {
+			warning("Wrong index size (%d, %d)", size, offset);
+			return false;
+		}
+
+		// Just copy the index into our buffer
+		_vm->_inter->_variables->copyTo(dataVar, _index, 2400);
+
+	} else {
+		// Save slot, whole variable block
+
+		uint32 slot = _slotFile->getSlot(offset);
+		int slotRem = _slotFile->getSlotRemainder(offset);
+
+		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
+
+		if ((slot >= kSlotCount) || (slotRem != 0) ||
+		    (dataVar != 0) || (((uint32) size) != varSize)) {
+
+			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
+					dataVar, size, offset, slot, slotRem);
+			return false;
+		}
+
+		char *slotFile = _slotFile->build(slot);
+
+		SaveWriter writer(2, slot, slotFile);
+		SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(), 0,
+				_vm->getEndianness(), varSize);
+		SavePartVars vars(_vm, varSize);
+
+		delete[] slotFile;
+
+		// Write the description
+		info.setDesc(_index + (slot * kSlotNameLength), kSlotNameLength);
+		// Write all variables
+		if (!vars.readFrom(0, 0, varSize))
+			return false;
+
+		if (!writer.writePart(0, &info))
+			return false;
+		if (!writer.writePart(1, &vars))
+			return false;
+	}
+
+	return true;
+}
+
+void SaveLoad_v6::GameHandler::buildIndex(byte *buffer) const {
+	uint32 varSize = SaveHandler::getVarSize(_vm);
+
+	if (varSize == 0)
+		return;
+
+	SavePartInfo info(kSlotNameLength, (uint32) _vm->getGameType(),
+			0, _vm->getEndianness(), varSize);
+
+	SaveConverter_v6 converter(_vm);
+
+	_slotFile->buildIndex(buffer, info, &converter);
+}
+
+void SaveLoad_v6::GameHandler::refreshProps() {
+	uint32 maxSlot = _slotFile->getSlotMax();
+
+	memset(_props + 40, 0xFF, 40);          // Joker
+	_props[159] = 0x03;                     // # of joker unused
+	WRITE_LE_UINT32(_props + 160, maxSlot); // # of saves
+}
+
+
+SaveLoad_v6::SaveLoad_v6(GobEngine *vm, const char *targetName) :
+		SaveLoad(vm, targetName) {
+
+	_gameHandler = new GameHandler(vm, _targetName);
+
+	_saveFiles[0].handler = _gameHandler;
+}
+
+SaveLoad_v6::~SaveLoad_v6() {
+	delete _gameHandler;
+}
+
+const SaveLoad_v6::SaveFile *SaveLoad_v6::getSaveFile(const char *fileName) const {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveLoad_v6::SaveFile *SaveLoad_v6::getSaveFile(const char *fileName) {
+	fileName = stripPath(fileName);
+
+	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
+		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
+			return &_saveFiles[i];
+
+	return 0;
+}
+
+SaveHandler *SaveLoad_v6::getHandler(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->handler;
+
+	return 0;
+}
+
+const char *SaveLoad_v6::getDescription(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->description;
+
+	return 0;
+}
+
+SaveLoad::SaveMode SaveLoad_v6::getSaveMode(const char *fileName) const {
+	const SaveFile *saveFile = getSaveFile(fileName);
+
+	if (saveFile)
+		return saveFile->mode;
+
+	return kSaveModeNone;
+}
+
+} // End of namespace Gob
diff --git a/engines/gob/saveload.cpp b/engines/gob/saveload.cpp
deleted file mode 100644
index 1584cedc95..0000000000
--- a/engines/gob/saveload.cpp
+++ /dev/null
@@ -1,879 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/endian.h"
-#include "common/savefile.h"
-
-#include "gob/gob.h"
-#include "gob/saveload.h"
-#include "gob/draw.h"
-
-namespace Gob {
-
-TempSprite::TempSprite() {
-	_sprite = 0;
-	_width = _height = 0;
-	_size = -1;
-	memset(_palette, 0, 768);
-}
-
-TempSprite::~TempSprite() {
-	delete[] _sprite;
-}
-
-int TempSprite::getSpriteIndex(int32 size) const {
-	if (size < -1000)
-		size += 1000;
-
-	return -size - 1;
-}
-
-bool TempSprite::getSpritePalette(int32 size) const {
-	return size < -1000;
-}
-
-bool TempSprite::getProperties(int16 dataVar, int32 size, int32 offset,
-		int &index, bool &palette) const {
-
-	if (size >= 0) {
-		warning("Invalid index (%d)", size);
-		return false;
-	}
-
-	index = getSpriteIndex(size);
-	palette = getSpritePalette(size);
-
-	if ((index < 0) || (index >= SPRITES_COUNT)) {
-		warning("Index out of range (%d)", index);
-		return false;
-	}
-
-	return true;
-}
-
-int32 TempSprite::getSize() const {
-	return _size;
-}
-
-bool TempSprite::saveSprite(const SurfaceDesc &surfDesc) {
-	delete[] _sprite;
-
-	_width = surfDesc.getWidth();
-	_height = surfDesc.getHeight();
-	_size = _width * _height;
-	_sprite = new byte[_size];
-
-	memcpy(_sprite, surfDesc.getVidMem(), _size);
-
-	return true;
-}
-
-bool TempSprite::savePalette(const Video::Color *palette) {
-	memcpy((byte *) _palette, (const byte *) palette, 768);
-	return true;
-}
-
-bool TempSprite::loadSprite(SurfaceDesc &surfDesc) {
-	if (!_sprite) {
-		warning("No sprite saved");
-		return false;
-	}
-
-	if (_size != (surfDesc.getWidth() * surfDesc.getHeight())) {
-		warning("Dimensions don't match (%dx%d - %dx%d",
-				_width, _height, surfDesc.getWidth(), surfDesc.getHeight());
-		return false;
-	}
-
-	memcpy(surfDesc.getVidMem(), _sprite, _size);
-
-	return true;
-}
-
-bool TempSprite::loadPalette(Video::Color *palette) {
-	memcpy((byte *) palette, (byte *) _palette, 768);
-	return true;
-}
-
-bool TempSprite::toBuffer(byte *buffer, int32 size, bool palette) const {
-
-	int32 haveSize = _size + (palette ? 768 : 0);
-	if (size != haveSize) {
-		warning("Sizes don't match (%d != %d)", size, haveSize);
-		return false;
-	}
-
-	if (palette) {
-		memcpy(buffer, (const byte *) _palette, 768);
-		buffer += 768;
-	}
-
-	memcpy(buffer, _sprite, _size);
-
-	return true;
-}
-
-bool TempSprite::fromBuffer(const byte *buffer, int32 size, bool palette) {
-	if (palette) {
-		memcpy((byte *) _palette, buffer, 768);
-		buffer += 768;
-		size -= 768;
-	}
-
-	_size = size;
-
-	delete[] _sprite;
-	_sprite = new byte[_size];
-
-	memcpy(_sprite, buffer, _size);
-
-	return true;
-}
-
-
-PlainSave::PlainSave(Endianness endianness) : _endianness(endianness) {
-}
-
-PlainSave::~PlainSave() {
-}
-
-bool PlainSave::save(int16 dataVar, int32 size, int32 offset, const char *name,
-		const Variables *variables) {
-
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	byte *vars = new byte[size];
-	byte *varSizes = new byte[size];
-
-	if (!variables->copyTo(dataVar, vars, varSizes, size)) {
-		delete[] vars;
-		delete[] varSizes;
-		warning("dataVar (%d) or size (%d) out of range", dataVar, size);
-		return false;
-	}
-
-	bool result = save(0, size, offset, name, vars, varSizes);
-
-	delete[] vars;
-	delete[] varSizes;
-
-	return result;
-}
-
-bool PlainSave::load(int16 dataVar, int32 size, int32 offset, const char *name,
-		Variables *variables) {
-
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	byte *vars = new byte[size];
-	byte *varSizes = new byte[size];
-
-	bool result = load(0, size, offset, name, vars, varSizes);
-
-	if (result && variables) {
-		if (!variables->copyFrom(dataVar, vars, varSizes, size)) {
-			delete[] vars;
-			delete[] varSizes;
-			warning("dataVar (%d) or size (%d) out of range", dataVar, size);
-			return false;
-		}
-	}
-
-	delete[] vars;
-	delete[] varSizes;
-
-	return result;
-}
-
-bool PlainSave::save(int16 dataVar, int32 size, int32 offset, const char *name,
-		const byte *variables, const byte *variableSizes) const {
-
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::OutSaveFile *out = saveMan->openForSaving(name);
-
-	if (!out) {
-		warning("Can't open file \"%s\" for writing", name);
-		return false;
-	}
-
-	bool retVal;
-	retVal = SaveLoad::saveDataEndian(*out, dataVar, size,
-			variables, variableSizes, _endianness);
-
-	out->finalize();
-	if (out->err()) {
-		warning("Can't write to file \"%s\"", name);
-		retVal = false;
-	}
-
-	delete out;
-	return retVal;
-}
-
-bool PlainSave::load(int16 dataVar, int32 size, int32 offset, const char *name,
-		byte *variables, byte *variableSizes) const {
-
-	if ((size <= 0) || (offset != 0)) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in = saveMan->openForLoading(name);
-
-	if (!in) {
-		warning("Can't open file \"%s\" for reading", name);
-		return false;
-	}
-
-	bool retVal = SaveLoad::loadDataEndian(*in, dataVar, size,
-			variables, variableSizes, _endianness);
-	delete in;
-	return retVal;
-}
-
-
-StagedSave::StagedSave(Endianness endianness) : _endianness(endianness) {
-	_mode = kModeNone;
-	_name = 0;
-	_loaded = false;
-}
-
-StagedSave::~StagedSave() {
-	clear();
-}
-
-void StagedSave::addStage(int32 size, bool endianed) {
-	int32 offset = 0;
-
-	if (!_stages.empty())
-		offset = _stages[_stages.size() - 1].offset +
-		         _stages[_stages.size() - 1].size;
-
-	Stage stage(size, offset, endianed);
-	_stages.push_back(stage);
-}
-
-int StagedSave::findStage(int16 dataVar, int32 size, int32 offset) const {
-	for (uint i = 0; i < _stages.size(); i++)
-		if ((_stages[i].size == size) &&
-		    (_stages[i].offset == offset))
-			return i;
-
-	return -1;
-}
-
-bool StagedSave::allSaved() const {
-	for (uint i = 0; i < _stages.size(); i++)
-		if (!_stages[i].bufVar)
-			return false;
-
-	return true;
-}
-
-uint32 StagedSave::getSize() const {
-	uint32 size = 0;
-
-	for (uint i = 0; i < _stages.size(); i++) {
-		if (_stages[i].endianed)
-			size += 2 * _stages[i].size;
-		else
-			size += _stages[i].size;
-	}
-
-	return size;
-}
-
-void StagedSave::clear() {
-	for (uint i = 0; i < _stages.size(); i++) {
-		delete[] _stages[i].bufVar;
-		delete[] _stages[i].bufVarSizes;
-		_stages[i].bufVar = 0;
-		_stages[i].bufVarSizes = 0;
-	}
-
-	delete[] _name;
-	_name = 0;
-
-	_mode = kModeNone;
-	_loaded = false;
-}
-
-void StagedSave::assertMode(Mode mode, const char *name) {
-	if ((_mode != mode) || ((name[0] != '\0') && strcmp(_name, name))) {
-		clear();
-		_mode = mode;
-		_name = new char[strlen(name) + 1];
-		strcpy(_name, name);
-	}
-}
-
-bool StagedSave::save(int16 dataVar, int32 size, int32 offset, const char *name,
-		const Variables *variables) {
-
-	if ((dataVar < 0) || (size <= 0) || (offset < 0)) {
-		warning("Invalid dataVar (%d), size (%d) or offset (%d)", dataVar, size, offset);
-		return false;
-	}
-
-	byte *vars = 0, *varSizes = 0;
-
-	if (variables) {
-		vars = new byte[size];
-		varSizes = new byte[size];
-
-		if (!variables->copyTo(dataVar, vars, varSizes, size)) {
-			delete[] vars;
-			delete[] varSizes;
-			warning("dataVar (%d) or size (%d) out of range", dataVar, size);
-			return false;
-		}
-	}
-
-	bool result = save(0, size, offset, name, vars, varSizes);
-
-	delete[] vars;
-	delete[] varSizes;
-
-	return result;
-}
-
-bool StagedSave::load(int16 dataVar, int32 size, int32 offset, const char *name,
-		Variables *variables) {
-
-	if ((dataVar < 0) || (size <= 0) || (offset < 0)) {
-		warning("Invalid dataVar (%d), size (%d) or offset (%d)", dataVar, size, offset);
-		return false;
-	}
-
-	byte *vars = new byte[size];
-	byte *varSizes = new byte[size];
-
-	bool result = load(0, size, offset, name, vars, varSizes);
-
-	if (result && variables) {
-		if (!variables->copyFrom(dataVar, vars, varSizes, size)) {
-			delete[] vars;
-			delete[] varSizes;
-			warning("dataVar (%d) or size (%d) out of range", dataVar, size);
-			return false;
-		}
-	}
-
-	delete[] vars;
-	delete[] varSizes;
-
-	return result;
-}
-
-bool StagedSave::save(int16 dataVar, int32 size, int32 offset, const char *name,
-		const byte *variables, const byte *variableSizes) {
-
-	if ((dataVar < 0) || (size <= 0) || (offset < 0)) {
-		warning("Invalid dataVar (%d), size (%d) or offset (%d)", dataVar, size, offset);
-		return false;
-	}
-
-	int stage = findStage(dataVar, size, offset);
-	if (stage == -1) {
-		warning("Invalid saving procedure");
-		return false;
-	}
-
-	if (!variables || (_stages[stage].endianed && !variableSizes)) {
-		warning("Missing data");
-		return false;
-	}
-
-	assertMode(kModeSave, name);
-
-	_stages[stage].bufVar = new byte[size];
-	memcpy(_stages[stage].bufVar, variables + dataVar, size);
-
-	if (_stages[stage].endianed) {
-		_stages[stage].bufVarSizes = new byte[size];
-		memcpy(_stages[stage].bufVarSizes, variableSizes + dataVar, size);
-	}
-
-	if (allSaved()) {
-		bool result = write();
-		clear();
-		return result;
-	}
-
-	return true;
-}
-
-bool StagedSave::load(int16 dataVar, int32 size, int32 offset, const char *name,
-		byte *variables, byte *variableSizes) {
-
-	if ((dataVar < 0) || (size <= 0) || (offset < 0)) {
-		warning("Invalid dataVar (%d), size (%d) or offset (%d)", dataVar, size, offset);
-		return false;
-	}
-
-	int stage = findStage(dataVar, size, offset);
-	if (stage == -1) {
-		warning("Invalid loading procedure");
-		return false;
-	}
-
-	assertMode(kModeLoad, name);
-
-	if (!_loaded) {
-		if (!read()) {
-			clear();
-			return false;
-		}
-	}
-
-	if (variables)
-		memcpy(variables + dataVar, _stages[stage].bufVar, size);
-	if (_stages[stage].endianed && variableSizes)
-		memcpy(variableSizes + dataVar, _stages[stage].bufVarSizes, size);
-
-	return true;
-}
-
-bool StagedSave::write() const {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::OutSaveFile *out = saveMan->openForSaving(_name);
-
-	if (!out) {
-		warning("Can't open file \"%s\" for writing", _name);
-		return false;
-	}
-
-	bool result = true;
-	for (uint i = 0; (i < _stages.size()) && result; i++) {
-		if (!_stages[i].endianed) {
-
-			uint32 written = out->write(_stages[i].bufVar, _stages[i].size);
-
-			result = (written == ((uint32) _stages[i].size));
-			if (!result)
-				warning("Can't write data: requested %d, wrote %d", _stages[i].size, written);
-
-		} else
-			result = SaveLoad::saveDataEndian(*out, 0, _stages[i].size,
-					_stages[i].bufVar, _stages[i].bufVarSizes, _endianness);
-	}
-
-	if (result) {
-		out->finalize();
-		if (out->err()) {
-			warning("Can't write to file \"%s\"", _name);
-			result = false;
-		}
-	}
-
-	delete out;
-	return result;
-}
-
-bool StagedSave::read() {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in = saveMan->openForLoading(_name);
-
-	if (!in) {
-		warning("Can't open file \"%s\" for reading", _name);
-		return false;
-	}
-
-	int32 saveSize = getSize();
-	if (in->size() != saveSize) {
-		warning("Wrong size (%d != %d)", in->size(), saveSize);
-		return false;
-	}
-
-	bool result = true;
-	for (uint i = 0; ((i < _stages.size()) && result); i++) {
-		_stages[i].bufVar = new byte[_stages[i].size];
-
-		if (!_stages[i].endianed) {
-
-			uint32 nRead = in->read(_stages[i].bufVar, _stages[i].size);
-
-			result = (nRead == ((uint32) _stages[i].size));
-			if (!result)
-				warning("Can't read data: requested %d, got %d", _stages[i].size, nRead);
-
-		} else {
-			_stages[i].bufVarSizes = new byte[_stages[i].size];
-
-			result = SaveLoad::loadDataEndian(*in, 0, _stages[i].size,
-					_stages[i].bufVar, _stages[i].bufVarSizes, _endianness);
-		}
-	}
-
-	if (result)
-		_loaded = true;
-
-	delete in;
-	return result;
-}
-
-
-PagedBuffer::PagedBuffer(uint32 pageSize) {
-
-	_size = 0;
-	_pageSize = pageSize;
-}
-
-PagedBuffer::~PagedBuffer() {
-	clear();
-}
-
-bool PagedBuffer::empty() const {
-	return _pages.empty();
-}
-
-uint32 PagedBuffer::getSize() const {
-	return _size;
-}
-
-void PagedBuffer::clear() {
-	for (uint i = 0; i < _pages.size(); i++)
-		delete[] _pages[i];
-	_pages.clear();
-	_size = 0;
-}
-
-bool PagedBuffer::write(const byte *buffer, uint32 size, uint32 offset) {
-	grow(size, offset);
-
-	uint page = offset / _pageSize;
-	while (size > 0) {
-		if (!_pages[page])
-			_pages[page] = new byte[_pageSize];
-
-		uint32 pStart = offset % _pageSize;
-		uint32 n = MIN(size, _pageSize - pStart);
-
-		memcpy(_pages[page] + pStart, buffer, n);
-
-		buffer += n;
-		offset += n;
-		size -= n;
-		page++;
-	}
-
-	return true;
-}
-
-bool PagedBuffer::read(byte *buffer, uint32 size, uint32 offset) const {
-	uint page = offset / _pageSize;
-
-	while (size > 0) {
-		if (offset >= _size) {
-			memset(buffer, 0, size);
-			break;
-		}
-
-		uint32 pStart = offset % _pageSize;
-		uint32 n = MIN(MIN(size, _pageSize - pStart), _size - offset);
-
-		if (_pages[page])
-			memcpy(buffer, _pages[page] + pStart, n);
-		else
-			memset(buffer, 0, n);
-
-		buffer += n;
-		offset += n;
-		size -= n;
-		page++;
-	}
-
-	return true;
-}
-
-uint32 PagedBuffer::writeToStream(Common::WriteStream &out) const {
-	for (uint i = 0; i < _pages.size(); i++) {
-		if (!_pages[i]) {
-			for (uint32 j = 0; j < _pageSize; j++)
-				out.writeByte(0);
-		} else
-			out.write(_pages[i], _pageSize);
-	}
-
-	return _size;
-}
-
-uint32 PagedBuffer::readFromStream(Common::ReadStream &in) {
-	clear();
-
-	while (!in.eos()) {
-		byte *buffer = new byte[_pageSize];
-
-		_size += in.read(buffer, _pageSize);
-
-		_pages.push_back(buffer);
-	}
-
-	return _size;
-}
-
-void PagedBuffer::grow(uint32 size, uint32 offset) {
-	uint32 eSize = offset + size;
-
-	while (_size < eSize) {
-		_pages.push_back(0);
-		_size += MIN(_pageSize, eSize - _size);
-	}
-}
-
-
-SaveLoad::SaveLoad(GobEngine *vm, const char *targetName) : _vm(vm) {
-
-	_targetName = new char[strlen(targetName) + 1];
-	strcpy(_targetName, targetName);
-}
-
-SaveLoad::~SaveLoad() {
-	delete[] _targetName;
-}
-
-int32 SaveLoad::getSize(const char *fileName) {
-	int type;
-
-	type = getSaveType(stripPath(fileName));
-	if (type == -1)
-		return -1;
-
-	debugC(3, kDebugSaveLoad, "Requested size of save file \"%s\" (type %d)",
-			fileName, type);
-
-	return getSizeVersioned(type);
-}
-
-bool SaveLoad::load(const char *fileName, int16 dataVar, int32 size, int32 offset) {
-	int type;
-
-	type = getSaveType(stripPath(fileName));
-	if (type == -1)
-		return false;
-
-	debugC(3, kDebugSaveLoad, "Requested loading of save file \"%s\" (type %d) - %d, %d, %d",
-			fileName, type, dataVar, size, offset);
-
-	return loadVersioned(type, dataVar, size, offset);
-}
-
-bool SaveLoad::save(const char *fileName, int16 dataVar, int32 size, int32 offset) {
-	int type;
-
-	type = getSaveType(stripPath(fileName));
-	if (type == -1)
-		return false;
-
-	debugC(3, kDebugSaveLoad, "Requested saving of save file \"%s\" (type %d) - %d, %d, %d",
-			fileName, type, dataVar, size, offset);
-
-	return saveVersioned(type, dataVar, size, offset);
-}
-
-const char *SaveLoad::stripPath(const char *fileName) {
-	const char *backSlash;
-	if ((backSlash = strrchr(fileName, '\\')))
-		return backSlash + 1;
-
-	return fileName;
-}
-
-char *SaveLoad::setCurrentSlot(char *destName, int slot) {
-	char *slotBase = destName + strlen(destName) - 2;
-
-	snprintf(slotBase, 3, "%02d", slot);
-
-	return destName;
-}
-
-void SaveLoad::buildIndex(byte *buffer, char *name, int n, int32 size, int32 offset) {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-
-	for (int i = 0; i < n; i++, buffer += size) {
-		in = saveMan->openForLoading(setCurrentSlot(name, i));
-		if (in) {
-			in->seek(offset);
-			in->read(buffer, size);
-			delete in;
-		} else
-			memset(buffer, 0, size);
-	}
-}
-
-bool SaveLoad::fromEndian(byte *buf, const byte *sizes, uint32 count, Endianness endianness) {
-	bool LE = (endianness == kEndiannessLE);
-
-	while (count-- > 0) {
-		if (*sizes == 3)
-			*((uint32 *) buf) = LE ? READ_LE_UINT32(buf) : READ_BE_UINT32(buf);
-		else if (*sizes == 1)
-			*((uint16 *) buf) = LE ? READ_LE_UINT16(buf) : READ_BE_UINT16(buf);
-		else if (*sizes != 0) {
-			warning("SaveLoad::fromEndian(): Corrupted variables sizes");
-			return false;
-		}
-
-		count -= *sizes;
-		buf += *sizes + 1;
-		sizes += *sizes + 1;
-	}
-
-	return true;
-}
-
-bool SaveLoad::toEndian(byte *buf, const byte *sizes, uint32 count, Endianness endianness) {
-	while (count-- > 0) {
-		if (*sizes == 3) {
-			if (endianness == kEndiannessLE)
-				WRITE_LE_UINT32(buf, *((uint32 *) buf));
-			else
-				WRITE_BE_UINT32(buf, *((uint32 *) buf));
-		} else if (*sizes == 1) {
-			if (endianness == kEndiannessLE)
-				WRITE_LE_UINT16(buf, *((uint16 *) buf));
-			else
-				WRITE_BE_UINT16(buf, *((uint16 *) buf));
-		}
-		else if (*sizes != 0) {
-			warning("SaveLoad::toEndian(): Corrupted variables sizes");
-			return false;
-		}
-
-		count -= *sizes;
-		buf += *sizes + 1;
-		sizes += *sizes + 1;
-	}
-
-	return true;
-}
-
-uint32 SaveLoad::read(Common::ReadStream &in,
-		byte *buf, byte *sizes, uint32 count) {
-	uint32 nRead;
-
-	nRead = in.read(buf, count);
-	if (nRead != count) {
-		warning("Can't read data: requested %d, got %d", count, nRead);
-		return 0;
-	}
-
-	nRead = in.read(sizes, count);
-	if (nRead != count) {
-		warning("Can't read data sizes: requested %d, got %d", count, nRead);
-		return 0;
-	}
-
-	return count;
-}
-
-uint32 SaveLoad::write(Common::WriteStream &out,
-		const byte *buf, const byte *sizes, uint32 count) {
-	uint32 written;
-
-	written = out.write(buf, count);
-	if (written != count) {
-		warning("Can't write data: requested %d, wrote %d", count, written);
-		return 0;
-	}
-
-	written = out.write(sizes, count);
-	if (written != count) {
-		warning("Can't write data: requested %d, wrote %d", count, written);
-		return 0;
-	}
-
-	return count;
-}
-
-bool SaveLoad::loadDataEndian(Common::ReadStream &in,
-		int16 dataVar, uint32 size,
-		byte *variables, byte *variableSizes, Endianness endianness) {
-
-	bool retVal = false;
-
-	byte *varBuf = new byte[size];
-	byte *sizeBuf = new byte[size];
-
-	assert(varBuf && sizeBuf);
-
-	if (read(in, varBuf, sizeBuf, size) == size) {
-		if (fromEndian(varBuf, sizeBuf, size, endianness)) {
-			memcpy(variables + dataVar, varBuf, size);
-			memcpy(variableSizes + dataVar, sizeBuf, size);
-			retVal = true;
-		}
-	}
-
-	delete[] varBuf;
-	delete[] sizeBuf;
-
-	return retVal;
-}
-
-bool SaveLoad::saveDataEndian(Common::WriteStream &out,
-		int16 dataVar, uint32 size,
-		const byte *variables, const byte *variableSizes, Endianness endianness) {
-
-	bool retVal = false;
-
-	byte *varBuf = new byte[size];
-	byte *sizeBuf = new byte[size];
-
-	assert(varBuf && sizeBuf);
-
-	memcpy(varBuf, variables + dataVar, size);
-	memcpy(sizeBuf, variableSizes + dataVar, size);
-
-	if (toEndian(varBuf, sizeBuf, size, endianness))
-		if (write(out, varBuf, sizeBuf, size) == size)
-			retVal = true;
-
-	delete[] varBuf;
-	delete[] sizeBuf;
-
-	return retVal;
-}
-
-SaveLoad::SaveMode SaveLoad::getSaveMode(const char *fileName) { return kSaveModeNone; }
-int SaveLoad::getSaveType(const char *fileName) { return -1; }
-int32 SaveLoad::getSizeVersioned(int type) { return -1; }
-bool SaveLoad::loadVersioned(int type, int16 dataVar, int32 size, int32 offset) { return false; }
-bool SaveLoad::saveVersioned(int type, int16 dataVar, int32 size, int32 offset) { return false; }
-
-} // End of namespace Gob
diff --git a/engines/gob/saveload.h b/engines/gob/saveload.h
deleted file mode 100644
index c14b4f2680..0000000000
--- a/engines/gob/saveload.h
+++ /dev/null
@@ -1,464 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#ifndef GOB_SAVELOAD_H
-#define GOB_SAVELOAD_H
-
-#include "common/array.h"
-#include "common/stream.h"
-
-#include "gob/video.h"
-#include "gob/variables.h"
-
-namespace Gob {
-
-class TempSprite {
-public:
-	TempSprite();
-	~TempSprite();
-
-	bool getProperties(int16 dataVar, int32 size, int32 offset,
-			int &index, bool &palette) const;
-
-	int32 getSize() const;
-
-	bool saveSprite(const SurfaceDesc &surfDesc);
-	bool savePalette(const Video::Color *palette);
-	bool loadSprite(SurfaceDesc &surfDesc);
-	bool loadPalette(Video::Color *palette);
-
-	bool toBuffer(byte *buffer, int32 size, bool palette) const;
-	bool fromBuffer(const byte *buffer, int32 size, bool palette);
-
-private:
-	byte *_sprite;
-	int16 _width;
-	int16 _height;
-	int32 _size;
-	Video::Color _palette[256];
-
-	int getSpriteIndex(int32 size) const;
-	bool getSpritePalette(int32 size) const;
-};
-
-class PlainSave {
-public:
-	PlainSave(Endianness endianness);
-	~PlainSave();
-
-	bool save(int16 dataVar, int32 size, int32 offset, const char *name,
-			const Variables *variables);
-	bool load(int16 dataVar, int32 size, int32 offset, const char *name,
-			Variables *variables);
-
-	bool save(int16 dataVar, int32 size, int32 offset, const char *name,
-			const byte *variables, const byte *variableSizes) const;
-	bool load(int16 dataVar, int32 size, int32 offset, const char *name,
-			byte *variables, byte *variableSizes) const;
-
-private:
-	Endianness _endianness;
-};
-
-class StagedSave {
-public:
-	StagedSave(Endianness endianness);
-	~StagedSave();
-
-	void addStage(int32 size, bool endianed = true);
-
-	bool save(int16 dataVar, int32 size, int32 offset, const char *name,
-			const Variables *variables);
-	bool load(int16 dataVar, int32 size, int32 offset, const char *name,
-			Variables *variables);
-
-	bool save(int16 dataVar, int32 size, int32 offset, const char *name,
-			const byte *variables, const byte *variableSizes);
-	bool load(int16 dataVar, int32 size, int32 offset, const char *name,
-			byte *variables, byte *variableSizes);
-
-private:
-	struct Stage {
-		byte *bufVar;
-		byte *bufVarSizes;
-		int32 size;
-		int32 offset;
-		bool endianed;
-
-		Stage(int32 s = 0, int32 off = 0, bool end = true) :
-			bufVar(0), bufVarSizes(0), size(s), offset(off), endianed(end) {}
-	};
-
-	enum Mode {
-		kModeNone,
-		kModeSave,
-		kModeLoad
-	};
-
-	Endianness _endianness;
-
-	Common::Array<Stage> _stages;
-	enum Mode _mode;
-	char *_name;
-
-	bool _loaded;
-
-	int findStage(int16 dataVar, int32 size, int32 offset) const;
-	bool allSaved() const;
-
-	uint32 getSize() const;
-
-	void clear();
-	void assertMode(Mode mode, const char *name);
-
-	bool write() const;
-	bool read();
-};
-
-class PagedBuffer {
-public:
-	PagedBuffer(uint32 pageSize = 1024);
-	~PagedBuffer();
-
-	bool empty() const;
-	uint32 getSize() const;
-
-	void clear();
-
-	bool write(const byte *buffer, uint32 size, uint32 offset);
-	bool read(byte *buffer, uint32 size, uint32 offset) const;
-
-	uint32 writeToStream(Common::WriteStream &out) const;
-	uint32 readFromStream(Common::ReadStream &in);
-
-private:
-	uint32 _size;
-	uint32 _pageSize;
-	Common::Array<byte *> _pages;
-
-	void grow(uint32 size, uint32 offset);
-};
-
-class SaveLoad {
-public:
-	enum SaveMode {
-		kSaveModeNone,
-		kSaveModeIgnore,
-		kSaveModeExists,
-		kSaveModeSave
-	};
-
-	SaveLoad(GobEngine *vm, const char *targetName);
-	virtual ~SaveLoad();
-
-	virtual SaveMode getSaveMode(const char *fileName);
-
-	int32 getSize(const char *fileName);
-	bool load(const char *fileName, int16 dataVar, int32 size, int32 offset);
-	bool save(const char *fileName, int16 dataVar, int32 size, int32 offset);
-
-	char *setCurrentSlot(char *destName, int slot);
-	void buildIndex(byte *buffer, char *name, int n, int32 size, int32 offset = 0);
-
-	static const char *stripPath(const char *fileName);
-
-	static bool fromEndian(byte *buf, const byte *sizes, uint32 count, Endianness endianness);
-	static bool toEndian(byte *buf, const byte *sizes, uint32 count, Endianness endianness);
-	static uint32 read(Common::ReadStream &in,
-			byte *buf, byte *sizes, uint32 count);
-	static uint32 write(Common::WriteStream &out,
-			const byte *buf, const byte *sizes, uint32 count);
-
-	static bool loadDataEndian(Common::ReadStream &in,
-			int16 dataVar, uint32 size,
-			byte *variables, byte *variableSizes, Endianness endianness);
-	static bool saveDataEndian(Common::WriteStream &out,
-			int16 dataVar, uint32 size,
-			const byte *variables, const byte *variableSizes, Endianness endianness);
-
-protected:
-	GobEngine *_vm;
-
-	char *_targetName;
-
-	virtual int getSaveType(const char *fileName);
-
-	virtual int32 getSizeVersioned(int type);
-	virtual bool loadVersioned(int type, int16 dataVar, int32 size, int32 offset);
-	virtual bool saveVersioned(int type, int16 dataVar, int32 size, int32 offset);
-};
-
-class SaveLoad_v2 : public SaveLoad {
-public:
-	enum SaveType {
-		kSaveGame,
-		kSaveTempSprite,
-		kSaveNotes
-	};
-
-	SaveLoad_v2(GobEngine *vm, const char *targetName);
-	virtual ~SaveLoad_v2();
-
-	virtual SaveMode getSaveMode(const char *fileName);
-
-protected:
-	struct SaveFile {
-		const char *sourceName;
-		char *destName;
-		SaveMode mode;
-		SaveType type;
-	};
-
-	static SaveFile _saveFiles[];
-
-	int32 _varSize;
-
-	TempSprite _tmpSprite;
-	PlainSave *_notes;
-	StagedSave *_save;
-
-	byte _indexBuffer[600];
-	bool _hasIndex;
-
-	virtual int getSaveType(const char *fileName);
-
-	virtual int32 getSizeVersioned(int type);
-	virtual bool loadVersioned(int type, int16 dataVar, int32 size, int32 offset);
-	virtual bool saveVersioned(int type, int16 dataVar, int32 size, int32 offset);
-
-	int getSlot(int32 offset) const;
-	int getSlotRemainder(int32 offset) const;
-
-	int32 getSizeGame(SaveFile &saveFile);
-	int32 getSizeTempSprite(SaveFile &saveFile);
-	int32 getSizeNotes(SaveFile &saveFile);
-
-	bool loadGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadTempSprite(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadNotes(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	bool saveGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveTempSprite(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveNotes(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	void assertInited();
-};
-
-enum SaveType {
-	kSaveNone = -1,
-	kSaveGame,
-	kSaveTempSprite,
-	kSaveNotes,
-	kSaveScreenshot,
-	kSaveIgnore
-};
-
-class SaveLoad_v3 : public SaveLoad {
-public:
-	enum SaveType {
-		kSaveNone,
-		kSaveGame,
-		kSaveTempSprite,
-		kSaveNotes,
-		kSaveScreenshot
-	};
-
-	SaveLoad_v3(GobEngine *vm, const char *targetName,
-			uint32 screenshotSize = 19968,
-			int32 indexOffset = 40, int32 screenshotOffset = 80);
-	virtual ~SaveLoad_v3();
-
-	virtual SaveMode getSaveMode(const char *fileName);
-
-protected:
-	struct SaveFile {
-		const char *sourceName;
-		char *destName;
-		SaveMode mode;
-		SaveType type;
-		int slot;
-	};
-
-	bool _useScreenshots;
-	bool _firstSizeGame;
-
-	uint32 _screenshotSize;
-	int32 _indexOffset;
-	int32 _screenshotOffset;
-
-	static SaveFile _saveFiles[];
-
-	int32 _varSize;
-
-	TempSprite _screenshot;
-	TempSprite _tmpSprite;
-	PlainSave *_notes;
-	StagedSave *_save;
-
-	byte _propBuffer[1000];
-	byte _indexBuffer[1200];
-	bool _hasIndex;
-
-	virtual int getSaveType(const char *fileName);
-
-	virtual int32 getSizeVersioned(int type);
-	virtual bool loadVersioned(int type, int16 dataVar, int32 size, int32 offset);
-	virtual bool saveVersioned(int type, int16 dataVar, int32 size, int32 offset);
-
-	int getSlot(int32 offset) const;
-	int getSlotRemainder(int32 offset) const;
-
-	int32 getSizeGame(SaveFile &saveFile);
-	int32 getSizeTempSprite(SaveFile &saveFile);
-	int32 getSizeNotes(SaveFile &saveFile);
-	int32 getSizeScreenshot(SaveFile &saveFile);
-
-	bool loadGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadTempSprite(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadNotes(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadScreenshot(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	bool saveGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveTempSprite(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveNotes(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveScreenshot(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	void assertInited();
-
-	void buildScreenshotIndex(byte *buffer, char *name, int n);
-};
-
-class SaveLoad_v4 : public SaveLoad {
-public:
-	enum SaveType {
-		kSaveNone,
-		kSaveScreenProps,
-		kSaveGame,
-		kSaveGameScreenProps
-	};
-
-	bool _firstSizeGame;
-
-	SaveLoad_v4(GobEngine *vm, const char *targetName);
-	virtual ~SaveLoad_v4();
-
-	virtual SaveMode getSaveMode(const char *fileName);
-
-protected:
-	struct SaveFile {
-		const char *sourceName;
-		char *destName;
-		SaveMode mode;
-		SaveType type;
-	};
-
-	static SaveFile _saveFiles[];
-
-	int32 _varSize;
-
-	StagedSave *_save;
-
-	byte _propBuffer[1000];
-	byte _indexBuffer[1200];
-	bool _hasIndex;
-
-	byte *_screenProps;
-
-	virtual int getSaveType(const char *fileName);
-
-	virtual int32 getSizeVersioned(int type);
-	virtual bool loadVersioned(int type, int16 dataVar, int32 size, int32 offset);
-	virtual bool saveVersioned(int type, int16 dataVar, int32 size, int32 offset);
-
-	int getSlot(int32 offset) const;
-	int getSlotRemainder(int32 offset) const;
-
-	int32 getSizeScreenProps(SaveFile &saveFile);
-	int32 getSizeGame(SaveFile &saveFile);
-	int32 getSizeGameScreenProps(SaveFile &saveFile);
-
-	bool loadScreenProps(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool loadGameScreenProps(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	bool saveScreenProps(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-	bool saveGameScreenProps(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	void assertInited();
-};
-
-class SaveLoad_v6 : public SaveLoad {
-public:
-	enum SaveType {
-		kSaveNone,
-		kSaveGame,
-		kSaveNoCD
-	};
-
-	SaveLoad_v6(GobEngine *vm, const char *targetName);
-	virtual ~SaveLoad_v6();
-
-	virtual SaveMode getSaveMode(const char *fileName);
-
-protected:
-	struct SaveFile {
-		const char *sourceName;
-		char *destName;
-		SaveMode mode;
-		SaveType type;
-	};
-
-	static SaveFile _saveFiles[];
-
-	int32 _varSize;
-
-	StagedSave *_save;
-
-	byte _indexBuffer[2900];
-
-	virtual int getSaveType(const char *fileName);
-
-	virtual int32 getSizeVersioned(int type);
-	virtual bool loadVersioned(int type, int16 dataVar, int32 size, int32 offset);
-	virtual bool saveVersioned(int type, int16 dataVar, int32 size, int32 offset);
-
-	int getSlot(int32 offset) const;
-	int getSlotRemainder(int32 offset) const;
-
-	int32 getSizeGame(SaveFile &saveFile);
-
-	bool loadGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	bool saveGame(SaveFile &saveFile, int16 dataVar, int32 size, int32 offset);
-
-	void assertInited();
-
-	void refreshIndex();
-};
-
-} // End of namespace Gob
-
-#endif // GOB_SAVELOAD_H
diff --git a/engines/gob/saveload_v2.cpp b/engines/gob/saveload_v2.cpp
deleted file mode 100644
index e58799a6db..0000000000
--- a/engines/gob/saveload_v2.cpp
+++ /dev/null
@@ -1,373 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/endian.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"
-#include "gob/inter.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) {
-
-	_notes = new PlainSave(_vm->getEndianness());
-	_save = new StagedSave(_vm->getEndianness());
-
-	_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];
-
-	sprintf(_saveFiles[0].destName, "%s.s00", targetName);
-	sprintf(_saveFiles[3].destName, "%s.blo", targetName);
-
-	_varSize = 0;
-	_hasIndex = false;
-}
-
-SaveLoad_v2::~SaveLoad_v2() {
-	delete _notes;
-	delete _save;
-
-	delete[] _saveFiles[0].destName;
-	delete[] _saveFiles[3].destName;
-}
-
-SaveLoad::SaveMode SaveLoad_v2::getSaveMode(const char *fileName) {
-	fileName = stripPath(fileName);
-
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return _saveFiles[i].mode;
-
-	return kSaveModeNone;
-}
-
-int SaveLoad_v2::getSaveType(const char *fileName) {
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return i;
-
-	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 -1;
-}
-
-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(setCurrentSlot(saveFile.destName, i));
-		if (in) {
-			delete in;
-			return (i + 1) * _varSize + 600;
-		}
-	}
-
-	return -1;
-}
-
-int32 SaveLoad_v2::getSizeTempSprite(SaveFile &saveFile) {
-	return _tmpSprite.getSize();
-}
-
-int32 SaveLoad_v2::getSizeNotes(SaveFile &saveFile) {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	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;
-	}
-
-	if (offset == 0) {
-		debugC(3, kDebugSaveLoad, "Loading save index");
-
-		if (size != 600) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		SaveLoad::buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar, 600),
-				saveFile.destName, 15, 40);
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Loading from 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;
-		}
-
-		if (!_save->load(dataVar, size, 40, saveFile.destName, _vm->_inter->_variables))
-			return false;
-	}
-
-	return true;
-}
-
-bool SaveLoad_v2::loadTempSprite(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Loading from the temporary sprite");
-
-	int index;
-	bool palette;
-
-	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
-		return false;
-
-	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);
-	}
-
-	if (index == 21) {
-		_vm->_draw->forceBlit();
-		_vm->_video->retrace();
-	}
-
-	return true;
-}
-
-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->_inter->_variables);
-}
-
-bool SaveLoad_v2::saveGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset == 0) {
-		debugC(3, kDebugSaveLoad, "Saving save index");
-
-		if (size != 600) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar, _indexBuffer, 0, 600);
-		_hasIndex = true;
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
-
-		SaveLoad::setCurrentSlot(saveFile.destName, slot);
-
-		if ((slot >= 15) || (slotRem != 0)) {
-			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, slot, slotRem);
-			return false;
-		}
-
-		if (!_hasIndex) {
-			warning("No index written yet");
-			return false;
-		}
-
-		_hasIndex = false;
-
-		byte sizes[40];
-		memset(sizes, 0, 40);
-		if (!_save->save(0, 40, 0, saveFile.destName, _indexBuffer + (slot * 40), sizes))
-			return false;
-
-		if (!_save->save(dataVar, size, 40, saveFile.destName, _vm->_inter->_variables))
-			return false;
-
-	}
-
-	return true;
-}
-
-bool SaveLoad_v2::saveTempSprite(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Saving to the temporary sprite");
-
-	int index;
-	bool palette;
-
-	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
-		return false;
-
-	if (!_tmpSprite.saveSprite(*_vm->_draw->_spritesArray[index]))
-		return false;
-
-	if (palette)
-		if (!_tmpSprite.savePalette(_vm->_global->_pPaletteDesc->vgaPal))
-			return false;
-
-	return true;
-}
-
-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->_inter->_variables);
-	return false;
-}
-
-void SaveLoad_v2::assertInited() {
-	if (_varSize > 0)
-		return;
-
-	_varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
-
-	_save->addStage(40);
-	_save->addStage(_varSize);
-}
-
-} // End of namespace Gob
diff --git a/engines/gob/saveload_v3.cpp b/engines/gob/saveload_v3.cpp
deleted file mode 100644
index 806ac75939..0000000000
--- a/engines/gob/saveload_v3.cpp
+++ /dev/null
@@ -1,616 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/endian.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"
-#include "gob/inter.h"
-
-namespace Gob {
-
-SaveLoad_v3::SaveFile SaveLoad_v3::_saveFiles[] = {
-	{    "cat.inf", 0, kSaveModeSave,   kSaveGame,       -1},
-	{    "ima.inf", 0, kSaveModeSave,   kSaveScreenshot, -1},
-	{  "intro.$$$", 0, kSaveModeSave,   kSaveTempSprite, -1},
-	{   "bloc.inf", 0, kSaveModeSave,   kSaveNotes,      -1},
-	{   "prot",     0, kSaveModeIgnore, kSaveNone,       -1},
-	{ "config",     0, kSaveModeIgnore, kSaveNone,       -1},
-};
-
-SaveLoad_v3::SaveLoad_v3(GobEngine *vm, const char *targetName,
-		uint32 screenshotSize, int32 indexOffset, int32 screenshotOffset) :
-	SaveLoad(vm, targetName) {
-
-	_notes = new PlainSave(_vm->getEndianness());
-	_save = new StagedSave(_vm->getEndianness());
-
-	_screenshotSize = screenshotSize;
-	_indexOffset = indexOffset;
-	_screenshotOffset = screenshotOffset;
-
-	_useScreenshots = false;
-	_firstSizeGame = true;
-
-	_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];
-	_saveFiles[4].destName = 0;
-	_saveFiles[5].destName = 0;
-
-	sprintf(_saveFiles[0].destName, "%s.s00", targetName);
-	sprintf(_saveFiles[3].destName, "%s.blo", targetName);
-
-	_varSize = 0;
-	_hasIndex = false;
-	memset(_propBuffer, 0, 1000);
-}
-
-SaveLoad_v3::~SaveLoad_v3() {
-	delete _notes;
-	delete _save;
-
-	delete[] _saveFiles[0].destName;
-	delete[] _saveFiles[3].destName;
-}
-
-SaveLoad::SaveMode SaveLoad_v3::getSaveMode(const char *fileName) {
-	fileName = stripPath(fileName);
-
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return _saveFiles[i].mode;
-
-	return kSaveModeNone;
-}
-
-int SaveLoad_v3::getSaveType(const char *fileName) {
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return i;
-
-	return -1;
-}
-
-int32 SaveLoad_v3::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]);
-	case kSaveScreenshot:
-		return getSizeScreenshot(_saveFiles[type]);
-	default:
-		break;
-	}
-
-	return -1;
-}
-
-bool SaveLoad_v3::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;
-
-	case kSaveScreenshot:
-		if (loadScreenshot(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While loading a screenshot");
-		break;
-
-	default:
-		break;
-	}
-
-	return false;
-}
-
-bool SaveLoad_v3::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;
-
-	case kSaveScreenshot:
-		if (saveScreenshot(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While saving a screenshot");
-		break;
-
-	default:
-		break;
-	}
-
-	return false;
-}
-
-int SaveLoad_v3::getSlot(int32 offset) const {
-	return ((offset - 1700) / _varSize);
-}
-
-int SaveLoad_v3::getSlotRemainder(int32 offset) const {
-	return ((offset - 1700) % _varSize);
-}
-
-int32 SaveLoad_v3::getSizeGame(SaveFile &saveFile) {
-	if (_firstSizeGame) {
-		_firstSizeGame = false;
-		return -1;
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	int32 size = -1;
-
-	int slot = saveFile.slot;
-	for (int i = 29; i >= 0; i--) {
-		in = saveMan->openForLoading(setCurrentSlot(saveFile.destName, i));
-		if (in) {
-			delete in;
-			size = (i + 1) * _varSize + 1700;
-			break;
-		}
-	}
-	setCurrentSlot(saveFile.destName, slot);
-
-	return size;
-}
-
-int32 SaveLoad_v3::getSizeTempSprite(SaveFile &saveFile) {
-	return _tmpSprite.getSize();
-}
-
-int32 SaveLoad_v3::getSizeNotes(SaveFile &saveFile) {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	int32 size = -1;
-
-	in = saveMan->openForLoading(saveFile.destName);
-	if (in) {
-		size = in->size();
-		delete in;
-	}
-
-	return size;
-}
-
-int32 SaveLoad_v3::getSizeScreenshot(SaveFile &saveFile) {
-	if (!_useScreenshots) {
-		_useScreenshots = true;
-		_save->addStage(_screenshotSize, false);
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	int32 size = -1;
-
-	int slot = saveFile.slot;
-	for (int i = 29; i >= 0; i--) {
-		in = saveMan->openForLoading(setCurrentSlot(saveFile.destName, i));
-		if (in) {
-			delete in;
-			size = (i + 1) * _screenshotSize + _screenshotOffset;
-			break;
-		}
-	}
-	setCurrentSlot(saveFile.destName, slot);
-
-	return size;
-}
-
-bool SaveLoad_v3::loadGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 500) {
-		debugC(3, kDebugSaveLoad, "Loading global properties");
-
-		if ((size + offset) > 500) {
-			warning("Wrong global properties list size (%d, %d)", size, offset);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyFrom(dataVar,
-				_propBuffer + offset, _propBuffer + offset + 500, size);
-
-	} else if (offset == 500) {
-		debugC(3, kDebugSaveLoad, "Loading save index");
-
-		if (size != 1200) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		int slot = saveFile.slot;
-
-		SaveLoad::buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar, 1200),
-				saveFile.destName, 30, 40, 1000);
-
-		setCurrentSlot(saveFile.destName, slot);
-
-	} else {
-		saveFile.slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Loading from slot %d", saveFile.slot);
-
-		SaveLoad::setCurrentSlot(saveFile.destName, saveFile.slot);
-
-		if ((saveFile.slot < 0) || (saveFile.slot >= 30) || (slotRem != 0)) {
-			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, saveFile.slot, slotRem);
-			return false;
-		}
-
-		if (!_save->load(dataVar, size, 540, saveFile.destName, _vm->_inter->_variables))
-			return false;
-	}
-
-	return true;
-}
-
-bool SaveLoad_v3::loadTempSprite(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Loading from the temporary sprite");
-
-	int index;
-	bool palette;
-
-	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
-		return false;
-
-	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);
-	}
-
-	if (index == 21) {
-		_vm->_draw->forceBlit();
-		_vm->_video->retrace();
-	}
-
-	return true;
-}
-
-bool SaveLoad_v3::loadNotes(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(2, kDebugSaveLoad, "Loading the notes");
-
-	return _notes->load(dataVar, size, offset, saveFile.destName, _vm->_inter->_variables);
-}
-
-bool SaveLoad_v3::loadScreenshot(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Loading a screenshot");
-
-	if (!_useScreenshots) {
-		_useScreenshots = true;
-		_save->addStage(_screenshotSize, false);
-	}
-
-	if (offset == _indexOffset) {
-		if (size != 40) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		byte buffer[40];
-		memset(buffer, 0, 40);
-
-		int slot = saveFile.slot;
-		buildScreenshotIndex(buffer, saveFile.destName, 30);
-		setCurrentSlot(saveFile.destName, slot);
-
-		memcpy(_vm->_inter->_variables->getAddressOff8(dataVar, 40), buffer, 40);
-
-	} else {
-		saveFile.slot = (offset - _screenshotOffset) / _screenshotSize;
-		int slotRem = (offset - _screenshotOffset) % _screenshotSize;
-
-		SaveLoad::setCurrentSlot(saveFile.destName, saveFile.slot);
-
-		if ((saveFile.slot < 0) || (saveFile.slot >= 30) || (slotRem != 0)) {
-			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, saveFile.slot, slotRem);
-			return false;
-		}
-
-		byte *buffer = new byte[_screenshotSize];
-
-		if (!_save->load(0, _screenshotSize, _varSize + 540, saveFile.destName, buffer, 0)) {
-			delete[] buffer;
-			return false;
-		}
-
-		int index;
-		bool palette;
-
-		if (!_screenshot.getProperties(dataVar, size, offset, index, palette)) {
-			delete[] buffer;
-			return false;
-		}
-
-		if (!_screenshot.fromBuffer(buffer, _screenshotSize, palette)) {
-			delete[] buffer;
-			return false;
-		}
-
-		if (!_screenshot.loadSprite(*_vm->_draw->_spritesArray[index])) {
-			delete[] buffer;
-			return false;
-		}
-
-		if (palette) {
-			if (!_screenshot.loadPalette(_vm->_global->_pPaletteDesc->vgaPal)) {
-				delete[] buffer;
-				return false;
-			}
-			_vm->_video->setFullPalette(_vm->_global->_pPaletteDesc);
-		}
-
-		delete[] buffer;
-	}
-
-	return true;
-}
-
-bool SaveLoad_v3::saveGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 500) {
-		debugC(3, kDebugSaveLoad, "Loading global properties");
-
-		if ((size + offset) > 500) {
-			warning("Wrong global properties list size (%d, %d)", size, offset);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar,
-				_propBuffer + offset, _propBuffer + offset + 500, size);
-
-	} else if (offset == 500) {
-		debugC(3, kDebugSaveLoad, "Saving save index");
-
-		if (size != 1200) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar, _indexBuffer, 0, size);
-		_hasIndex = true;
-
-	} else {
-		saveFile.slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Saving to slot %d", saveFile.slot);
-
-		SaveLoad::setCurrentSlot(saveFile.destName, saveFile.slot);
-
-		if ((saveFile.slot < 0) || (saveFile.slot >= 30) || (slotRem != 0)) {
-			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, saveFile.slot, slotRem);
-			return false;
-		}
-
-		if (!_hasIndex) {
-			warning("No index written yet");
-			return false;
-		}
-
-		_hasIndex = false;
-
-		if (!_save->save(0, 500, 0, saveFile.destName, _propBuffer, _propBuffer + 500))
-			return false;
-
-		if (!_save->save(0, 40, 500, saveFile.destName, _indexBuffer + (saveFile.slot * 40), 0))
-			return false;
-
-		if (!_save->save(dataVar, size, 540, saveFile.destName, _vm->_inter->_variables))
-			return false;
-
-	}
-
-	return true;
-}
-
-bool SaveLoad_v3::saveTempSprite(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Saving to the temporary sprite");
-
-	int index;
-	bool palette;
-
-	if (!_tmpSprite.getProperties(dataVar, size, offset, index, palette))
-		return false;
-
-	if (!_tmpSprite.saveSprite(*_vm->_draw->_spritesArray[index]))
-		return false;
-
-	if (palette)
-		if (!_tmpSprite.savePalette(_vm->_global->_pPaletteDesc->vgaPal))
-			return false;
-
-	return true;
-}
-
-bool SaveLoad_v3::saveNotes(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(2, kDebugSaveLoad, "Saving the notes");
-
-	return _notes->save(dataVar, size - 160, offset, saveFile.destName, _vm->_inter->_variables);
-	return false;
-}
-
-bool SaveLoad_v3::saveScreenshot(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	debugC(3, kDebugSaveLoad, "Saving a screenshot");
-
-	if (!_useScreenshots) {
-		_useScreenshots = true;
-		_save->addStage(_screenshotSize, false);
-	}
-
-	if (offset >= _screenshotOffset) {
-
-		saveFile.slot = (offset - _screenshotOffset) / _screenshotSize;
-		int slotRem = (offset - _screenshotOffset) % _screenshotSize;
-
-		setCurrentSlot(saveFile.destName, saveFile.slot);
-
-		if ((saveFile.slot < 0) || (saveFile.slot >= 30) || (slotRem != 0)) {
-			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, saveFile.slot, slotRem);
-			return false;
-		}
-
-		int index;
-		bool palette;
-
-		if (!_screenshot.getProperties(dataVar, size, offset, index, palette))
-			return false;
-
-		if (!_screenshot.saveSprite(*_vm->_draw->_spritesArray[index]))
-			return false;
-
-		if (palette)
-			if (!_screenshot.savePalette(_vm->_global->_pPaletteDesc->vgaPal))
-				return false;
-
-
-		byte *buffer = new byte[_screenshotSize];
-
-		if (!_screenshot.toBuffer(buffer, _screenshotSize, palette)) {
-			delete[] buffer;
-			return false;
-		}
-
-		if (!_save->save(0, _screenshotSize, _varSize + 540, saveFile.destName, buffer, 0)) {
-			delete[] buffer;
-			return false;
-		}
-
-		delete[] buffer;
-	}
-
-	return true;
-}
-
-void SaveLoad_v3::assertInited() {
-	if (_varSize > 0)
-		return;
-
-	_varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
-
-	_save->addStage(500);
-	_save->addStage(40, false);
-	_save->addStage(_varSize);
-}
-
-void SaveLoad_v3::buildScreenshotIndex(byte *buffer, char *name, int n) {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-
-	memset(buffer, 0, n);
-	for (int i = 0; i < n; i++) {
-		in = saveMan->openForLoading(setCurrentSlot(name, i));
-		if (in) {
-			delete in;
-			buffer[i] = 1;
-		}
-	}
-}
-
-} // End of namespace Gob
diff --git a/engines/gob/saveload_v4.cpp b/engines/gob/saveload_v4.cpp
deleted file mode 100644
index e7df11f6ad..0000000000
--- a/engines/gob/saveload_v4.cpp
+++ /dev/null
@@ -1,443 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/endian.h"
-
-#include "gob/gob.h"
-#include "gob/saveload.h"
-#include "gob/game.h"
-#include "gob/inter.h"
-
-namespace Gob {
-
-SaveLoad_v4::SaveFile SaveLoad_v4::_saveFiles[] = {
-	{  "save.tmp", 0, kSaveModeSave, kSaveScreenProps     },
-	{   "cat.inf", 0, kSaveModeSave, kSaveGame            },
-	{ "save0.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save1.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save2.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save3.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save4.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save5.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save6.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save7.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save8.tmp", 0, kSaveModeSave, kSaveGameScreenProps },
-	{ "save9.tmp", 0, kSaveModeSave, kSaveGameScreenProps }
-};
-
-SaveLoad_v4::SaveLoad_v4(GobEngine *vm, const char *targetName) :
-	SaveLoad(vm, targetName) {
-
-	_save = new StagedSave(_vm->getEndianness());
-
-	_firstSizeGame = true;
-
-	_saveFiles[0].destName = 0;
-	_saveFiles[1].destName = new char[strlen(targetName) + 5];
-	_saveFiles[2].destName = _saveFiles[1].destName;
-	_saveFiles[3].destName = _saveFiles[1].destName;
-	_saveFiles[4].destName = _saveFiles[1].destName;
-	_saveFiles[5].destName = _saveFiles[1].destName;
-	_saveFiles[6].destName = _saveFiles[1].destName;
-	_saveFiles[7].destName = _saveFiles[1].destName;
-	_saveFiles[8].destName = _saveFiles[1].destName;
-	_saveFiles[9].destName = _saveFiles[1].destName;
-	_saveFiles[10].destName = _saveFiles[1].destName;
-	_saveFiles[11].destName = _saveFiles[1].destName;
-
-	sprintf(_saveFiles[1].destName, "%s.s00", targetName);
-
-	_varSize = 0;
-	_hasIndex = false;
-	memset(_propBuffer, 0, 1000);
-
-	_screenProps = new byte[512000];
-	memset(_screenProps, 0, 512000);
-}
-
-SaveLoad_v4::~SaveLoad_v4() {
-	delete _save;
-
-	delete[] _screenProps;
-	delete[] _saveFiles[1].destName;
-}
-
-SaveLoad::SaveMode SaveLoad_v4::getSaveMode(const char *fileName) {
-	fileName = stripPath(fileName);
-
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return _saveFiles[i].mode;
-
-	return kSaveModeNone;
-}
-
-int SaveLoad_v4::getSaveType(const char *fileName) {
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return i;
-
-	return -1;
-}
-
-int32 SaveLoad_v4::getSizeVersioned(int type) {
-	assertInited();
-
-	switch (_saveFiles[type].type) {
-	case kSaveScreenProps:
-		return getSizeScreenProps(_saveFiles[type]);
-	case kSaveGame:
-		return getSizeGame(_saveFiles[type]);
-	case kSaveGameScreenProps:
-		return getSizeGameScreenProps(_saveFiles[type]);
-	default:
-		break;
-	}
-
-	return -1;
-}
-
-bool SaveLoad_v4::loadVersioned(int type, int16 dataVar, int32 size, int32 offset) {
-	assertInited();
-
-	switch (_saveFiles[type].type) {
-	case kSaveScreenProps:
-		if (loadScreenProps(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While loading screen properties");
-		break;
-
-	case kSaveGame:
-		if (loadGame(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While loading from slot %d", getSlot(offset));
-		break;
-
-	case kSaveGameScreenProps:
-		if (loadGameScreenProps(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While loading screen properties from slot %d", getSlot(offset));
-		break;
-
-	default:
-		break;
-	}
-
-	return false;
-}
-
-bool SaveLoad_v4::saveVersioned(int type, int16 dataVar, int32 size, int32 offset) {
-	assertInited();
-
-	switch (_saveFiles[type].type) {
-	case kSaveScreenProps:
-		if (saveScreenProps(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While saving screen properties");
-		break;
-
-	case kSaveGame:
-		if (saveGame(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While saving to slot %d", getSlot(offset));
-		break;
-
-	case kSaveGameScreenProps:
-		if (saveGameScreenProps(_saveFiles[type], dataVar, size, offset))
-			return true;
-
-		warning("While saving screen properties to slot %d", getSlot(offset));
-		break;
-
-	default:
-		break;
-	}
-
-	return false;
-}
-
-int SaveLoad_v4::getSlot(int32 offset) const {
-	return ((offset - 1700) / _varSize);
-}
-
-int SaveLoad_v4::getSlotRemainder(int32 offset) const {
-	return ((offset - 1700) % _varSize);
-}
-
-int32 SaveLoad_v4::getSizeScreenProps(SaveFile &saveFile) {
-	return 256000;
-}
-
-int32 SaveLoad_v4::getSizeGame(SaveFile &saveFile) {
-	if (_firstSizeGame) {
-		_firstSizeGame = false;
-		return -1;
-	}
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-	int32 size = -1;
-
-	for (int i = 29; i >= 0; i--) {
-		in = saveMan->openForLoading(setCurrentSlot(saveFile.destName, i));
-		if (in) {
-			delete in;
-			size = (i + 1) * _varSize + 1700;
-			break;
-		}
-	}
-
-	return size;
-}
-
-int32 SaveLoad_v4::getSizeGameScreenProps(SaveFile &saveFile) {
-	return -1;
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-
-	setCurrentSlot(saveFile.destName, saveFile.sourceName[4] - '0');
-	in = saveMan->openForLoading(saveFile.destName);
-
-	if (!in)
-		return -1;
-
-	int32 size = in->size();
-
-	delete in;
-
-	return size;
-}
-
-bool SaveLoad_v4::loadScreenProps(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	// Using a sprite as a buffer
-	if (size <= 0)
-		return true;
-
-	if ((offset < 0) || (size + offset) > 256000) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	debugC(3, kDebugSaveLoad, "Loading screen properties (%d, %d, %d)",
-			dataVar, size, offset);
-
-	_vm->_inter->_variables->copyFrom(dataVar,
-			_screenProps + offset, _screenProps + 256000 + offset, size);
-
-	return true;
-}
-
-bool SaveLoad_v4::loadGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 500) {
-		debugC(3, kDebugSaveLoad, "Loading global properties");
-
-		if ((size + offset) > 500) {
-			warning("Wrong global properties list size (%d, %d)", size, offset);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyFrom(dataVar,
-				_propBuffer + offset, _propBuffer + offset + 500, size);
-
-	} else if (offset == 500) {
-		debugC(3, kDebugSaveLoad, "Loading save index");
-
-		if (size != 1200) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		SaveLoad::buildIndex(_vm->_inter->_variables->getAddressOff8(dataVar, 1200),
-				saveFile.destName, 30, 40, 1000);
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
-
-		SaveLoad::setCurrentSlot(saveFile.destName, slot);
-
-		if ((slot < 0) || (slot >= 30) || (slotRem != 0)) {
-			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, slot, slotRem);
-			return false;
-		}
-
-		if (!_save->load(dataVar, size, 540, saveFile.destName, _vm->_inter->_variables))
-			return false;
-	}
-
-	return true;
-}
-
-bool SaveLoad_v4::loadGameScreenProps(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size != -5) {
-		warning("Invalid loading procedure (%d, %d, %d)", dataVar, size, offset);
-		return false;
-	}
-
-	setCurrentSlot(saveFile.destName, saveFile.sourceName[4] - '0');
-
-	if (!_save->load(0, 256000, _varSize + 540, saveFile.destName,
-	                _screenProps, _screenProps + 256000))
-		return false;
-
-	return true;
-}
-
-bool SaveLoad_v4::saveScreenProps(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	// Using a sprite as a buffer
-	if (size <= 0)
-		return true;
-
-	if ((offset < 0) || (size + offset) > 256000) {
-		warning("Invalid size (%d) or offset (%d)", size, offset);
-		return false;
-	}
-
-	debugC(3, kDebugSaveLoad, "Saving screen properties (%d, %d, %d)",
-			dataVar, size, offset);
-
-	_vm->_inter->_variables->copyTo(dataVar,
-			_screenProps + offset, _screenProps + 256000 + offset, size);
-
-	return true;
-}
-
-bool SaveLoad_v4::saveGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 500) {
-		debugC(3, kDebugSaveLoad, "Loading global properties");
-
-		if ((size + offset) > 500) {
-			warning("Wrong global properties list size (%d, %d)", size, offset);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar,
-				_propBuffer + offset, _propBuffer + offset + 500, size);
-
-	} else if (offset == 500) {
-		debugC(3, kDebugSaveLoad, "Saving save index");
-
-		if (size != 1200) {
-			warning("Requested index has wrong size (%d)", size);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar, _indexBuffer, 0, size);
-		_hasIndex = true;
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
-
-		SaveLoad::setCurrentSlot(saveFile.destName, slot);
-
-		if ((slot < 0) || (slot >= 30) || (slotRem != 0)) {
-			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, slot, slotRem);
-			return false;
-		}
-
-		if (!_hasIndex) {
-			warning("No index written yet");
-			return false;
-		}
-
-		_hasIndex = false;
-
-		if (!_save->save(0, 500, 0, saveFile.destName, _propBuffer, _propBuffer + 500))
-			return false;
-
-		if (!_save->save(0, 40, 500, saveFile.destName, _indexBuffer + (slot * 40), 0))
-			return false;
-
-		if (!_save->save(dataVar, size, 540, saveFile.destName, _vm->_inter->_variables))
-			return false;
-
-	}
-
-	return true;
-}
-
-bool SaveLoad_v4::saveGameScreenProps(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size != -5) {
-		warning("Invalid saving procedure (%d, %d, %d)", dataVar, size, offset);
-		return false;
-	}
-
-	setCurrentSlot(saveFile.destName, saveFile.sourceName[4] - '0');
-
-	if (!_save->save(0, 256000, _varSize + 540, saveFile.destName,
-	                _screenProps, _screenProps + 256000))
-		return false;
-
-	return true;
-}
-
-void SaveLoad_v4::assertInited() {
-	if (_varSize > 0)
-		return;
-
-	_varSize = READ_LE_UINT32(_vm->_game->_totFileData + 0x2C) * 4;
-
-	_save->addStage(500);
-	_save->addStage(40, false);
-	_save->addStage(_varSize);
-	_save->addStage(256000);
-}
-
-} // End of namespace Gob
diff --git a/engines/gob/saveload_v6.cpp b/engines/gob/saveload_v6.cpp
deleted file mode 100644
index f0de4d934a..0000000000
--- a/engines/gob/saveload_v6.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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 2
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/endian.h"
-
-#include "gob/gob.h"
-#include "gob/saveload.h"
-#include "gob/game.h"
-#include "gob/inter.h"
-
-namespace Gob {
-
-SaveLoad_v6::SaveFile SaveLoad_v6::_saveFiles[] = {
-	{  "cat.inf", 0, kSaveModeSave,   kSaveGame},
-	{  "mdo.def", 0, kSaveModeExists, kSaveNone},
-	{"no_cd.txt", 0, kSaveModeExists, kSaveNoCD},
-};
-
-SaveLoad_v6::SaveLoad_v6(GobEngine *vm, const char *targetName) :
-	SaveLoad(vm, targetName) {
-
-	_save = new StagedSave(_vm->getEndianness());
-
-	_saveFiles[0].destName = new char[strlen(targetName) + 5];
-	_saveFiles[1].destName = 0;
-	_saveFiles[2].destName = 0;
-
-	sprintf(_saveFiles[0].destName, "%s.s00", targetName);
-
-	_varSize = 0;
-}
-
-SaveLoad_v6::~SaveLoad_v6() {
-	delete _save;
-
-	delete[] _saveFiles[0].destName;
-}
-
-SaveLoad::SaveMode SaveLoad_v6::getSaveMode(const char *fileName) {
-	fileName = stripPath(fileName);
-
-	int i;
-	for (i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			break;
-
-	if (i >= ARRAYSIZE(_saveFiles))
-		return kSaveModeNone;
-
-	if (_saveFiles[i].type != kSaveNoCD)
-		return _saveFiles[i].mode;
-
-	if (_vm->_game->_noCd)
-		return kSaveModeExists;
-	else
-		return kSaveModeNone;
-}
-
-int SaveLoad_v6::getSaveType(const char *fileName) {
-	for (int i = 0; i < ARRAYSIZE(_saveFiles); i++)
-		if (!scumm_stricmp(fileName, _saveFiles[i].sourceName))
-			return i;
-
-	return -1;
-}
-
-int32 SaveLoad_v6::getSizeVersioned(int type) {
-	assertInited();
-
-	switch (_saveFiles[type].type) {
-	case kSaveGame:
-		return getSizeGame(_saveFiles[type]);
-	default:
-		return -1;
-	}
-
-	return -1;
-}
-
-bool SaveLoad_v6::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;
-
-	default:
-		return false;
-	}
-
-	return false;
-}
-
-bool SaveLoad_v6::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;
-
-	default:
-		return false;
-	}
-
-	return false;
-}
-
-int SaveLoad_v6::getSlot(int32 offset) const {
-	return ((offset - 2900) / _varSize);
-}
-
-int SaveLoad_v6::getSlotRemainder(int32 offset) const {
-	return ((offset - 2900) % _varSize);
-}
-
-int32 SaveLoad_v6::getSizeGame(SaveFile &saveFile) {
-	refreshIndex();
-
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-
-	for (int i = 60; i >= 0; i--) {
-		in = saveMan->openForLoading(setCurrentSlot(saveFile.destName, i));
-		if (in) {
-			delete in;
-			return (i + 1) * _varSize + 2900;
-		}
-	}
-
-	return -1;
-}
-
-bool SaveLoad_v6::loadGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 2900) {
-		debugC(3, kDebugSaveLoad, "Saving save index");
-
-		if ((offset + size) > 2900) {
-			warning("Wrong index size (%d, %d)", size, offset);
-			return false;
-		}
-
-		refreshIndex();
-
-		byte *sizes = new byte[size];
-		memset(sizes, 0, size);
-
-		_vm->_inter->_variables->copyFrom(dataVar, _indexBuffer + offset, sizes, size);
-
-		delete[] sizes;
-
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Loading from slot %d", slot);
-
-		if ((slot >= 60) || (slotRem != 0)) {
-			warning("Invalid loading procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, slot, slotRem);
-			return false;
-		}
-
-		refreshIndex();
-		SaveLoad::setCurrentSlot(saveFile.destName, slot);
-
-		if (!_save->load(dataVar, size, 40, saveFile.destName, _vm->_inter->_variables))
-			return false;
-
-		refreshIndex();
-	}
-
-	return true;
-}
-
-bool SaveLoad_v6::saveGame(SaveFile &saveFile,
-		int16 dataVar, int32 size, int32 offset) {
-
-	if (size == 0) {
-		dataVar = 0;
-		size = _varSize;
-	}
-
-	if (offset < 2900) {
-		debugC(3, kDebugSaveLoad, "Saving save index");
-
-		if ((offset + size) > 2900) {
-			warning("Wrong index size (%d, %d)", size, offset);
-			return false;
-		}
-
-		_vm->_inter->_variables->copyTo(dataVar, _indexBuffer + offset, 0, size);
-
-	} else {
-		int slot = getSlot(offset);
-		int slotRem = getSlotRemainder(offset);
-
-		debugC(2, kDebugSaveLoad, "Saving to slot %d", slot);
-
-		if ((slot >= 60) || (slotRem != 0)) {
-			warning("Invalid saving procedure (%d, %d, %d, %d, %d)",
-					dataVar, size, offset, slot, slotRem);
-			return false;
-		}
-
-		SaveLoad::setCurrentSlot(saveFile.destName, slot);
-
-		byte sizes[40];
-		memset(sizes, 0, 40);
-		if (!_save->save(0, 40, 0, saveFile.destName, _indexBuffer + 500 + (slot * 40), sizes))
-			return false;
-
-		if (!_save->save(dataVar, size, 40, saveFile.destName, _vm->_inter->_variables))
-			return false;
-
-		refreshIndex();
-	}
-
-	return true;
-}
-
-void SaveLoad_v6::assertInited() {
-	if (_varSize > 0)
-		return;
-
-	_varSize = _vm->_inter->_variables->getSize();
-
-	_save->addStage(40);
-	_save->addStage(_varSize);
-}
-
-void SaveLoad_v6::refreshIndex() {
-	Common::SaveFileManager *saveMan = g_system->getSavefileManager();
-	Common::InSaveFile *in;
-
-	int32 max = -1;
-	byte *names = _indexBuffer + 500;
-	for (int i = 0; i < 60; i++, names += 40) {
-		in = saveMan->openForLoading(setCurrentSlot(_saveFiles[0].destName, i));
-		if (in) {
-			max = i;
-			in->read(names, 40);
-			delete in;
-		} else
-			memset(names, 0, 40);
-	}
-
-	memset(_indexBuffer + 40, 0xFF, 40);          // Joker
-	_indexBuffer[159] = 0x03;                     // # of joker unused
-	WRITE_LE_UINT32(_indexBuffer + 160, max + 1); // # of saves
-}
-
-} // End of namespace Gob
diff --git a/engines/gob/variables.cpp b/engines/gob/variables.cpp
index 6929045b20..1183ec21ae 100644
--- a/engines/gob/variables.cpp
+++ b/engines/gob/variables.cpp
@@ -35,14 +35,12 @@ Variables::Variables(uint32 size) {
 	_size = size;
 
 	_vars = new byte[_size];
-	_sizes = new byte[_size];
 
 	clear();
 }
 
 Variables::~Variables() {
 	delete[] _vars;
-	delete[] _sizes;
 }
 
 uint32 Variables::getSize() const {
@@ -51,39 +49,6 @@ uint32 Variables::getSize() const {
 
 void Variables::clear() {
 	memset(_vars, 0, _size);
-
-	// All variables are 32 bit wide per default
-	memset(_sizes, 0, _size);
-	for (uint32 i = 0; i < _size; i += 4)
-		_sizes[i] = kSize32;
-}
-
-void Variables::clearSize(uint32 offset) {
-	uint32 inVar = offset % 4;
-	uint32 varOff = (offset >> 2) << 2;
-
-	// Clearing out the old size
-	for (uint32 i = 0; i < 4; i++) {
-		if (_sizes[varOff + i] == kSize32)
-			_sizes[varOff + i] = kSize8;
-		else if ((inVar == (i + 1)) && (_sizes[varOff + i] == kSize16))
-			_sizes[varOff + i] = kSize8;
-	}
-}
-
-void Variables::writeSize(uint32 offset, byte n) {
-	clearSize(offset);
-
-	_sizes[offset] = n;
-	// Setting following bytes of size to 8 bit, for easy clearing out afterwards
-	for (; n > 0; n--)
-		_sizes[offset + n] = kSize8;
-}
-
-void Variables::writeSizeString(uint32 offset, uint32 length) {
-	clearSize(offset);
-
-	memset(_sizes + offset, kSize8, length);
 }
 
 void Variables::writeVar8(uint32 var, uint8 value) {
@@ -104,22 +69,18 @@ void Variables::writeVarString(uint32 var, const char *value) {
 
 void Variables::writeOff8(uint32 offset, uint8 value) {
 	write8(_vars + offset, value);
-	writeSize(offset, kSize8);
 }
 
 void Variables::writeOff16(uint32 offset, uint16 value) {
 	write16(_vars + offset, value);
-	writeSize(offset, kSize16);
 }
 
 void Variables::writeOff32(uint32 offset, uint32 value) {
 	write32(_vars + offset, value);
-	writeSize(offset, kSize32);
 }
 
 void Variables::writeOffString(uint32 offset, const char *value) {
 	strcpy((char *) (_vars + offset), value);
-	writeSizeString(offset, strlen(value));
 }
 
 uint8 Variables::readVar8(uint32 var) const {
@@ -158,42 +119,39 @@ const uint8 *Variables::getAddressVar8(uint32 var) const {
 	return getAddressOff8(var * 4);
 }
 
-uint8 *Variables::getAddressVar8(uint32 var, uint32 n) {
-	return getAddressOff8(var * 4, n);
+uint8 *Variables::getAddressVar8(uint32 var) {
+	return getAddressOff8(var * 4);
 }
 
 const uint16 *Variables::getAddressVar16(uint32 var) const {
 	return getAddressOff16(var * 4);
 }
 
-uint16 *Variables::getAddressVar16(uint32 var, uint32 n) {
-	return getAddressOff16(var * 4, n);
+uint16 *Variables::getAddressVar16(uint32 var) {
+	return getAddressOff16(var * 4);
 }
 
 const uint32 *Variables::getAddressVar32(uint32 var) const {
 	return getAddressOff32(var * 4);
 }
 
-uint32 *Variables::getAddressVar32(uint32 var, uint32 n) {
-	return getAddressOff32(var * 4, n);
+uint32 *Variables::getAddressVar32(uint32 var) {
+	return getAddressOff32(var * 4);
 }
 
 const char *Variables::getAddressVarString(uint32 var) const {
 	return getAddressOffString(var * 4);
 }
 
-char *Variables::getAddressVarString(uint32 var, uint32 n) {
-	return getAddressOffString(var * 4, n);
+char *Variables::getAddressVarString(uint32 var) {
+	return getAddressOffString(var * 4);
 }
 
 const uint8 *Variables::getAddressOff8(uint32 offset) const {
 	return ((const uint8 *) (_vars + offset));
 }
 
-uint8 *Variables::getAddressOff8(uint32 offset, uint32 n) {
-	for (uint32 i = 0; i < n; i++)
-		writeSize(offset + i, kSize8);
-
+uint8 *Variables::getAddressOff8(uint32 offset) {
 	return ((uint8 *) (_vars + offset));
 }
 
@@ -201,10 +159,7 @@ const uint16 *Variables::getAddressOff16(uint32 offset) const {
 	return ((const uint16 *) (_vars + offset));
 }
 
-uint16 *Variables::getAddressOff16(uint32 offset, uint32 n) {
-	for (uint32 i = 0; i < n; i++)
-		writeSize(offset + i * 2, kSize16);
-
+uint16 *Variables::getAddressOff16(uint32 offset) {
 	return ((uint16 *) (_vars + offset));
 }
 
@@ -212,10 +167,7 @@ const uint32 *Variables::getAddressOff32(uint32 offset) const {
 	return ((const uint32 *) (_vars + offset));
 }
 
-uint32 *Variables::getAddressOff32(uint32 offset, uint32 n) {
-	for (uint32 i = 0; i < n; i++)
-		writeSize(offset + i * 4, kSize32);
-
+uint32 *Variables::getAddressOff32(uint32 offset) {
 	return ((uint32 *) (_vars + offset));
 }
 
@@ -223,30 +175,25 @@ const char *Variables::getAddressOffString(uint32 offset) const {
 	return ((const char *) (_vars + offset));
 }
 
-char *Variables::getAddressOffString(uint32 offset, uint32 n) {
-	writeSizeString(offset, (n == 0xFFFFFFFF) ? strlen((char *) (_vars + offset)) : n);
-
+char *Variables::getAddressOffString(uint32 offset) {
 	return ((char *) (_vars + offset));
 }
 
-bool Variables::copyTo(uint32 offset, byte *variables, byte *sizes, uint32 n) const {
+bool Variables::copyTo(uint32 offset, byte *variables, uint32 n) const {
 	if ((offset + n) > _size)
 		return false;
 
 	if (variables)
 		memcpy(variables, _vars + offset, n);
-	if (sizes)
-		memcpy(sizes, _sizes + offset, n);
 
 	return true;
 }
 
-bool Variables::copyFrom(uint32 offset, const byte *variables, const byte *sizes, uint32 n) {
-	if (((offset + n) > _size) || !variables || !sizes)
+bool Variables::copyFrom(uint32 offset, const byte *variables, uint32 n) {
+	if (((offset + n) > _size) || !variables)
 		return false;
 
 	memcpy(_vars + offset, variables, n);
-	memcpy(_sizes + offset, sizes, n);
 
 	return true;
 }
diff --git a/engines/gob/variables.h b/engines/gob/variables.h
index c2f2285b80..84a4772baa 100644
--- a/engines/gob/variables.h
+++ b/engines/gob/variables.h
@@ -67,32 +67,32 @@ public:
 
 
 	const uint8 *getAddressVar8(uint32 var) const;
-	uint8 *getAddressVar8(uint32 var, uint32 n = 1);
+	uint8 *getAddressVar8(uint32 var);
 
 	const uint16 *getAddressVar16(uint32 var) const;
-	uint16 *getAddressVar16(uint32 var, uint32 n = 1);
+	uint16 *getAddressVar16(uint32 var);
 
 	const uint32 *getAddressVar32(uint32 var) const;
-	uint32 *getAddressVar32(uint32 var, uint32 n = 1);
+	uint32 *getAddressVar32(uint32 var);
 
 	const char *getAddressVarString(uint32 var) const;
-	char *getAddressVarString(uint32 var, uint32 n = 0xFFFFFFFF);
+	char *getAddressVarString(uint32 var);
 
 	const uint8 *getAddressOff8(uint32 offset) const;
-	uint8 *getAddressOff8(uint32 offset, uint32 n = 1);
+	uint8 *getAddressOff8(uint32 offset);
 
 	const uint16 *getAddressOff16(uint32 offset) const;
-	uint16 *getAddressOff16(uint32 offset, uint32 n = 1);
+	uint16 *getAddressOff16(uint32 offset);
 
 	const uint32 *getAddressOff32(uint32 offset) const;
-	uint32 *getAddressOff32(uint32 offset, uint32 n = 1);
+	uint32 *getAddressOff32(uint32 offset);
 
 	const char *getAddressOffString(uint32 offset) const;
-	char *getAddressOffString(uint32 offset, uint32 n = 0xFFFFFFFF);
+	char *getAddressOffString(uint32 offset);
 
 
-	bool copyTo(uint32 offset, byte *variables, byte *sizes, uint32 n) const;
-	bool copyFrom(uint32 offset, const byte *variables, const byte *sizes, uint32 n);
+	bool copyTo(uint32 offset, byte *variables, uint32 n) const;
+	bool copyFrom(uint32 offset, const byte *variables, uint32 n);
 
 protected:
 	virtual void write8(byte *buf, uint8 data) const = 0;
@@ -104,20 +104,10 @@ protected:
 	virtual uint32 read32(const byte *buf) const = 0;
 
 private:
-	// Basically the number of additional bytes occupied
-	static const byte kSize8 = 0;
-	static const byte kSize16 = 1;
-	static const byte kSize32 = 3;
-
 	uint32 _size;
-
 	byte *_vars;
-	byte *_sizes;
 
-	void clear();
-	void clearSize(uint32 offset);
-	void writeSize(uint32 offset, byte n);
-	void writeSizeString(uint32 offset, uint32 length);
+  void clear();
 };
 
 class VariablesLE : public Variables {
@@ -151,23 +141,23 @@ protected:
 };
 
 class VariableReference {
-	public:
-		VariableReference();
-		VariableReference(Variables &vars, uint32 offset,
-				Variables::Type type = Variables::kVariableType32);
-		~VariableReference();
-
-		void set(Variables &vars, uint32 offset, Variables::Type type = Variables::kVariableType32);
-
-		VariableReference &operator=(uint32 value);
-		VariableReference &operator+=(uint32 value);
-		VariableReference &operator*=(uint32 value);
-		operator uint32();
-
-	private:
-		Variables *_vars;
-		uint32 _offset;
-		Variables::Type _type;
+public:
+	VariableReference();
+	VariableReference(Variables &vars, uint32 offset,
+			Variables::Type type = Variables::kVariableType32);
+	~VariableReference();
+
+	void set(Variables &vars, uint32 offset, Variables::Type type = Variables::kVariableType32);
+
+	VariableReference &operator=(uint32 value);
+	VariableReference &operator+=(uint32 value);
+	VariableReference &operator*=(uint32 value);
+	operator uint32();
+
+private:
+	Variables *_vars;
+	uint32 _offset;
+	Variables::Type _type;
 };
 
 } // End of namespace Gob