Merge branch 'master' into phantom

7 files changed, 727 insertions, 427 deletions

diff --git a/engines/zvision/core/menu.h b/engines/zvision/core/clock.cpp
index 3ab6d4c2ec..1425d550b7 100644
--- a/engines/zvision/core/menu.h
+++ b/engines/zvision/core/clock.cpp
@@ -20,9 +20,49 @@
  *
  */
 
-#ifndef ZVISION_MENU_H
-#define ZVISION_MENU_H
+#include "common/scummsys.h"
 
-// TODO: Implement MenuHandler
+#include "zvision/core/clock.h"
 
-#endif
+#include "common/system.h"
+
+namespace ZVision {
+
+Clock::Clock(OSystem *system)
+	: _system(system),
+	  _lastTime(0),
+	  _deltaTime(0),
+	  _pausedTime(0),
+	  _paused(false) {
+}
+
+void Clock::update() {
+	uint32 currentTime = _system->getMillis();
+
+	_deltaTime = (currentTime - _lastTime);
+	if (_paused) {
+		_deltaTime -= (currentTime - _pausedTime);
+	}
+
+	if (_deltaTime < 0) {
+		_deltaTime = 0;
+	}
+
+	_lastTime = currentTime;
+}
+
+void Clock::start() {
+	if (_paused) {
+		_lastTime = _system->getMillis();
+		_paused = false;
+	}
+}
+
+void Clock::stop() {
+	if (!_paused) {
+		_pausedTime = _system->getMillis();
+		_paused = true;
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/core/clock.h b/engines/zvision/core/clock.h
new file mode 100644
index 0000000000..cbf52be560
--- /dev/null
+++ b/engines/zvision/core/clock.h
@@ -0,0 +1,84 @@
+/* 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.
+ *
+ */
+
+#ifndef ZVISION_CLOCK_H
+#define ZVISION_CLOCK_H
+
+#include "common/types.h"
+
+class OSystem;
+
+namespace ZVision {
+
+/* Class for handling frame to frame deltaTime while keeping track of time pauses/un-pauses */
+class Clock {
+public:
+	Clock(OSystem *system);
+
+private:
+	OSystem *_system;
+	uint32 _lastTime;
+	int32 _deltaTime;
+	uint32 _pausedTime;
+	bool _paused;
+
+public:
+	/**
+	 * Updates _deltaTime with the difference between the current time and
+	 * when the last update() was called.
+	 */
+	void update();
+
+	/**
+	 * Get the delta time since the last frame. (The time between update() calls)
+	 *
+	 * @return    Delta time since the last frame (in milliseconds)
+	 */
+	uint32 getDeltaTime() const {
+		return _deltaTime;
+	}
+
+	/**
+	 * Get the time from the program starting to the last update() call
+	 *
+	 * @return Time from program start to last update() call (in milliseconds)
+	 */
+	uint32 getLastMeasuredTime() {
+		return _lastTime;
+	}
+
+	/**
+	 * Pause the clock. Any future delta times will take this pause into account.
+	 * Has no effect if the clock is already paused.
+	 */
+	void start();
+
+	/**
+	 * Un-pause the clock.
+	 * Has no effect if the clock is already un-paused.
+	 */
+	void stop();
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/core/console.cpp b/engines/zvision/core/console.cpp
index e610f34474..f5cacb582c 100644
--- a/engines/zvision/core/console.cpp
+++ b/engines/zvision/core/console.cpp
@@ -1,24 +1,24 @@
 /* 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.
- *
- */
+*
+* 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.
+*
+*/
 
 #include "common/scummsys.h"
 
@@ -27,11 +27,10 @@
 #include "zvision/zvision.h"
 #include "zvision/scripting/script_manager.h"
 #include "zvision/graphics/render_manager.h"
-#include "zvision/strings/string_manager.h"
+#include "zvision/text/string_manager.h"
 #include "zvision/video/zork_avi_decoder.h"
 #include "zvision/sound/zork_raw.h"
-#include "zvision/utility/utility.h"
-#include "zvision/cursors/cursor.h"
+#include "zvision/graphics/cursors/cursor.h"
 
 #include "common/system.h"
 #include "common/file.h"
@@ -41,11 +40,9 @@
 
 #include "audio/mixer.h"
 
-
 namespace ZVision {
 
 Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
-	registerCmd("loadimage", WRAP_METHOD(Console, cmdLoadImage));
 	registerCmd("loadvideo", WRAP_METHOD(Console, cmdLoadVideo));
 	registerCmd("loadsound", WRAP_METHOD(Console, cmdLoadSound));
 	registerCmd("raw2wav", WRAP_METHOD(Console, cmdRawToWav));
@@ -53,26 +50,17 @@ Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
 	registerCmd("generaterendertable", WRAP_METHOD(Console, cmdGenerateRenderTable));
 	registerCmd("setpanoramafov", WRAP_METHOD(Console, cmdSetPanoramaFoV));
 	registerCmd("setpanoramascale", WRAP_METHOD(Console, cmdSetPanoramaScale));
-	registerCmd("changelocation", WRAP_METHOD(Console, cmdChangeLocation));
+	registerCmd("location", WRAP_METHOD(Console, cmdLocation));
 	registerCmd("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
-	registerCmd("parseallscrfiles", WRAP_METHOD(Console, cmdParseAllScrFiles));
-	registerCmd("rendertext", WRAP_METHOD(Console, cmdRenderText));
-}
-
-bool Console::cmdLoadImage(int argc, const char **argv) {
-	if (argc == 4)
-		_engine->getRenderManager()->renderImageToScreen(argv[1], atoi(argv[2]), atoi(argv[3]));
-	else {
-		debugPrintf("Use loadimage <fileName> <destinationX> <destinationY> to load an image to the screen\n");
-		return true;
-	}
-
-	return true;
+	registerCmd("dumpfiles", WRAP_METHOD(Console, cmdDumpFiles));
+	registerCmd("dumpimage", WRAP_METHOD(Console, cmdDumpImage));
+	registerCmd("statevalue", WRAP_METHOD(Console, cmdStateValue));
+	registerCmd("stateflag", WRAP_METHOD(Console, cmdStateFlag));
 }
 
 bool Console::cmdLoadVideo(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use loadvideo <fileName> to load a video to the screen\n");
+		debugPrintf("Use %s <fileName> to load a video to the screen\n", argv[0]);
 		return true;
 	}
 
@@ -94,18 +82,20 @@ bool Console::cmdLoadSound(int argc, const char **argv) {
 		Audio::AudioStream *soundStream = makeRawZorkStream(argv[1], _engine);
 		Audio::SoundHandle handle;
 		_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &handle, soundStream, -1, 100, 0, DisposeAfterUse::YES, false, false);
-
 	} else if (argc == 4) {
 		int isStereo = atoi(argv[3]);
 
 		Common::File *file = new Common::File();
-		file->open(argv[1]);
+		if (!_engine->getSearchManager()->openFile(*file, argv[1])) {
+			warning("File not found: %s", argv[1]);
+			return true;
+		}
 
 		Audio::AudioStream *soundStream = makeRawZorkStream(file, atoi(argv[2]), isStereo == 0 ? false : true);
 		Audio::SoundHandle handle;
 		_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &handle, soundStream, -1, 100, 0, DisposeAfterUse::YES, false, false);
 	} else {
-		debugPrintf("Use loadsound <fileName> [<rate> <isStereo: 1 or 0>] to load a sound\n");
+		debugPrintf("Use %s <fileName> [<rate> <isStereo: 1 or 0>] to load a sound\n", argv[0]);
 		return true;
 	}
 
@@ -114,17 +104,58 @@ bool Console::cmdLoadSound(int argc, const char **argv) {
 
 bool Console::cmdRawToWav(int argc, const char **argv) {
 	if (argc != 3) {
-		debugPrintf("Use raw2wav <rawFilePath> <wavFileName> to dump a .RAW file to .WAV\n");
+		debugPrintf("Use %s <rawFilePath> <wavFileName> to dump a .RAW file to .WAV\n", argv[0]);
 		return true;
 	}
 
-	convertRawToWav(argv[1], _engine, argv[2]);
+	Common::File file;
+	if (!_engine->getSearchManager()->openFile(file, argv[1])) {
+		warning("File not found: %s", argv[1]);
+		return true;
+	}
+
+	Audio::AudioStream *audioStream = makeRawZorkStream(argv[1], _engine);
+
+	Common::DumpFile output;
+	output.open(argv[2]);
+
+	output.writeUint32BE(MKTAG('R', 'I', 'F', 'F'));
+	output.writeUint32LE(file.size() * 2 + 36);
+	output.writeUint32BE(MKTAG('W', 'A', 'V', 'E'));
+	output.writeUint32BE(MKTAG('f', 'm', 't', ' '));
+	output.writeUint32LE(16);
+	output.writeUint16LE(1);
+	uint16 numChannels;
+	if (audioStream->isStereo()) {
+		numChannels = 2;
+		output.writeUint16LE(2);
+	} else {
+		numChannels = 1;
+		output.writeUint16LE(1);
+	}
+	output.writeUint32LE(audioStream->getRate());
+	output.writeUint32LE(audioStream->getRate() * numChannels * 2);
+	output.writeUint16LE(numChannels * 2);
+	output.writeUint16LE(16);
+	output.writeUint32BE(MKTAG('d', 'a', 't', 'a'));
+	output.writeUint32LE(file.size() * 2);
+	int16 *buffer = new int16[file.size()];
+	audioStream->readBuffer(buffer, file.size());
+#ifndef SCUMM_LITTLE_ENDIAN
+	for (int i = 0; i < file.size(); ++i)
+		buffer[i] = TO_LE_16(buffer[i]);
+#endif
+	output.write(buffer, file.size() * 2);
+
+	delete[] buffer;
+
+
 	return true;
 }
 
 bool Console::cmdSetRenderState(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use setrenderstate <RenderState: panorama, tilt, flat> to change the current render state\n");
+		debugPrintf("Use %s <RenderState: panorama, tilt, flat> to change the current render state\n", argv[0]);
 		return true;
 	}
 
@@ -137,7 +168,7 @@ bool Console::cmdSetRenderState(int argc, const char **argv) {
 	else if (renderState.matchString("flat", true))
 		_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::FLAT);
 	else
-		debugPrintf("Use setrenderstate <RenderState: panorama, tilt, flat> to change the current render state\n");
+		debugPrintf("Use %s <RenderState: panorama, tilt, flat> to change the current render state\n", argv[0]);
 
 	return true;
 }
@@ -150,7 +181,7 @@ bool Console::cmdGenerateRenderTable(int argc, const char **argv) {
 
 bool Console::cmdSetPanoramaFoV(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use setpanoramafov <fieldOfView> to change the current panorama field of view\n");
+		debugPrintf("Use %s <fieldOfView> to change the current panorama field of view\n", argv[0]);
 		return true;
 	}
 
@@ -161,7 +192,7 @@ bool Console::cmdSetPanoramaFoV(int argc, const char **argv) {
 
 bool Console::cmdSetPanoramaScale(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use setpanoramascale <scale> to change the current panorama scale\n");
+		debugPrintf("Use %s <scale> to change the current panorama scale\n", argv[0]);
 		return true;
 	}
 
@@ -170,9 +201,14 @@ bool Console::cmdSetPanoramaScale(int argc, const char **argv) {
 	return true;
 }
 
-bool Console::cmdChangeLocation(int argc, const char **argv) {
+bool Console::cmdLocation(int argc, const char **argv) {
+	Location curLocation = _engine->getScriptManager()->getCurrentLocation();
+	Common::String scrFile = Common::String::format("%c%c%c%c.scr", curLocation.world, curLocation.room, curLocation.node, curLocation.view);
+	debugPrintf("Current location: world '%c', room '%c', node '%c', view '%c', offset %d, script %s\n",
+				curLocation.world, curLocation.room, curLocation.node, curLocation.view, curLocation.offset, scrFile.c_str());
+
 	if (argc != 6) {
-		debugPrintf("Use changelocation <char: world> <char: room> <char:node> <char:view> <int: x position> to change your location\n");
+		debugPrintf("Use %s <char: world> <char: room> <char:node> <char:view> <int: x offset> to change your location\n", argv[0]);
 		return true;
 	}
 
@@ -181,36 +217,152 @@ bool Console::cmdChangeLocation(int argc, const char **argv) {
 	return true;
 }
 
+void dumpFile(Common::SeekableReadStream *s, const char *outName) {
+	byte *buffer = new byte[s->size()];
+	s->read(buffer, s->size());
+
+	Common::DumpFile dumpFile;
+	dumpFile.open(outName);
+
+	dumpFile.write(buffer, s->size());
+	dumpFile.flush();
+	dumpFile.close();
+
+	delete[] buffer;
+}
+
 bool Console::cmdDumpFile(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use dumpfile <fileName> to dump a file\n");
+		debugPrintf("Use %s <fileName> to dump a file\n", argv[0]);
 		return true;
 	}
 
-	writeFileContentsToFile(argv[1], argv[1]);
+	Common::File f;
+	if (!_engine->getSearchManager()->openFile(f, argv[1])) {
+		warning("File not found: %s", argv[1]);
+		return true;
+	}
+
+	dumpFile(&f, argv[1]);
 
 	return true;
 }
 
-bool Console::cmdParseAllScrFiles(int argc, const char **argv) {
-	Common::ArchiveMemberList list;
-	SearchMan.listMatchingMembers(list, "*.scr");
+bool Console::cmdDumpFiles(int argc, const char **argv) {
+	Common::String fileName;
+	Common::SeekableReadStream *in;
+
+	if (argc != 2) {
+		debugPrintf("Use %s <file extension> to dump all files with a specific extension\n", argv[0]);
+		return true;
+	}
+
+	SearchManager::MatchList fileList;
+	_engine->getSearchManager()->listMembersWithExtension(fileList, argv[1]);
+
+	for (SearchManager::MatchList::iterator iter = fileList.begin(); iter != fileList.end(); ++iter) {
+		fileName = iter->_value.name;
+		debugPrintf("Dumping %s\n", fileName.c_str());
 
-	for (Common::ArchiveMemberList::iterator iter = list.begin(); iter != list.end(); ++iter) {
-		_engine->getScriptManager()->parseScrFile((*iter)->getName());
+		in = iter->_value.arch->createReadStreamForMember(iter->_value.name);
+		if (in)
+			dumpFile(in, fileName.c_str());
+		delete in;
 	}
 
 	return true;
 }
 
-bool Console::cmdRenderText(int argc, const char **argv) {
-	if (argc != 7) {
-		debugPrintf("Use rendertext <text> <fontNumber> <destX> <destY> <maxWidth> <1 or 0: wrap> to render text\n");
+bool Console::cmdDumpImage(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Use %s <TGA/TGZ name> to dump a ZVision TGA/TGZ image into a regular BMP image\n", argv[0]);
+		return true;
+	}
+
+	Common::String fileName = argv[1];
+	if (!fileName.hasSuffix(".tga")) {
+		debugPrintf("%s is not an image file", argv[1]);
+	}
+
+	Common::File f;
+	if (!_engine->getSearchManager()->openFile(f, argv[1])) {
+		warning("File not found: %s", argv[1]);
 		return true;
 	}
 
-	StringManager::TextStyle style = _engine->getStringManager()->getTextStyle(atoi(argv[2]));
-	_engine->getRenderManager()->renderTextToWorkingWindow(333, Common::String(argv[1]), style.font, atoi(argv[3]), atoi(argv[4]), style.color, atoi(argv[5]), -1, Graphics::kTextAlignLeft, atoi(argv[6]) == 0 ? false : true);
+	Graphics::Surface surface;
+	_engine->getRenderManager()->readImageToSurface(argv[1], surface, false);
+
+	// Open file
+	Common::DumpFile out;
+
+	fileName.setChar('b', fileName.size() - 3);
+	fileName.setChar('m', fileName.size() - 2);
+	fileName.setChar('p', fileName.size() - 1);
+
+	out.open(fileName);
+
+	// Write BMP header
+	out.writeByte('B');
+	out.writeByte('M');
+	out.writeUint32LE(surface.h * surface.pitch + 54);
+	out.writeUint32LE(0);
+	out.writeUint32LE(54);
+	out.writeUint32LE(40);
+	out.writeUint32LE(surface.w);
+	out.writeUint32LE(surface.h);
+	out.writeUint16LE(1);
+	out.writeUint16LE(16);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+
+	// Write pixel data to BMP
+	out.write(surface.getPixels(), surface.pitch * surface.h);
+
+	out.flush();
+	out.close();
+
+	surface.free();
+
+	return true;
+}
+
+bool Console::cmdStateValue(int argc, const char **argv) {
+	if (argc < 2) {
+		debugPrintf("Use %s <valuenum> to show the value of a state variable\n", argv[0]);
+		debugPrintf("Use %s <valuenum> <newvalue> to set the value of a state variable\n", argv[0]);
+		return true;
+	}
+
+	int valueNum = atoi(argv[1]);
+	int newValue = (argc > 2) ? atoi(argv[2]) : -1;
+
+	if (argc == 2)
+		debugPrintf("[%d] = %d\n", valueNum, _engine->getScriptManager()->getStateValue(valueNum));
+	else if (argc == 3)
+		_engine->getScriptManager()->setStateValue(valueNum, newValue);
+
+	return true;
+}
+
+bool Console::cmdStateFlag(int argc, const char **argv) {
+	if (argc < 2) {
+		debugPrintf("Use %s <flagnum> to show the value of a state flag\n", argv[0]);
+		debugPrintf("Use %s <flagnum> <newvalue> to set the value of a state flag\n", argv[0]);
+		return true;
+	}
+
+	int valueNum = atoi(argv[1]);
+	int newValue = (argc > 2) ? atoi(argv[2]) : -1;
+
+	if (argc == 2)
+		debugPrintf("[%d] = %d\n", valueNum, _engine->getScriptManager()->getStateFlag(valueNum));
+	else if (argc == 3)
+		_engine->getScriptManager()->setStateFlag(valueNum, newValue);
 
 	return true;
 }
diff --git a/engines/zvision/core/console.h b/engines/zvision/core/console.h
index 29523c57ee..ac834185a0 100644
--- a/engines/zvision/core/console.h
+++ b/engines/zvision/core/console.h
@@ -37,7 +37,6 @@ public:
 private:
 	ZVision *_engine;
 
-	bool cmdLoadImage(int argc, const char **argv);
 	bool cmdLoadVideo(int argc, const char **argv);
 	bool cmdLoadSound(int argc, const char **argv);
 	bool cmdRawToWav(int argc, const char **argv);
@@ -45,10 +44,12 @@ private:
 	bool cmdGenerateRenderTable(int argc, const char **argv);
 	bool cmdSetPanoramaFoV(int argc, const char **argv);
 	bool cmdSetPanoramaScale(int argc, const char **argv);
-	bool cmdChangeLocation(int argc, const char **argv);
+	bool cmdLocation(int argc, const char **argv);
 	bool cmdDumpFile(int argc, const char **argv);
-	bool cmdParseAllScrFiles(int argc, const char **argv);
-	bool cmdRenderText(int argc, const char **argv);
+	bool cmdDumpFiles(int argc, const char **argv);
+	bool cmdDumpImage(int argc, const char **argv);
+	bool cmdStateValue(int argc, const char **argv);
+	bool cmdStateFlag(int argc, const char **argv);
 };
 
 } // End of namespace ZVision
diff --git a/engines/zvision/core/events.cpp b/engines/zvision/core/events.cpp
index 83d6c17dec..cc1c00b6d0 100644
--- a/engines/zvision/core/events.cpp
+++ b/engines/zvision/core/events.cpp
@@ -8,12 +8,12 @@
  * 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.
@@ -25,10 +25,12 @@
 #include "zvision/zvision.h"
 
 #include "zvision/core/console.h"
-#include "zvision/cursors/cursor_manager.h"
+#include "zvision/graphics/cursors/cursor_manager.h"
 #include "zvision/graphics/render_manager.h"
 #include "zvision/scripting/script_manager.h"
-#include "zvision/animation/rlf_animation.h"
+#include "zvision/scripting/menu.h"
+#include "zvision/sound/zork_raw.h"
+#include "zvision/text/string_manager.h"
 
 #include "common/events.h"
 #include "common/system.h"
@@ -36,29 +38,190 @@
 
 #include "engines/util.h"
 
-
 namespace ZVision {
 
+void ZVision::pushKeyToCheatBuf(uint8 key) {
+	for (int i = 0; i < KEYBUF_SIZE - 1; i++)
+		_cheatBuffer[i] = _cheatBuffer[i + 1];
+
+	_cheatBuffer[KEYBUF_SIZE - 1] = key;
+}
+
+bool ZVision::checkCode(const char *code) {
+	int codeLen = strlen(code);
+
+	if (codeLen > KEYBUF_SIZE)
+		return false;
+
+	for (int i = 0; i < codeLen; i++)
+		if (code[i] != _cheatBuffer[KEYBUF_SIZE - codeLen + i] && code[i] != '?')
+			return false;
+
+	return true;
+}
+
+uint8 ZVision::getBufferedKey(uint8 pos) {
+	if (pos >= KEYBUF_SIZE)
+		return 0;
+	else
+		return _cheatBuffer[KEYBUF_SIZE - pos - 1];
+}
+
+void ZVision::shortKeys(Common::Event event) {
+	if (event.kbd.hasFlags(Common::KBD_CTRL)) {
+		switch (event.kbd.keycode) {
+		case Common::KEYCODE_s:
+			if (_menu->getEnable() & kMenubarSave)
+				_scriptManager->changeLocation('g', 'j', 's', 'e', 0);
+			break;
+		case Common::KEYCODE_r:
+			if (_menu->getEnable() & kMenubarRestore)
+				_scriptManager->changeLocation('g', 'j', 'r', 'e', 0);
+			break;
+		case Common::KEYCODE_p:
+			if (_menu->getEnable() & kMenubarSettings)
+				_scriptManager->changeLocation('g', 'j', 'p', 'e', 0);
+			break;
+		case Common::KEYCODE_q:
+			if (_menu->getEnable() & kMenubarExit)
+				ifQuit();
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+void ZVision::cheatCodes(uint8 key) {
+	Location loc = _scriptManager->getCurrentLocation();
+	// Do not process cheat codes while in the game menus
+	if (loc.world == 'g' && loc.room == 'j')
+		return;
+
+	pushKeyToCheatBuf(key);
+
+	if (getGameId() == GID_GRANDINQUISITOR) {
+		if (checkCode("IMNOTDEAF")) {
+			// Unknown cheat
+			_renderManager->showDebugMsg(Common::String::format("IMNOTDEAF cheat or debug, not implemented"));
+		}
+
+		if (checkCode("3100OPB")) {
+			_renderManager->showDebugMsg(Common::String::format("Current location: %c%c%c%c",
+			                                    _scriptManager->getStateValue(StateKey_World),
+			                                    _scriptManager->getStateValue(StateKey_Room),
+			                                    _scriptManager->getStateValue(StateKey_Node),
+			                                    _scriptManager->getStateValue(StateKey_View)));
+		}
+
+		if (checkCode("KILLMENOW")) {
+			_scriptManager->changeLocation('g', 'j', 'd', 'e', 0);
+			_scriptManager->setStateValue(2201, 35);
+		}
+
+		if (checkCode("MIKESPANTS")) {
+			_scriptManager->changeLocation('g', 'j', 't', 'm', 0);
+		}
+
+		// There are 3 more cheats in script files:
+		// - "WHOAMI": gjcr.scr
+		// - "HUISOK": hp1e.scr
+		// - "EAT ME": uh1f.scr
+	} else if (getGameId() == GID_NEMESIS) {
+		if (checkCode("CHLOE")) {
+			_scriptManager->changeLocation('t', 'm', '2', 'g', 0);
+			_scriptManager->setStateValue(224, 1);
+		}
+
+		if (checkCode("77MASSAVE")) {
+			_renderManager->showDebugMsg(Common::String::format("Current location: %c%c%c%c",
+			                                    _scriptManager->getStateValue(StateKey_World),
+			                                    _scriptManager->getStateValue(StateKey_Room),
+			                                    _scriptManager->getStateValue(StateKey_Node),
+			                                    _scriptManager->getStateValue(StateKey_View)));
+		}
+
+		if (checkCode("IDKFA")) {
+			_scriptManager->changeLocation('t', 'w', '3', 'f', 0);
+			_scriptManager->setStateValue(249, 1);
+		}
+
+		if (checkCode("309NEWDORMA")) {
+			_scriptManager->changeLocation('g', 'j', 'g', 'j', 0);
+		}
+
+		if (checkCode("HELLOSAILOR")) {
+			Audio::AudioStream *soundStream;
+			if (loc == "vb10") {
+				soundStream = makeRawZorkStream("v000hpta.raw", this);
+			} else {
+				soundStream = makeRawZorkStream("v000hnta.raw", this);
+			}
+			Audio::SoundHandle handle;
+			_mixer->playStream(Audio::Mixer::kPlainSoundType, &handle, soundStream);
+		}
+	}
+
+	if (checkCode("FRAME")) {
+		Common::String fpsStr = Common::String::format("FPS: %d", getFPS());
+		_renderManager->showDebugMsg(fpsStr);
+	}
+
+	if (checkCode("COMPUTERARCH"))
+		_renderManager->showDebugMsg("COMPUTERARCH: var-viewer not implemented");
+
+	// This cheat essentially toggles the GOxxxx cheat below
+	if (checkCode("XYZZY"))
+		_scriptManager->setStateValue(StateKey_DebugCheats, 1 - _scriptManager->getStateValue(StateKey_DebugCheats));
+
+	if (_scriptManager->getStateValue(StateKey_DebugCheats) == 1)
+		if (checkCode("GO????"))
+			_scriptManager->changeLocation(getBufferedKey(3),
+			                               getBufferedKey(2),
+			                               getBufferedKey(1),
+			                               getBufferedKey(0), 0);
+
+	// Show the Venus screen when "?" or "/" is pressed while inside the temple world
+	if (_scriptManager->getStateValue(StateKey_VenusEnable) == 1)
+		if (getBufferedKey(0) == 0xBF && _scriptManager->getStateValue(StateKey_World) == 't')
+			_scriptManager->changeLocation('g', 'j', 'h', 'e', 0);
+}
+
 void ZVision::processEvents() {
 	while (_eventMan->pollEvent(_event)) {
 		switch (_event.type) {
 		case Common::EVENT_LBUTTONDOWN:
-			onMouseDown(_event.mouse);
+			_cursorManager->cursorDown(true);
+			_scriptManager->setStateValue(StateKey_LMouse, 1);
+			_menu->onMouseDown(_event.mouse);
+			_scriptManager->addEvent(_event);
 			break;
 
 		case Common::EVENT_LBUTTONUP:
-			onMouseUp(_event.mouse);
+			_cursorManager->cursorDown(false);
+			_scriptManager->setStateValue(StateKey_LMouse, 0);
+			_menu->onMouseUp(_event.mouse);
+			_scriptManager->addEvent(_event);
 			break;
 
 		case Common::EVENT_RBUTTONDOWN:
-			// TODO: Inventory logic
+			_cursorManager->cursorDown(true);
+			_scriptManager->setStateValue(StateKey_RMouse, 1);
+
+			if (getGameId() == GID_NEMESIS)
+				_scriptManager->inventoryCycle();
+			break;
+
+		case Common::EVENT_RBUTTONUP:
+			_cursorManager->cursorDown(false);
+			_scriptManager->setStateValue(StateKey_RMouse, 0);
 			break;
 
 		case Common::EVENT_MOUSEMOVE:
 			onMouseMove(_event.mouse);
 			break;
 
-		case Common::EVENT_KEYDOWN:
+		case Common::EVENT_KEYDOWN: {
 			switch (_event.kbd.keycode) {
 			case Common::KEYCODE_d:
 				if (_event.kbd.hasFlags(Common::KBD_CTRL)) {
@@ -67,18 +230,57 @@ void ZVision::processEvents() {
 					_console->onFrame();
 				}
 				break;
-			case Common::KEYCODE_q:
-				if (_event.kbd.hasFlags(Common::KBD_CTRL))
-					quitGame();
+
+			case Common::KEYCODE_LEFT:
+			case Common::KEYCODE_RIGHT:
+				if (_renderManager->getRenderTable()->getRenderState() == RenderTable::PANORAMA)
+					_keyboardVelocity = (_event.kbd.keycode == Common::KEYCODE_LEFT ?
+					                     -_scriptManager->getStateValue(StateKey_KbdRotateSpeed) :
+					                     _scriptManager->getStateValue(StateKey_KbdRotateSpeed)) * 2;
+				break;
+
+			case Common::KEYCODE_UP:
+			case Common::KEYCODE_DOWN:
+				if (_renderManager->getRenderTable()->getRenderState() == RenderTable::TILT)
+					_keyboardVelocity = (_event.kbd.keycode == Common::KEYCODE_UP ?
+					                     -_scriptManager->getStateValue(StateKey_KbdRotateSpeed) :
+					                     _scriptManager->getStateValue(StateKey_KbdRotateSpeed)) * 2;
+				break;
+
+			case Common::KEYCODE_F10: {
+				Common::String fpsStr = Common::String::format("FPS: %d", getFPS());
+				_renderManager->showDebugMsg(fpsStr);
+				}
 				break;
 			default:
 				break;
 			}
 
-			_scriptManager->onKeyDown(_event.kbd);
-			break;
+			uint8 vkKey = getZvisionKey(_event.kbd.keycode);
+
+			_scriptManager->setStateValue(StateKey_KeyPress, vkKey);
+
+			_scriptManager->addEvent(_event);
+			shortKeys(_event);
+			cheatCodes(vkKey);
+		}
+		break;
 		case Common::EVENT_KEYUP:
-			_scriptManager->onKeyUp(_event.kbd);
+			_scriptManager->addEvent(_event);
+			switch (_event.kbd.keycode) {
+			case Common::KEYCODE_LEFT:
+			case Common::KEYCODE_RIGHT:
+				if (_renderManager->getRenderTable()->getRenderState() == RenderTable::PANORAMA)
+					_keyboardVelocity = 0;
+				break;
+			case Common::KEYCODE_UP:
+			case Common::KEYCODE_DOWN:
+				if (_renderManager->getRenderTable()->getRenderState() == RenderTable::TILT)
+					_keyboardVelocity = 0;
+				break;
+			default:
+				break;
+			}
 			break;
 		default:
 			break;
@@ -86,24 +288,11 @@ void ZVision::processEvents() {
 	}
 }
 
-void ZVision::onMouseDown(const Common::Point &pos) {
-	_cursorManager->cursorDown(true);
-
-	Common::Point imageCoord(_renderManager->screenSpaceToImageSpace(pos));
-	_scriptManager->onMouseDown(pos, imageCoord);
-}
-
-void ZVision::onMouseUp(const Common::Point &pos) {
-	_cursorManager->cursorDown(false);
-
-	Common::Point imageCoord(_renderManager->screenSpaceToImageSpace(pos));
-	_scriptManager->onMouseUp(pos, imageCoord);
-}
-
 void ZVision::onMouseMove(const Common::Point &pos) {
+	_menu->onMouseMove(pos);
 	Common::Point imageCoord(_renderManager->screenSpaceToImageSpace(pos));
 
-	bool cursorWasChanged = _scriptManager->onMouseMove(pos, imageCoord);
+	bool cursorWasChanged = false;
 
 	// Graph of the function governing rotation velocity:
 	//
@@ -135,52 +324,183 @@ void ZVision::onMouseMove(const Common::Point &pos) {
 	//               |
 	//               ^
 
-	if (_workingWindow.contains(pos)) {
+	// Clip the horizontal mouse position to the working window
+	Common::Point clippedPos = pos;
+	clippedPos.x = CLIP<int16>(pos.x, _workingWindow.left + 1, _workingWindow.right - 1);
+
+	if (_workingWindow.contains(clippedPos)) {
+		cursorWasChanged = _scriptManager->onMouseMove(clippedPos, imageCoord);
+
 		RenderTable::RenderState renderState = _renderManager->getRenderTable()->getRenderState();
 		if (renderState == RenderTable::PANORAMA) {
-			if (pos.x >= _workingWindow.left && pos.x < _workingWindow.left + ROTATION_SCREEN_EDGE_OFFSET) {
-				// Linear function of distance to the left edge (y = -mx + b)
-				// We use fixed point math to get better accuracy
-				Common::Rational velocity = (Common::Rational(MAX_ROTATION_SPEED, ROTATION_SCREEN_EDGE_OFFSET) * (pos.x - _workingWindow.left)) - MAX_ROTATION_SPEED;
-				_renderManager->setBackgroundVelocity(velocity.toInt());
-				_cursorManager->setLeftCursor();
+			if (clippedPos.x >= _workingWindow.left && clippedPos.x < _workingWindow.left + ROTATION_SCREEN_EDGE_OFFSET) {
+
+				int16 mspeed = _scriptManager->getStateValue(StateKey_RotateSpeed) >> 4;
+				if (mspeed <= 0) {
+					mspeed = 25;
+				}
+				_mouseVelocity  = MIN(((Common::Rational(mspeed, ROTATION_SCREEN_EDGE_OFFSET) * (clippedPos.x - _workingWindow.left)) - mspeed).toInt(), -1);
+
+
+				_cursorManager->changeCursor(CursorIndex_Left);
 				cursorWasChanged = true;
-			} else if (pos.x <= _workingWindow.right && pos.x > _workingWindow.right - ROTATION_SCREEN_EDGE_OFFSET) {
-				// Linear function of distance to the right edge (y = mx)
-				// We use fixed point math to get better accuracy
-				Common::Rational velocity = Common::Rational(MAX_ROTATION_SPEED, ROTATION_SCREEN_EDGE_OFFSET) * (pos.x - _workingWindow.right + ROTATION_SCREEN_EDGE_OFFSET);
-				_renderManager->setBackgroundVelocity(velocity.toInt());
-				_cursorManager->setRightCursor();
+			} else if (clippedPos.x <= _workingWindow.right && clippedPos.x > _workingWindow.right - ROTATION_SCREEN_EDGE_OFFSET) {
+
+				int16 mspeed = _scriptManager->getStateValue(StateKey_RotateSpeed) >> 4;
+				if (mspeed <= 0) {
+					mspeed = 25;
+				}
+				_mouseVelocity  = MAX((Common::Rational(mspeed, ROTATION_SCREEN_EDGE_OFFSET) * (clippedPos.x - _workingWindow.right + ROTATION_SCREEN_EDGE_OFFSET)).toInt(), 1);
+
+				_cursorManager->changeCursor(CursorIndex_Right);
 				cursorWasChanged = true;
 			} else {
-				_renderManager->setBackgroundVelocity(0);
+				_mouseVelocity = 0;
 			}
 		} else if (renderState == RenderTable::TILT) {
-			if (pos.y >= _workingWindow.top && pos.y < _workingWindow.top + ROTATION_SCREEN_EDGE_OFFSET) {
-				// Linear function of distance to top edge
-				// We use fixed point math to get better accuracy
-				Common::Rational velocity = (Common::Rational(MAX_ROTATION_SPEED, ROTATION_SCREEN_EDGE_OFFSET) * (pos.y - _workingWindow.top)) - MAX_ROTATION_SPEED;
-				_renderManager->setBackgroundVelocity(velocity.toInt());
-				_cursorManager->setUpCursor();
+			if (clippedPos.y >= _workingWindow.top && clippedPos.y < _workingWindow.top + ROTATION_SCREEN_EDGE_OFFSET) {
+
+				int16 mspeed = _scriptManager->getStateValue(StateKey_RotateSpeed) >> 4;
+				if (mspeed <= 0) {
+					mspeed = 25;
+				}
+				_mouseVelocity  = MIN(((Common::Rational(mspeed, ROTATION_SCREEN_EDGE_OFFSET) * (pos.y - _workingWindow.top)) - mspeed).toInt(), -1);
+
+				_cursorManager->changeCursor(CursorIndex_UpArr);
 				cursorWasChanged = true;
-			} else if (pos.y <= _workingWindow.bottom && pos.y > _workingWindow.bottom - ROTATION_SCREEN_EDGE_OFFSET) {
-				// Linear function of distance to the bottom edge (y = mx)
-				// We use fixed point math to get better accuracy
-				Common::Rational velocity = Common::Rational(MAX_ROTATION_SPEED, ROTATION_SCREEN_EDGE_OFFSET) * (pos.y - _workingWindow.bottom + ROTATION_SCREEN_EDGE_OFFSET);
-				_renderManager->setBackgroundVelocity(velocity.toInt());
-				_cursorManager->setDownCursor();
+			} else if (clippedPos.y <= _workingWindow.bottom && clippedPos.y > _workingWindow.bottom - ROTATION_SCREEN_EDGE_OFFSET) {
+
+				int16 mspeed = _scriptManager->getStateValue(StateKey_RotateSpeed) >> 4;
+				if (mspeed <= 0) {
+					mspeed = 25;
+				}
+				_mouseVelocity = MAX((Common::Rational(MAX_ROTATION_SPEED, ROTATION_SCREEN_EDGE_OFFSET) * (pos.y - _workingWindow.bottom + ROTATION_SCREEN_EDGE_OFFSET)).toInt(), 1);
+
+				_cursorManager->changeCursor(CursorIndex_DownArr);
 				cursorWasChanged = true;
 			} else {
-				_renderManager->setBackgroundVelocity(0);
+				_mouseVelocity = 0;
 			}
+		} else {
+			_mouseVelocity = 0;
 		}
 	} else {
-		_renderManager->setBackgroundVelocity(0);
+		_mouseVelocity = 0;
 	}
 
 	if (!cursorWasChanged) {
-		_cursorManager->revertToIdle();
+		_cursorManager->changeCursor(CursorIndex_Idle);
+	}
+}
+
+uint8 ZVision::getZvisionKey(Common::KeyCode scummKeyCode) {
+	if (scummKeyCode >= Common::KEYCODE_a && scummKeyCode <= Common::KEYCODE_z)
+		return 0x41 + scummKeyCode - Common::KEYCODE_a;
+	if (scummKeyCode >= Common::KEYCODE_0 && scummKeyCode <= Common::KEYCODE_9)
+		return 0x30 + scummKeyCode - Common::KEYCODE_0;
+	if (scummKeyCode >= Common::KEYCODE_F1 && scummKeyCode <= Common::KEYCODE_F15)
+		return 0x70 + scummKeyCode - Common::KEYCODE_F1;
+	if (scummKeyCode >= Common::KEYCODE_KP0 && scummKeyCode <= Common::KEYCODE_KP9)
+		return 0x60 + scummKeyCode - Common::KEYCODE_KP0;
+
+	switch (scummKeyCode) {
+	case Common::KEYCODE_BACKSPACE:
+		return 0x8;
+	case Common::KEYCODE_TAB:
+		return 0x9;
+	case Common::KEYCODE_CLEAR:
+		return 0xC;
+	case Common::KEYCODE_RETURN:
+		return 0xD;
+	case Common::KEYCODE_CAPSLOCK:
+		return 0x14;
+	case Common::KEYCODE_ESCAPE:
+		return 0x1B;
+	case Common::KEYCODE_SPACE:
+		return 0x20;
+	case Common::KEYCODE_PAGEUP:
+		return 0x21;
+	case Common::KEYCODE_PAGEDOWN:
+		return 0x22;
+	case Common::KEYCODE_END:
+		return 0x23;
+	case Common::KEYCODE_HOME:
+		return 0x24;
+	case Common::KEYCODE_LEFT:
+		return 0x25;
+	case Common::KEYCODE_UP:
+		return 0x26;
+	case Common::KEYCODE_RIGHT:
+		return 0x27;
+	case Common::KEYCODE_DOWN:
+		return 0x28;
+	case Common::KEYCODE_PRINT:
+		return 0x2A;
+	case Common::KEYCODE_INSERT:
+		return 0x2D;
+	case Common::KEYCODE_DELETE:
+		return 0x2E;
+	case Common::KEYCODE_HELP:
+		return 0x2F;
+	case Common::KEYCODE_KP_MULTIPLY:
+		return 0x6A;
+	case Common::KEYCODE_KP_PLUS:
+		return 0x6B;
+	case Common::KEYCODE_KP_MINUS:
+		return 0x6D;
+	case Common::KEYCODE_KP_PERIOD:
+		return 0x6E;
+	case Common::KEYCODE_KP_DIVIDE:
+		return 0x6F;
+	case Common::KEYCODE_NUMLOCK:
+		return 0x90;
+	case Common::KEYCODE_SCROLLOCK:
+		return 0x91;
+	case Common::KEYCODE_LSHIFT:
+		return 0xA0;
+	case Common::KEYCODE_RSHIFT:
+		return 0xA1;
+	case Common::KEYCODE_LCTRL:
+		return 0xA2;
+	case Common::KEYCODE_RCTRL:
+		return 0xA3;
+	case Common::KEYCODE_MENU:
+		return 0xA5;
+	case Common::KEYCODE_LEFTBRACKET:
+		return 0xDB;
+	case Common::KEYCODE_RIGHTBRACKET:
+		return 0xDD;
+	case Common::KEYCODE_SEMICOLON:
+		return 0xBA;
+	case Common::KEYCODE_BACKSLASH:
+		return 0xDC;
+	case Common::KEYCODE_QUOTE:
+		return 0xDE;
+	case Common::KEYCODE_SLASH:
+		return 0xBF;
+	case Common::KEYCODE_TILDE:
+		return 0xC0;
+	case Common::KEYCODE_COMMA:
+		return 0xBC;
+	case Common::KEYCODE_PERIOD:
+		return 0xBE;
+	case Common::KEYCODE_MINUS:
+		return 0xBD;
+	case Common::KEYCODE_PLUS:
+		return 0xBB;
+	default:
+		return 0;
+	}
+
+	return 0;
+}
+
+bool ZVision::ifQuit() {
+	if (_renderManager->askQuestion(_stringManager->getTextLine(StringManager::ZVISION_STR_EXITPROMT))) {
+		quitGame();
+		return true;
 	}
+	return false;
 }
 
 } // End of namespace ZVision
diff --git a/engines/zvision/core/save_manager.cpp b/engines/zvision/core/save_manager.cpp
deleted file mode 100644
index 07fb7637e7..0000000000
--- a/engines/zvision/core/save_manager.cpp
+++ /dev/null
@@ -1,206 +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.
- *
- */
-
-#include "common/scummsys.h"
-
-#include "zvision/core/save_manager.h"
-
-#include "zvision/zvision.h"
-#include "zvision/scripting/script_manager.h"
-#include "zvision/graphics/render_manager.h"
-
-#include "common/system.h"
-
-#include "graphics/surface.h"
-#include "graphics/thumbnail.h"
-
-#include "gui/message.h"
-
-
-namespace ZVision {
-
-const uint32 SaveManager::SAVEGAME_ID = MKTAG('Z', 'E', 'N', 'G');
-
-void SaveManager::saveGame(uint slot, const Common::String &saveName) {
-	// The games only support 20 slots
-	assert(slot <= 1 && slot <= 20);
-
-	Common::SaveFileManager *saveFileManager = g_system->getSavefileManager();
-	Common::OutSaveFile *file = saveFileManager->openForSaving(_engine->generateSaveFileName(slot));
-
-	// Write out the savegame header
-	file->writeUint32BE(SAVEGAME_ID);
-
-	// Write version
-	file->writeByte(SAVE_VERSION);
-
-	// Write savegame name
-	file->writeString(saveName);
-	file->writeByte(0);
-
-	// We can't call writeGameSaveData because the save menu is actually
-	// a room, so writeGameSaveData would save us in the save menu.
-	// However, an auto save is performed before each room change, so we
-	// can copy the data from there. We can guarantee that an auto save file will
-	// exist before this is called because the save menu can only be accessed
-	// after the first room (the main menu) has loaded.
-	Common::InSaveFile *autoSaveFile = saveFileManager->openForLoading(_engine->generateAutoSaveFileName());
-
-	// Skip over the header info
-	autoSaveFile->readSint32BE(); // SAVEGAME_ID
-	autoSaveFile->readByte(); // Version
-	autoSaveFile->seek(5, SEEK_CUR); // The string "auto" with terminating NULL
-
-	// Read the rest to a buffer
-	uint32 size = autoSaveFile->size() - autoSaveFile->pos();
-	byte *buffer = new byte[size];
-	autoSaveFile->read(buffer, size);
-
-	// Then write the buffer to the new file
-	file->write(buffer, size);
-
-	// Cleanup
-	delete[] buffer;
-	file->finalize();
-	delete file;
-}
-
-void SaveManager::autoSave() {
-	Common::OutSaveFile *file = g_system->getSavefileManager()->openForSaving(_engine->generateAutoSaveFileName());
-
-	// Write out the savegame header
-	file->writeUint32BE(SAVEGAME_ID);
-
-	// Version
-	file->writeByte(SAVE_VERSION);
-
-	file->writeString("auto");
-	file->writeByte(0);
-
-	writeSaveGameData(file);
-
-	// Cleanup
-	file->finalize();
-	delete file;
-}
-
-void SaveManager::writeSaveGameData(Common::OutSaveFile *file) {
-	// Create a thumbnail and save it
-	Graphics::saveThumbnail(*file);
-	
-	// Write out the save date/time
-	TimeDate td;
-	g_system->getTimeAndDate(td);
-	file->writeSint16LE(td.tm_year + 1900);
-	file->writeSint16LE(td.tm_mon + 1);
-	file->writeSint16LE(td.tm_mday);
-	file->writeSint16LE(td.tm_hour);
-	file->writeSint16LE(td.tm_min);
-
-	ScriptManager *scriptManager = _engine->getScriptManager();
-	// Write out the current location
-	Location currentLocation = scriptManager->getCurrentLocation();
-	file->writeByte(currentLocation.world);
-	file->writeByte(currentLocation.room);
-	file->writeByte(currentLocation.node);
-	file->writeByte(currentLocation.view);
-	file->writeUint32LE(currentLocation.offset);
-
-	// Write out the current state table values
-	scriptManager->serializeStateTable(file);
-
-	// Write out any controls needing to save state
-	scriptManager->serializeControls(file);
-}
-
-Common::Error SaveManager::loadGame(uint slot) {
-	// The games only support 20 slots
-	assert(slot <= 1 && slot <= 20);
-
-	Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(_engine->generateSaveFileName(slot));
-	if (saveFile == 0) {
-		return Common::kPathDoesNotExist;
-	}
-
-	// Read the header
-	SaveGameHeader header;
-	if (!readSaveGameHeader(saveFile, header)) {
-		return Common::kUnknownError;
-	}
-
-	char world = (char)saveFile->readByte();
-	char room = (char)saveFile->readByte();
-	char node = (char)saveFile->readByte();
-	char view = (char)saveFile->readByte();
-	uint32 offset = (char)saveFile->readUint32LE();
-
-	ScriptManager *scriptManager = _engine->getScriptManager();
-	// Update the state table values
-	scriptManager->deserializeStateTable(saveFile);
-
-	// Load the room
-	scriptManager->changeLocation(world, room, node, view, offset);
-
-	// Update the controls
-	scriptManager->deserializeControls(saveFile);
-
-	return Common::kNoError;
-}
-
-bool SaveManager::readSaveGameHeader(Common::InSaveFile *in, SaveGameHeader &header) {
-	if (in->readUint32BE() != SAVEGAME_ID) {
-		warning("File is not a ZVision save file. Aborting load");
-		return false;
-	}
-	
-	// Read in the version
-	header.version = in->readByte();
-
-	// Check that the save version isn't newer than this binary
-	if (header.version > SAVE_VERSION) {
-		uint tempVersion = header.version;
-		GUI::MessageDialog dialog(Common::String::format("This save file uses version %u, but this engine only supports up to version %d. You will need an updated version of the engine to use this save file.", tempVersion, SAVE_VERSION), "OK");
-		dialog.runModal();
-	}
-
-	// Read in the save name
-	header.saveName.clear();
-	char ch;
-	while ((ch = (char)in->readByte()) != '\0')
-		header.saveName += ch;
-
-	// Get the thumbnail
-	header.thumbnail = Graphics::loadThumbnail(*in);
-	if (!header.thumbnail)
-		return false;
-
-	// Read in save date/time
-	header.saveYear = in->readSint16LE();
-	header.saveMonth = in->readSint16LE();
-	header.saveDay = in->readSint16LE();
-	header.saveHour = in->readSint16LE();
-	header.saveMinutes = in->readSint16LE();
-
-	return true;
-}
-
-} // End of namespace ZVision
diff --git a/engines/zvision/core/save_manager.h b/engines/zvision/core/save_manager.h
deleted file mode 100644
index 43fb0c0faf..0000000000
--- a/engines/zvision/core/save_manager.h
+++ /dev/null
@@ -1,91 +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.
- *
- */
-
-#ifndef ZVISION_SAVE_MANAGER_H
-#define ZVISION_SAVE_MANAGER_H
-
-#include "common/savefile.h"
-
-namespace Common {
-class String;
-}
-
-namespace Graphics {
-struct Surface;
-}
-
-namespace ZVision {
-
-class ZVision;
-
-struct SaveGameHeader {
-	byte version;
-	Common::String saveName;
-	Graphics::Surface *thumbnail;
-	int saveYear, saveMonth, saveDay;
-	int saveHour, saveMinutes;
-};
-
-class SaveManager {
-public:
-	SaveManager(ZVision *engine) : _engine(engine) {}
-
-private:
-	ZVision *_engine;
-	static const uint32 SAVEGAME_ID;
-
-	enum {
-		SAVE_VERSION = 1
-	};
-
-public:
-	/**
-	 * Called every room change. Saves the state of the room just before
-	 * we switched rooms. Uses ZVision::generateAutoSaveFileName() to
-	 * create the save file name.
-	 */
-	void autoSave();
-	/**
-	 * Copies the data from the last auto-save into a new save file. We
-	 * can't use the current state data because the save menu *IS* a room.
-	 * The file is named using ZVision::generateSaveFileName(slot)
-	 *
-	 * @param slot        The save slot this save pertains to. Must be [1, 20]
-	 * @param saveName    The internal name for this save. This is NOT the name of the actual save file.
-	 */
-	void saveGame(uint slot, const Common::String &saveName);
-	/**
-	 * Loads the state data from the save file that slot references. Uses
-	 * ZVision::generateSaveFileName(slot) to get the save file name.
-	 *
-	 * @param slot    The save slot to load. Must be [1, 20]
-	 */
-	Common::Error loadGame(uint slot);
-
-private:
-	void writeSaveGameData(Common::OutSaveFile *file);
-	bool readSaveGameHeader(Common::InSaveFile *in, SaveGameHeader &header);
-};
-
-} // End of namespace ZVision
-
-#endif