Merge branch 'master' into zvision

50 files changed, 6514 insertions, 2 deletions

diff --git a/engines/configure.engines b/engines/configure.engines
index 963b9f774f..a3525576a2 100644
--- a/engines/configure.engines
+++ b/engines/configure.engines
@@ -52,3 +52,4 @@ add_engine tony "Tony Tough and the Night of Roasted Moths" yes "" "" "16bit"
 add_engine tsage "TsAGE" yes
 add_engine tucker "Bud Tucker in Double Trouble" yes
 add_engine wintermute "Wintermute" no "" "" "png zlib vorbis 16bit"
+add_engine zvision "ZVision" no
diff --git a/engines/engines.mk b/engines/engines.mk
index f58dba0d6d..e399713202 100644
--- a/engines/engines.mk
+++ b/engines/engines.mk
@@ -246,3 +246,8 @@ ifdef ENABLE_WINTERMUTE
 DEFINES += -DENABLE_WINTERMUTE=$(ENABLE_WINTERMUTE)
 MODULES += engines/wintermute
 endif
+
+ifdef ENABLE_ZVISION
+DEFINES += -DENABLE_ZVISION=$(ENABLE_ZVISION)
+MODULES += engines/zvision
+endif
\ No newline at end of file
diff --git a/engines/plugins_table.h b/engines/plugins_table.h
index edc94eb0d3..793f15110c 100644
--- a/engines/plugins_table.h
+++ b/engines/plugins_table.h
@@ -119,3 +119,6 @@ LINK_PLUGIN(TUCKER)
 #if PLUGIN_ENABLED_STATIC(WINTERMUTE)
 LINK_PLUGIN(WINTERMUTE)
 #endif
+#if PLUGIN_ENABLED_STATIC(ZVISION)
+LINK_PLUGIN(ZVISION)
+#endif
diff --git a/engines/zvision/action_node.cpp b/engines/zvision/action_node.cpp
new file mode 100644
index 0000000000..1a51690b3f
--- /dev/null
+++ b/engines/zvision/action_node.cpp
@@ -0,0 +1,45 @@
+/* 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/action_node.h"
+#include "zvision/zvision.h"
+#include "zvision/script_manager.h"
+
+namespace ZVision {
+
+NodeTimer::NodeTimer(uint32 key, uint timeInSeconds) 
+	: _key(key), _timeLeft(timeInSeconds * 1000) {}
+
+bool NodeTimer::process(ZVision *engine, uint32 deltaTimeInMillis) {
+	_timeLeft -= deltaTimeInMillis;
+
+	if (_timeLeft <= 0) {
+		engine->getScriptManager()->setStateValue(_key, 0);
+		return true;
+	}
+
+	return false;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/action_node.h b/engines/zvision/action_node.h
new file mode 100644
index 0000000000..5b4430c3a4
--- /dev/null
+++ b/engines/zvision/action_node.h
@@ -0,0 +1,58 @@
+/* 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_ACTION_NODE_H
+#define ZVISION_ACTION_NODE_H
+
+#include "common/types.h"
+
+namespace ZVision {
+
+class ZVision;
+
+class ActionNode {
+public:
+	virtual ~ActionNode() {}
+	virtual bool process(ZVision *engine, uint32 deltaTimeInMillis) = 0;
+};
+
+class NodeTimer : public ActionNode {
+public:
+	NodeTimer(uint32 key, uint timeInSeconds);
+	/**
+	 * Decrement the timer by the delta time. If the timer is finished, set the status
+	 * in _globalState and let this node be deleted
+	 *
+	 * @param engine               Pointer to the ZVision instance
+	 * @param deltaTimeInMillis    Amount of time that has passed since the last frame
+	 * @return    Node should be deleted after this (true) or kept (false)
+	 */
+	bool process(ZVision *engine, uint32 deltaTimeInMillis);
+
+private:
+	uint32 _key;
+	uint32 _timeLeft;
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/actions.cpp b/engines/zvision/actions.cpp
new file mode 100644
index 0000000000..2316530c67
--- /dev/null
+++ b/engines/zvision/actions.cpp
@@ -0,0 +1,298 @@
+/* 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 "common/file.h"
+
+#include "audio/decoders/wave.h"
+
+#include "zvision/actions.h"
+#include "zvision/zvision.h"
+#include "zvision/script_manager.h"
+#include "zvision/render_manager.h"
+#include "zvision/action_node.h"
+#include "zvision/zork_raw.h"
+#include "zvision/zork_avi_decoder.h"
+
+namespace ZVision {
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionAdd
+//////////////////////////////////////////////////////////////////////////////
+
+ActionAdd::ActionAdd(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^(](%u,%u)", &_key, &_value);
+}
+
+bool ActionAdd::execute(ZVision *engine) {
+	engine->getScriptManager()->addToStateValue(_key, _value);
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionAssign
+//////////////////////////////////////////////////////////////////////////////
+
+ActionAssign::ActionAssign(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^(](%u, %u)", &_key, &_value);
+}
+
+bool ActionAssign::execute(ZVision *engine) {
+	engine->getScriptManager()->setStateValue(_key, _value);
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionAttenuate
+//////////////////////////////////////////////////////////////////////////////
+
+ActionAttenuate::ActionAttenuate(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^(](%u, %d)", &_key, &_attenuation);
+}
+
+bool ActionAttenuate::execute(ZVision *engine) {
+	// TODO: Implement
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionChangeLocation
+//////////////////////////////////////////////////////////////////////////////
+
+ActionChangeLocation::ActionChangeLocation(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^(](%c,%c,%c%c,%u)", &_world, &_room, &_node, &_view, &_x);
+}
+
+bool ActionChangeLocation::execute(ZVision *engine) {
+	// We can't directly call ScriptManager::ChangeLocationIntern() because doing so clears all the Puzzles, and thus would corrupt the current puzzle checking
+	engine->getScriptManager()->changeLocation(_world, _room, _node, _view, _x);
+	// Tell the puzzle system to stop checking any more puzzles
+	return false;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionCrossfade
+//////////////////////////////////////////////////////////////////////////////
+
+ActionCrossfade::ActionCrossfade(const Common::String &line) {
+	sscanf(line.c_str(),
+           "%*[^(](%u %u %u %u %u %u %u)",
+           &_keyOne, &_keyTwo, &_oneStartVolume, &_twoStartVolume, &_oneEndVolume, &_twoEndVolume, &_timeInMillis);
+}
+
+bool ActionCrossfade::execute(ZVision *engine) {
+	// TODO: Implement
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionMusic
+//////////////////////////////////////////////////////////////////////////////
+
+ActionMusic::ActionMusic(const Common::String &line) : _volume(255) {
+	uint type;
+	char fileNameBuffer[25];
+	uint loop;
+	uint volume = 255;
+
+	sscanf(line.c_str(), "%*[^:]:%*[^:]:%u(%u %25s %u %u)", &_key, &type, fileNameBuffer, &loop, &volume);
+
+	// type 4 are midi sound effect files
+	if (type == 4) {
+		_soundType = Audio::Mixer::kSFXSoundType;
+		_fileName = Common::String::format("midi/%s/%u.wav", fileNameBuffer, loop);
+		_loop = false;
+	} else {
+		// TODO: See what the other types are so we can specify the correct Mixer::SoundType. In the meantime use kPlainSoundType
+		_soundType = Audio::Mixer::kPlainSoundType;
+		_fileName = Common::String(fileNameBuffer);
+		_loop = loop == 1 ? true : false;
+	}
+
+	// Volume is optional. If it doesn't appear, assume full volume
+	if (volume != 255) {
+		// Volume in the script files is mapped to [0, 100], but the ScummVM mixer uses [0, 255]
+		_volume = volume * 255 / 100;
+	}
+}
+
+bool ActionMusic::execute(ZVision *engine) {
+	Audio::RewindableAudioStream *audioStream;
+
+	if (_fileName.contains(".wav")) {
+		Common::File file;
+		if (file.open(_fileName)) {
+			audioStream = Audio::makeWAVStream(&file, DisposeAfterUse::NO);
+		}
+	} else {
+		audioStream = makeRawZorkStream(_fileName, engine);
+	}
+	
+	if (_loop) {
+		Audio::LoopingAudioStream *loopingAudioStream = new Audio::LoopingAudioStream(audioStream, 0, DisposeAfterUse::YES);
+		engine->_mixer->playStream(_soundType, 0, loopingAudioStream, -1, _volume);
+	} else {
+		engine->_mixer->playStream(_soundType, 0, audioStream, -1, _volume);
+	}
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionPreloadAnimation
+//////////////////////////////////////////////////////////////////////////////
+
+ActionPreloadAnimation::ActionPreloadAnimation(const Common::String &line) {
+	char fileName[25];
+
+	// The two %*u are always 0 and dont seem to have a use
+	sscanf(line.c_str(), "%*[^:]:%*[^:]:%u(%25s %*u %*u %u %u)", &_key, fileName, &_mask, &_framerate);
+
+	_fileName = Common::String(fileName);
+}
+
+bool ActionPreloadAnimation::execute(ZVision *engine) {
+	// TODO: Implement
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionPlayAnimation
+//////////////////////////////////////////////////////////////////////////////
+
+ActionPlayAnimation::ActionPlayAnimation(const Common::String &line) {
+	char fileName[25];
+	uint loop;
+
+	// The two %*u are always 0 and dont seem to have a use
+	sscanf(line.c_str(),
+           "%*[^:]:%*[^:]:%u(%25s %u %u %u %u %u %u %u %*u %*u %u %u)",
+           &_key, fileName, &_x, &_y, &_width, &_height, &_start, &_end, &loop, &_mask, &_framerate);
+
+	_fileName = Common::String(fileName);
+	_loop = loop == 1 ? true : false;
+}
+
+bool ActionPlayAnimation::execute(ZVision *engine) {
+	// TODO: Implement
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionQuit
+//////////////////////////////////////////////////////////////////////////////
+
+bool ActionQuit::execute(ZVision *engine) {
+	engine->quitGame();
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionRandom
+//////////////////////////////////////////////////////////////////////////////
+
+ActionRandom::ActionRandom(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^:]:%*[^:]:%u, %u)", &_key, &_max);
+}
+
+bool ActionRandom::execute(ZVision *engine) {
+	uint randNumber = engine->getRandomSource()->getRandomNumber(_max);
+	engine->getScriptManager()->setStateValue(_key, randNumber);
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionSetScreen
+//////////////////////////////////////////////////////////////////////////////
+
+ActionSetScreen::ActionSetScreen(const Common::String &line) {
+	char fileName[25];
+	sscanf(line.c_str(), "%*[^(](%25[^)])", fileName);
+
+	_fileName = Common::String(fileName);
+}
+
+bool ActionSetScreen::execute(ZVision *engine) {
+	RenderManager *renderManager = engine->getRenderManager();
+	renderManager->setBackgroundImage(_fileName);
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionStreamVideo
+//////////////////////////////////////////////////////////////////////////////
+
+ActionStreamVideo::ActionStreamVideo(const Common::String &line) {
+	char fileName[25];
+	uint skippable;
+
+	sscanf(line.c_str(), "%*[^(](%25s %u %u %u %u %u %u)", fileName, &_x1, &_y1, &_x2, &_y2, &_flags, &skippable);
+
+	_fileName = Common::String(fileName);
+	_skippable = (skippable == 0) ? false : true;
+}
+
+bool ActionStreamVideo::execute(ZVision *engine) {
+	ZorkAVIDecoder decoder;
+	if (!decoder.loadFile(_fileName)) {
+		return true;
+	}
+
+	Common::Rect destRect;
+	// 0x1 flags that the destRect dimensions are different from the original video dimensions
+	if ((_flags & 0x1) == 0x1) {
+		destRect = Common::Rect(_x1, _y1, _x2, _y2);
+	}
+
+	engine->playVideo(decoder, destRect, _skippable);
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ActionTimer
+//////////////////////////////////////////////////////////////////////////////
+
+ActionTimer::ActionTimer(const Common::String &line) {
+	sscanf(line.c_str(), "%*[^:]:%*[^:]:%u(%u)", &_key, &_time);
+}
+
+bool ActionTimer::execute(ZVision *engine) {
+	engine->getScriptManager()->addActionNode(Common::SharedPtr<ActionNode>(new NodeTimer(_key, _time)));
+	return true;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/actions.h b/engines/zvision/actions.h
new file mode 100644
index 0000000000..511f3d9b83
--- /dev/null
+++ b/engines/zvision/actions.h
@@ -0,0 +1,316 @@
+/* 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_ACTIONS_H
+#define ZVISION_ACTIONS_H
+
+#include "common/scummsys.h"
+
+#include "audio/mixer.h"
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+// Forward declaration of ZVision. This file is included before ZVision is declared
+class ZVision;
+
+/**
+  * The base class that represents any action that a Puzzle can take.
+  * This class is purely virtual.
+  */
+class ResultAction {
+public:
+	virtual ~ResultAction() {}
+	/**
+	 * This is called by the script system whenever a Puzzle's criteria are found to be true.
+	 * It should execute any necessary actions and return a value indicating whether the script
+	 * system should continue to test puzzles. In 99% of cases this will be 'true'.
+	 *
+	 * @param engine    A pointer to the base engine so the ResultAction can access all the necessary methods
+	 * @return          Should the script system continue to test any remaining puzzles (true) or immediately break and go on to the next frame (false)
+	 */
+	virtual bool execute(ZVision *engine) = 0;
+};
+
+
+// The different types of actions
+// DEBUG,
+// DISABLE_CONTROL,
+// DISABLE_VENUS,
+// DISPLAY_MESSAGE,
+// DISSOLVE,
+// DISTORT,
+// ENABLE_CONTROL,
+// FLUSH_MOUSE_EVENTS,
+// INVENTORY,
+// KILL,
+// MENU_BAR_ENABLE,
+// MUSIC,
+// PAN_TRACK,
+// PLAY_PRELOAD,
+// PREFERENCES,
+// QUIT,
+// RANDOM,
+// REGION,
+// RESTORE_GAME,
+// ROTATE_TO,
+// SAVE_GAME,
+// SET_PARTIAL_SCREEN,
+// SET_SCREEN,
+// SET_VENUS,
+// STOP,
+// STREAM_VIDEO,
+// SYNC_SOUND,
+// TTY_TEXT,
+// UNIVERSE_MUSIC,
+
+class ActionAdd : public ResultAction {
+public:
+	ActionAdd(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	uint _value;
+};
+
+class ActionAssign : public ResultAction {
+public:
+	ActionAssign(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	uint _value;
+};
+
+class ActionAttenuate : public ResultAction {
+public:
+	ActionAttenuate(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	int _attenuation;
+};
+
+class ActionChangeLocation : public ResultAction {
+public:
+	ActionChangeLocation(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	char _world;
+	char _room;
+	char _node;
+	char _view;
+	uint32 _x;
+};
+
+class ActionCrossfade : public ResultAction {
+public:
+	ActionCrossfade(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _keyOne;
+	uint32 _keyTwo;
+	uint _oneStartVolume;
+	uint _twoStartVolume;
+	uint _oneEndVolume;
+	uint _twoEndVolume;
+	uint _timeInMillis;
+};
+
+class ActionDebug : public ResultAction {
+public:
+	ActionDebug(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionDelayRender : public ResultAction {
+public:
+	ActionDelayRender(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	// TODO: Check if this should actually be frames or if it should be milliseconds/seconds
+	uint32 framesToDelay;
+};
+
+class ActionDisableControl : public ResultAction {
+public:
+	ActionDisableControl(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionDisableVenus : public ResultAction {
+public:
+	ActionDisableVenus(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionDisplayMessage : public ResultAction {
+public:
+	ActionDisplayMessage(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionDissolve : public ResultAction {
+public:
+	ActionDissolve(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionDistort : public ResultAction {
+public:
+	ActionDistort(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionEnableControl : public ResultAction {
+public:
+	ActionEnableControl(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+};
+
+class ActionMusic : public ResultAction {
+public:
+	ActionMusic(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	Audio::Mixer::SoundType _soundType;
+	Common::String _fileName;
+	bool _loop;
+	byte _volume;
+};
+
+class ActionPlayAnimation : public ResultAction {
+public:
+	ActionPlayAnimation(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	Common::String _fileName;
+	uint32 _x;
+	uint32 _y;
+	uint32 _width;
+	uint32 _height;
+	uint32 _start;
+	uint32 _end;
+	uint _mask;
+	uint _framerate;
+	bool _loop;
+};
+
+class ActionPreloadAnimation : public ResultAction {
+public:
+	ActionPreloadAnimation(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	Common::String _fileName;
+	uint _mask;
+	uint _framerate;
+};
+
+class ActionQuit : public ResultAction {
+public:
+	ActionQuit() {}
+	bool execute(ZVision *engine);
+};
+
+// TODO: See if this exists in ZGI. It doesn't in ZNem
+class ActionUnloadAnimation : public ResultAction {
+public:
+	ActionUnloadAnimation(const Common::String &line);
+	bool execute(ZVision *engine);
+};
+
+class ActionRandom : public ResultAction {
+public:
+	ActionRandom(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	uint _max;
+};
+
+class ActionSetScreen : public ResultAction {
+public:
+	ActionSetScreen(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	Common::String _fileName;
+};
+
+class ActionStreamVideo : public ResultAction {
+public:
+	ActionStreamVideo(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	Common::String _fileName;
+	uint _x1;
+	uint _y1;
+	uint _x2;
+	uint _y2;
+	uint _flags;
+	bool _skippable;
+};
+
+class ActionTimer : public ResultAction {
+public:
+	ActionTimer(const Common::String &line);
+	bool execute(ZVision *engine);
+
+private:
+	uint32 _key;
+	uint _time;
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/clock.cpp b/engines/zvision/clock.cpp
new file mode 100644
index 0000000000..fe322525f8
--- /dev/null
+++ b/engines/zvision/clock.cpp
@@ -0,0 +1,69 @@
+/* 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 "common/system.h"
+
+#include "zvision/clock.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/clock.h b/engines/zvision/clock.h
new file mode 100644
index 0000000000..3939ba1612
--- /dev/null
+++ b/engines/zvision/clock.h
@@ -0,0 +1,78 @@
+/* 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/console.cpp b/engines/zvision/console.cpp
new file mode 100644
index 0000000000..f1b192fce1
--- /dev/null
+++ b/engines/zvision/console.cpp
@@ -0,0 +1,207 @@
+/* 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 "common/system.h"
+#include "gui/debugger.h"
+#include "common/file.h"
+#include "common/bufferedstream.h"
+#include "audio/mixer.h"
+
+#include "zvision/console.h"
+#include "zvision/zvision.h"
+#include "zvision/script_manager.h"
+#include "zvision/render_manager.h"
+#include "zvision/zork_avi_decoder.h"
+#include "zvision/zork_raw.h"
+#include "zvision/utility.h"
+#include "zvision/cursor.h"
+
+
+namespace ZVision {
+
+Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
+	DCmd_Register("loadimage", WRAP_METHOD(Console, cmdLoadImage));
+	DCmd_Register("loadvideo", WRAP_METHOD(Console, cmdLoadVideo));
+	DCmd_Register("loadsound", WRAP_METHOD(Console, cmdLoadSound));
+	DCmd_Register("raw2wav", WRAP_METHOD(Console, cmdRawToWav));
+	DCmd_Register("setrenderstate", WRAP_METHOD(Console, cmdSetRenderState));
+	DCmd_Register("generaterendertable", WRAP_METHOD(Console, cmdGenerateRenderTable));
+	DCmd_Register("setpanoramafov", WRAP_METHOD(Console, cmdSetPanoramaFoV));
+	DCmd_Register("setpanoramascale", WRAP_METHOD(Console, cmdSetPanoramaScale));
+	DCmd_Register("changelocation", WRAP_METHOD(Console, cmdChangeLocation));
+	DCmd_Register("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
+	DCmd_Register("dumpcursorfilenames", WRAP_METHOD(Console, cmdDumpAllCursorFileNames));
+	DCmd_Register("showcursor", WRAP_METHOD(Console, cmdShowCursor));
+}
+
+bool Console::cmdLoadImage(int argc, const char **argv) {
+	if (argc == 4)
+		_engine->getRenderManager()->renderImageToScreen(argv[1], atoi(argv[2]), atoi(argv[3]));
+	else if (argc == 8)
+		_engine->getRenderManager()->renderImageToScreen(argv[1], atoi(argv[2]), atoi(argv[3]), Common::Rect(atoi(argv[4]), atoi(argv[5]), atoi(argv[6]), atoi(argv[7])));
+	else {
+		DebugPrintf("Use loadimage <fileName> <destinationX> <destinationY> [ <subRectX1> <subRectY2> <subRectX2> <subRectY2> ] to load an image to the screen\n");
+		return true;
+	}
+
+	return true;
+}
+
+bool Console::cmdLoadVideo(int argc, const char **argv) {
+	if (argc != 2) {
+		DebugPrintf("Use loadvideo <fileName> to load a video to the screen\n");
+		return true;
+	}
+
+	ZorkAVIDecoder videoDecoder;
+	if (videoDecoder.loadFile(argv[1])) {
+		_engine->playVideo(videoDecoder);
+	}
+
+	return true;
+}
+
+bool Console::cmdLoadSound(int argc, const char **argv) {
+	if (argc != 2) {
+		DebugPrintf("Use loadsound <fileName> to load a sound\n");
+		return true;
+	}
+
+	if (!Common::File::exists(argv[1])) {
+		DebugPrintf("File does not exist\n");
+		return true;
+	}
+
+	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);
+
+	return true;
+}
+
+bool Console::cmdRawToWav(int argc, const char **argv) {
+	if (argc != 3) {
+		DebugPrintf("Use raw2wav <rawFilePath> <wavFileName> to dump a .RAW file to .WAV\n");
+		return true;
+	}
+
+	convertRawToWav(argv[1], _engine, argv[2]);
+	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");
+		return true;
+	}
+
+	Common::String renderState(argv[1]);
+
+	if (renderState.matchString("panorama", true))
+		_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::PANORAMA);
+	else if (renderState.matchString("tilt", true))
+		_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::TILT);
+	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");
+
+	return true;
+}
+
+bool Console::cmdGenerateRenderTable(int argc, const char **argv) {
+	_engine->getRenderManager()->getRenderTable()->generateRenderTable();
+
+	return true;
+}
+
+bool Console::cmdSetPanoramaFoV(int argc, const char **argv) {
+	if (argc != 2) {
+		DebugPrintf("Use setpanoramafov <fieldOfView> to change the current panorama field of view\n");
+		return true;
+	}
+
+	_engine->getRenderManager()->getRenderTable()->setPanoramaFoV(atof(argv[1]));
+
+	return true;
+}
+
+bool Console::cmdSetPanoramaScale(int argc, const char **argv) {
+	if (argc != 2) {
+		DebugPrintf("Use setpanoramascale <scale> to change the current panorama scale\n");
+		return true;
+	}
+
+	_engine->getRenderManager()->getRenderTable()->setPanoramaScale(atof(argv[1]));
+
+	return true;
+}
+
+bool Console::cmdChangeLocation(int argc, const char **argv) {
+	if (argc != 6) {
+		DebugPrintf("Use changelocation <char: world> <char: room> <char:node> <char:view> <int: x position> to change your location");
+		return true;
+	}
+
+	_engine->getScriptManager()->changeLocation(*(argv[1]), *(argv[2]), *(argv[3]), *(argv[4]), atoi(argv[5]));
+
+	return true;
+}
+
+bool Console::cmdDumpFile(int argc, const char **argv) {
+	if (argc != 2) {
+		DebugPrintf("Use dumpfile <fileName> to dump a file");
+		return true;
+	}
+
+	writeFileContentsToFile(argv[1], argv[1]);
+
+	return true;
+}
+
+bool Console::cmdDumpAllCursorFileNames(int argc, const char **argv) {
+	Common::DumpFile outputFile;
+	outputFile.open("cursorFileNames.txt");
+	
+	Common::ArchiveMemberList list;
+	SearchMan.listMatchingMembers(list, "*.zcr");
+
+	// Register the file entries within the zfs archives with the SearchMan
+	for (Common::ArchiveMemberList::iterator iter = list.begin(); iter != list.end(); ++iter) {
+		outputFile.writeString((*iter)->getName());
+		outputFile.writeByte('\n');
+	}
+
+	return true;
+}
+
+bool Console::cmdShowCursor(int argc, const char **argv) {
+	ZorkCursor cursor(argv[1]);
+
+	_engine->_system->copyRectToScreen(cursor.getSurface(), cursor.getWidth() * 2, 0, 0, cursor.getWidth(), cursor.getHeight());
+
+	return true;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/console.h b/engines/zvision/console.h
new file mode 100644
index 0000000000..995c41881e
--- /dev/null
+++ b/engines/zvision/console.h
@@ -0,0 +1,55 @@
+/* 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_CONSOLE_H
+#define ZVISION_CONSOLE_H
+
+#include "gui/debugger.h"
+
+namespace ZVision {
+
+class ZVision;
+
+class Console : public GUI::Debugger {
+public:
+	Console(ZVision *engine);
+	virtual ~Console() {}
+
+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);
+	bool cmdSetRenderState(int argc, const char **argv);
+	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 cmdDumpFile(int argc, const char **argv);
+	bool cmdDumpAllCursorFileNames(int argc, const char **argv);
+	bool cmdShowCursor(int argc, const char **argv);
+};
+
+} // End of namespace ZVision
+#endif
diff --git a/engines/zvision/control.cpp b/engines/zvision/control.cpp
new file mode 100644
index 0000000000..02d15fe9d0
--- /dev/null
+++ b/engines/zvision/control.cpp
@@ -0,0 +1,140 @@
+/* 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 "common/stream.h"
+
+#include "zvision/zvision.h"
+#include "zvision/render_manager.h"
+#include "zvision/render_table.h"
+#include "zvision/control.h"
+#include "zvision/utility.h"
+
+namespace ZVision {
+
+void Control::parseFlatControl(ZVision *engine) {
+	engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::FLAT);
+}
+
+void Control::parsePanoramaControl(ZVision *engine, Common::SeekableReadStream &stream) {
+	RenderTable *renderTable = engine->getRenderManager()->getRenderTable();
+	renderTable->setRenderState(RenderTable::PANORAMA);
+
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	while (!line.contains('}')) {
+		if (line.matchString("angle*", true)) {
+			float fov;
+			sscanf(line.c_str(), "angle(%f)", &fov);
+			renderTable->setPanoramaFoV(fov);
+		} else if (line.matchString("linscale*", true)) {
+			float scale;
+			sscanf(line.c_str(), "linscale(%f)", &scale);
+			renderTable->setPanoramaScale(scale);
+		} else if (line.matchString("reversepana*", true)) {
+			uint reverse;
+			sscanf(line.c_str(), "reversepana(%u)", &reverse);
+			if (reverse == 1) {
+				renderTable->setPanoramaReverse(true);
+			}
+		} else if (line.matchString("zeropoint*", true)) {
+			// TODO: Implement
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	renderTable->generateRenderTable();
+}
+
+void Control::parseTiltControl(ZVision *engine, Common::SeekableReadStream &stream) {
+	RenderTable *renderTable = engine->getRenderManager()->getRenderTable();
+	renderTable->setRenderState(RenderTable::TILT);
+
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	while (!line.contains('}')) {
+		if (line.matchString("angle*", true)) {
+			float fov;
+			sscanf(line.c_str(), "angle(%f)", &fov);
+			renderTable->setTiltFoV(fov);
+		} else if (line.matchString("linscale*", true)) {
+			float scale;
+			sscanf(line.c_str(), "linscale(%f)", &scale);
+			renderTable->setTiltScale(scale);
+		} else if (line.matchString("reversepana*", true)) {
+			uint reverse;
+			sscanf(line.c_str(), "reversepana(%u)", &reverse);
+			if (reverse == 1) {
+				renderTable->setTiltReverse(true);
+			}
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	renderTable->generateRenderTable();
+}
+
+void Control::parsePushToggleControl(uint32 key, ZVision *engine, Common::SeekableReadStream &stream) {
+	Common::Rect hotspot;
+	Common::String cursorName;
+	
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	while (!line.contains('}')) {
+		if (line.matchString("*_hotspot*", true)) {
+			uint x;
+			uint y;
+			uint width;
+			uint height;
+
+			sscanf(line.c_str(), "%*[^(](%u,%u,%u,%u)", &x, &y, &width, &height);
+			
+			hotspot = Common::Rect(x, y, x + width, y + height);
+		} else if (line.matchString("cursor*", true)) {
+			char nameBuffer[25];
+
+			sscanf(line.c_str(), "%*[^(](%25[^)])", nameBuffer);
+
+			cursorName = Common::String(nameBuffer);
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	if (!hotspot.isEmpty() && !cursorName.empty()) {
+		engine->registerMouseEvent(MouseEvent(key, hotspot, cursorName));
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/control.h b/engines/zvision/control.h
new file mode 100644
index 0000000000..2d5426c0c4
--- /dev/null
+++ b/engines/zvision/control.h
@@ -0,0 +1,54 @@
+/* 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_CONTROL_H
+#define ZVISION_CONTROL_H
+
+#include "common/types.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace ZVision {
+
+class ZVision;
+
+class Control {
+public:
+	virtual ~Control() {}
+	virtual bool execute(ZVision *engine) = 0;
+
+protected:
+	uint32 key;
+
+// Static member functions
+public:
+	static void parseFlatControl(ZVision *engine);
+	static void parsePanoramaControl(ZVision *engine, Common::SeekableReadStream &stream);
+	static void parseTiltControl(ZVision *engine, Common::SeekableReadStream &stream);
+	static void parsePushToggleControl(uint32 key, ZVision *engine, Common::SeekableReadStream &stream);
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/cursor.cpp b/engines/zvision/cursor.cpp
new file mode 100644
index 0000000000..601c58fa2c
--- /dev/null
+++ b/engines/zvision/cursor.cpp
@@ -0,0 +1,100 @@
+/* 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 "common/str.h"
+#include "common/file.h"
+
+#include "zvision/cursor.h"
+
+
+namespace ZVision {
+
+ZorkCursor::ZorkCursor() 
+	: _width(0),
+	  _height(0),
+	  _hotspotX(0),
+	  _hotspotY(0),
+	  _surface(0) {
+}
+
+ZorkCursor::ZorkCursor(const Common::String &fileName) 
+		: _width(0),
+		  _height(0),
+		  _hotspotX(0),
+		  _hotspotY(0),
+		  _surface(0) {
+	Common::File file;
+	if (!file.open(fileName))
+		return;
+
+	uint32 magic = file.readUint32BE();
+	if (magic != MKTAG('Z', 'C', 'R', '1')) {
+		warning("%s is not a Zork Cursor file", fileName.c_str());
+		return;
+	}
+
+	_hotspotX = file.readUint16LE();
+	_hotspotY = file.readUint16LE();
+	_width = file.readUint16LE();
+	_height = file.readUint16LE();
+
+	uint dataSize = _width * _height * 2;
+	_surface = new byte[dataSize];
+	uint32 bytesRead = file.read(_surface, dataSize);
+	assert(bytesRead == dataSize);
+}
+
+ZorkCursor::ZorkCursor(const ZorkCursor &other) {
+	_width = other._width;
+	_height = other._height;
+	_hotspotX = other._hotspotX;
+	_hotspotY = other._hotspotY;
+
+	uint dataSize = _width * _height * 2;
+	_surface = new byte[dataSize];
+
+	memcpy(_surface, other._surface, dataSize);
+}
+
+ZorkCursor &ZorkCursor::operator=(const ZorkCursor &other) {
+	_width = other._width;
+	_height = other._height;
+	_hotspotX = other._hotspotX;
+	_hotspotY = other._hotspotY;
+
+	uint dataSize = _width * _height * 2;
+	_surface = new byte[dataSize];
+
+	memcpy(_surface, other._surface, dataSize);
+
+	return *this;
+}
+
+ZorkCursor::~ZorkCursor() {
+	if (_surface != 0) {
+		delete[] _surface;
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/cursor.h b/engines/zvision/cursor.h
new file mode 100644
index 0000000000..9a561fcac3
--- /dev/null
+++ b/engines/zvision/cursor.h
@@ -0,0 +1,67 @@
+/* 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_CURSOR_H
+#define ZVISION_CURSOR_H
+
+#include "common/types.h"
+
+#include "graphics/cursor.h"
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+/** 
+ * Utility class to parse and hold cursor data
+ * Modeled off Graphics::Cursor
+ */
+class ZorkCursor {
+public:
+	ZorkCursor();
+	ZorkCursor(const Common::String &fileName);
+	ZorkCursor(const ZorkCursor &other);
+	~ZorkCursor();
+
+private:
+	uint16 _width;
+	uint16 _height;
+	uint16 _hotspotX;
+	uint16 _hotspotY;
+	byte *_surface;
+
+public:
+	ZorkCursor &operator=(const ZorkCursor &other);
+
+	uint16 getWidth() const { return _width; }
+	uint16 getHeight() const { return _height; }
+	uint16 getHotspotX() const { return _hotspotX; }
+	uint16 getHotspotY() const { return _hotspotY; }
+	byte getKeyColor() const { return 0; }
+	const byte *getSurface() const { return _surface; }
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/cursor_manager.cpp b/engines/zvision/cursor_manager.cpp
new file mode 100644
index 0000000000..50fa5031b2
--- /dev/null
+++ b/engines/zvision/cursor_manager.cpp
@@ -0,0 +1,149 @@
+/* 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 "common/system.h"
+#include "graphics/pixelformat.h"
+#include "graphics/cursorman.h"
+
+#include "zvision/zvision.h"
+#include "zvision/cursor_manager.h"
+
+
+namespace ZVision {
+
+const char *CursorManager::_cursorNames[NUM_CURSORS] = { "active", "arrow", "backward", "downarrow", "forward", "handpt", "handpu", "hdown", "hleft",
+                                                         "hright", "hup", "idle", "leftarrow", "rightarrow", "suggest_surround", "suggest_tilt", "turnaround", "zuparrow" };
+
+const char *CursorManager::_zgiCursorFileNames[NUM_CURSORS] = { "g0gbc011.zcr", "g0gac001.zcr", "g0gac021.zcr", "g0gac031.zcr", "g0gac041.zcr", "g0gac051.zcr", "g0gac061.zcr", "g0gac071.zcr", "g0gac081.zcr",
+                                                                "g0gac091.zcr", "g0gac101.zcr", "g0gac011.zcr", "g0gac111.zcr", "g0gac121.zcr", "g0gac131.zcr", "g0gac141.zcr", "g0gac151.zcr", "g0gac161.zcr" };
+
+const char *CursorManager::_zNemCursorFileNames[NUM_CURSORS] = { "00act", "arrow", "back", "down", "forw", "handpt", "handpu", "hdown", "hleft",
+                                                                 "hright", "hup", "00idle", "left", "right", "ssurr", "stilt", "turn", "up" };
+
+
+CursorManager::CursorManager(ZVision *engine, const Graphics::PixelFormat *pixelFormat)
+		: _engine(engine),
+		  _pixelFormat(pixelFormat),
+		  _cursorIsPushed(false) {
+	// WARNING: The index IDLE_CURSOR_INDEX is hardcoded. If you change the order of _cursorNames/_zgiCursorFileNames/_zNemCursorFileNames, you HAVE to change the index accordingly
+	if (_engine->getGameId() == ZorkNemesis) {
+		Common::String name(Common::String::format("%sa.zcr", _zNemCursorFileNames[IDLE_CURSOR_INDEX]));
+		_idleCursor = ZorkCursor(name);
+	} else if (_engine->getGameId() == ZorkGrandInquisitor) {
+		_idleCursor = ZorkCursor(_zgiCursorFileNames[IDLE_CURSOR_INDEX]);
+	}
+}
+
+void CursorManager::initialize() {
+	revertToIdle();
+	CursorMan.showMouse(true);
+}
+
+void CursorManager::changeCursor(const Common::String &cursorName) {
+	changeCursor(cursorName, _cursorIsPushed);
+}
+
+void CursorManager::changeCursor(const Common::String &cursorName, bool pushed) {
+	if (_currentCursor.equals(cursorName) && _cursorIsPushed == pushed)
+		return;
+
+	if (_cursorIsPushed != pushed)
+		_cursorIsPushed = pushed;
+
+	if (cursorName == "idle" && !pushed) {
+		CursorMan.replaceCursor(_idleCursor.getSurface(), _idleCursor.getWidth(), _idleCursor.getHeight(), _idleCursor.getHotspotX(), _idleCursor.getHotspotY(), _idleCursor.getKeyColor(), false, _pixelFormat);
+		return;
+	}
+
+	for (int i = 0; i < NUM_CURSORS; i++) {
+		if (_engine->getGameId() == ZorkNemesis) {
+			if (cursorName.equals(_cursorNames[i])) {
+				_currentCursor = cursorName;
+
+				// ZNem uses a/b at the end of the file to signify not pushed/pushed respectively
+				Common::String pushedFlag = pushed ? "b" : "a";
+				Common::String name = Common::String::format("%s%s.zcr", _zNemCursorFileNames[i], pushedFlag.c_str());
+
+				changeCursor(ZorkCursor(name));
+				return;
+			}
+		} else if (_engine->getGameId() == ZorkGrandInquisitor) {
+			if (cursorName.equals(_cursorNames[i])) {
+				_currentCursor = cursorName;
+
+				if (!pushed) {
+					changeCursor(ZorkCursor(_zgiCursorFileNames[i]));
+				} else {
+					// ZGI flips not pushed/pushed between a/c and b/d
+					// It flips the 4th character of the name
+					char buffer[25];
+					strcpy(buffer, _zgiCursorFileNames[i]);
+					buffer[3] += 2;
+				}
+				return;
+			}
+		}
+	}
+
+	// If we get here, something went wrong
+	warning("No cursor found for identifier %s", cursorName.c_str());
+}
+
+void CursorManager::changeCursor(const ZorkCursor &cursor) {
+	CursorMan.replaceCursor(cursor.getSurface(), cursor.getWidth(), cursor.getHeight(), cursor.getHotspotX(), cursor.getHotspotY(), cursor.getKeyColor(), false, _pixelFormat);
+}
+
+void CursorManager::cursorDown(bool pushed) {
+	if (_cursorIsPushed == pushed)
+		return;
+
+	_cursorIsPushed = pushed;
+	changeCursor(_currentCursor, pushed);
+}
+
+void CursorManager::setLeftCursor() {
+	changeCursor("leftarrow");
+}
+
+void CursorManager::setRightCursor() {
+	changeCursor("rightarrow");
+}
+
+void CursorManager::setUpCursor() {
+	changeCursor("zuparrow");
+}
+
+void CursorManager::setDownCursor() {
+	changeCursor("downarrow");
+}
+
+void CursorManager::revertToIdle() {
+	_currentCursor = "idle";
+	if (!_cursorIsPushed)
+		CursorMan.replaceCursor(_idleCursor.getSurface(), _idleCursor.getWidth(), _idleCursor.getHeight(), _idleCursor.getHotspotX(), _idleCursor.getHotspotY(), _idleCursor.getKeyColor(), false, _pixelFormat);
+	else
+		changeCursor(_currentCursor, _cursorIsPushed);
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/cursor_manager.h b/engines/zvision/cursor_manager.h
new file mode 100644
index 0000000000..1c09620b7e
--- /dev/null
+++ b/engines/zvision/cursor_manager.h
@@ -0,0 +1,114 @@
+/* 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_CURSOR_MANAGER_H
+#define ZVISION_CURSOR_MANAGER_H
+
+#include "common/types.h"
+
+#include "zvision/cursor.h"
+
+
+namespace Graphics {
+struct PixelFormat;
+}
+
+namespace ZVision {
+
+class ZVision;
+
+/**
+ * Class to manage cursor changes. The actual changes have to be done
+ * through CursorMan. Otherwise the cursor will disappear after GMM
+ * or debug console.
+ * TODO: Figure out a way to get rid of the extraneous data copying due to having to use CursorMan
+ */
+class CursorManager {
+public:
+	CursorManager(ZVision *engine, const Graphics::PixelFormat *pixelFormat);
+
+private:
+	enum {
+		NUM_CURSORS = 18,
+		// WARNING: The index 11 is hardcoded. If you change the order of _cursorNames/_zgiCursorFileNames/_zNemCursorFileNames, you HAVE to change the index accordingly
+		IDLE_CURSOR_INDEX = 11
+	};
+
+	ZVision *_engine;
+	const Graphics::PixelFormat *_pixelFormat;
+	ZorkCursor _idleCursor;
+	Common::String _currentCursor;
+	bool _cursorIsPushed;
+
+	static const char *_cursorNames[];
+	static const char *_zgiCursorFileNames[];
+	static const char *_zNemCursorFileNames[];
+
+public:
+	/** Creates the idle cursor and shows it */
+	void initialize();
+
+	/**
+	 * Parses a cursor name into a cursor file then creates and shows that cursor.
+	 * It will use the current _isCursorPushed state to choose the correct cursor
+	 *
+	 * @param cursorName    The name of a cursor. This *HAS* to correspond to one of the entries in _cursorNames[]
+	 */
+	void changeCursor(const Common::String &cursorName);
+	/**
+	 * Parses a cursor name into a cursor file then creates and shows that cursor.
+	 *
+	 * @param cursorName    The name of a cursor. This *HAS* to correspond to one of the entries in _cursorNames[] 
+	 * @param pushed        Should the cursor be pushed (true) or not pushed (false) (Another way to say it: down or up)
+	 */
+	void changeCursor(const Common::String &cursorName, bool pushed);
+	/**
+	 * Change the cursor to a certain push state. If the cursor is already in the specified push state, nothing will happen.
+	 *
+	 * @param pushed    Should the cursor be pushed (true) or not pushed (false) (Another way to say it: down or up)
+	 */
+	void cursorDown(bool pushed);
+
+	/** Set the cursor to 'Left Arrow'. It will retain the current _isCursorPushed state */
+	void setLeftCursor();
+	/** Set the cursor to 'Right Arrow'. It will retain the current _isCursorPushed state */
+	void setRightCursor();
+	/** Set the cursor to 'Up Arrow'. It will retain the current _isCursorPushed state */
+	void setUpCursor();
+	/** Set the cursor to 'Down Arrow'. It will retain the current _isCursorPushed state */
+	void setDownCursor();
+
+	/** Set the cursor to 'Idle'. It will retain the current _isCursorPushed state */
+	void revertToIdle();
+
+private:
+	/**
+	 * Calls CursorMan.replaceCursor() using the data in cursor
+	 *
+	 * @param cursor    The cursor to show
+	 */
+	void changeCursor(const ZorkCursor &cursor);
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/detection.cpp b/engines/zvision/detection.cpp
new file mode 100644
index 0000000000..d9bb692f07
--- /dev/null
+++ b/engines/zvision/detection.cpp
@@ -0,0 +1,270 @@
+/* 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 "base/plugins.h"
+
+#include "common/translation.h"
+#include "common/savefile.h"
+#include "common/str-array.h"
+#include "common/system.h"
+
+#include "zvision/zvision.h"
+#include "zvision/detection.h"
+
+
+namespace ZVision {
+
+uint32 ZVision::getFeatures() const {
+	return _gameDescription->desc.flags;
+}
+
+Common::Language ZVision::getLanguage() const {
+	return _gameDescription->desc.language;
+}
+
+} // End of namespace ZVision
+
+
+static const PlainGameDescriptor zVisionGames[] = {
+	{"zvision",  "ZVision Game"},
+	{"znemesis", "Zork Nemesis: The Forbidden Lands"},
+	{"zgi",      "Zork: Grand Inquisitor"},
+	{0, 0}
+};
+
+
+namespace ZVision {
+
+static const ZVisionGameDescription gameDescriptions[] = {
+
+	{
+		// Zork Nemesis English version
+		{
+			"znemesis",
+			0,
+			AD_ENTRY1s("CSCR.ZFS", "88226e51a205d2e50c67a5237f3bd5f2", 2397741),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NONE)
+		},
+		ZorkNemesis
+	},
+
+	{
+		// Zork Grand Inquisitor English version
+		{
+			"zgi",
+			0,
+			AD_ENTRY1s("SCRIPTS.ZFS", "81efd40ecc3d22531e211368b779f17f", 8336944),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NONE)
+		},
+		ZorkGrandInquisitor
+	},
+
+	{
+		AD_TABLE_END_MARKER,
+		None
+	}
+};
+
+} // End of namespace ZVision
+
+static const char *directoryGlobs[] = {
+	"znemscr",
+	0
+};
+
+static const ExtraGuiOption ZVisionExtraGuiOption = {
+	_s("Use original save/load screens"),
+	_s("Use the original save/load screens, instead of the ScummVM ones"),
+	"originalsaveload",
+	false
+};
+
+class ZVisionMetaEngine : public AdvancedMetaEngine {
+public:
+	ZVisionMetaEngine() : AdvancedMetaEngine(ZVision::gameDescriptions, sizeof(ZVision::ZVisionGameDescription), zVisionGames) {
+		_maxScanDepth = 2;
+		_directoryGlobs = directoryGlobs;
+		_singleid = "zvision";
+	}
+
+	virtual const char *getName() const {
+		return "ZVision";
+	}
+
+	virtual const char *getOriginalCopyright() const {
+		return "ZVision Activision (C) 1996";
+	}
+
+	virtual bool hasFeature(MetaEngineFeature f) const;
+	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+	virtual const ExtraGuiOptions getExtraGuiOptions(const Common::String &target) const;
+	SaveStateList listSaves(const char *target) const;
+	virtual int getMaximumSaveSlot() const;
+	void removeSaveState(const char *target, int slot) const;
+	SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+};
+
+bool ZVisionMetaEngine::hasFeature(MetaEngineFeature f) const {
+	return false;
+		/*
+		(f == kSupportsListSaves) ||
+		(f == kSupportsLoadingDuringStartup) ||
+		(f == kSupportsDeleteSave) ||
+		(f == kSavesSupportMetaInfo) ||
+		(f == kSavesSupportThumbnail) ||
+		(f == kSavesSupportCreationDate) ||
+		(f == kSavesSupportPlayTime);
+		*/
+}
+
+/*bool ZVision::ZVision::hasFeature(EngineFeature f) const {
+	return
+		(f == kSupportsRTL) ||
+		(f == kSupportsLoadingDuringRuntime) ||
+		(f == kSupportsSavingDuringRuntime);
+}*/
+
+bool ZVisionMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+	const ZVision::ZVisionGameDescription *gd = (const ZVision::ZVisionGameDescription *)desc;
+	if (gd) {
+		*engine = new ZVision::ZVision(syst, gd);
+	}
+	return gd != 0;
+}
+
+const ExtraGuiOptions ZVisionMetaEngine::getExtraGuiOptions(const Common::String &target) const {
+	ExtraGuiOptions options;
+	options.push_back(ZVisionExtraGuiOption);
+	return options;
+}
+
+SaveStateList ZVisionMetaEngine::listSaves(const char *target) const {
+	//Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	/*ZVision::ZVision::SaveHeader header;
+	Common::String pattern = target;
+	pattern += ".???";
+
+	Common::StringArray filenames;
+	filenames = saveFileMan->listSavefiles(pattern.c_str());
+	Common::sort(filenames.begin(), filenames.end());	// Sort (hopefully ensuring we are sorted numerically..)*/
+
+	SaveStateList saveList;
+/*	for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); file++) {
+		// Obtain the last 3 digits of the filename, since they correspond to the save slot
+		int slotNum = atoi(file->c_str() + file->size() - 3);
+
+		if (slotNum >= 0 && slotNum <= 999) {
+			Common::InSaveFile *in = saveFileMan->openForLoading(file->c_str());
+			if (in) {
+				if (ZVision::ZVision::readSaveHeader(in, false, header) == ZVision::ZVision::kRSHENoError) {
+					saveList.push_back(SaveStateDescriptor(slotNum, header.description));
+				}
+				delete in;
+			}
+		}
+	}*/
+
+	return saveList;
+}
+
+int ZVisionMetaEngine::getMaximumSaveSlot() const {
+	return 999;
+}
+
+void ZVisionMetaEngine::removeSaveState(const char *target, int slot) const {
+	/*
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::String filename = ZVision::ZVision::getSavegameFilename(target, slot);
+
+	saveFileMan->removeSavefile(filename.c_str());
+
+	Common::StringArray filenames;
+	Common::String pattern = target;
+	pattern += ".???";
+	filenames = saveFileMan->listSavefiles(pattern.c_str());
+	Common::sort(filenames.begin(), filenames.end());	// Sort (hopefully ensuring we are sorted numerically..)
+
+	for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+		// Obtain the last 3 digits of the filename, since they correspond to the save slot
+		int slotNum = atoi(file->c_str() + file->size() - 3);
+
+		// Rename every slot greater than the deleted slot,
+		if (slotNum > slot) {
+			saveFileMan->renameSavefile(file->c_str(), filename.c_str());
+			filename = ZVision::ZVision::getSavegameFilename(target, ++slot);
+		}
+	}
+	*/
+}
+
+SaveStateDescriptor ZVisionMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+	/*
+	Common::String filename = ZVision::ZVision::getSavegameFilename(target, slot);
+	Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(filename.c_str());
+
+	if (in) {
+		ZVision::ZVision::SaveHeader header;
+		ZVision::ZVision::kReadSaveHeaderError error;
+
+		error = ZVision::ZVision::readSaveHeader(in, true, header);
+		delete in;
+
+		if (error == ZVision::ZVision::kRSHENoError) {
+			SaveStateDescriptor desc(slot, header.description);
+
+			desc.setThumbnail(header.thumbnail);
+
+			if (header.version > 0) {
+				int day = (header.saveDate >> 24) & 0xFF;
+				int month = (header.saveDate >> 16) & 0xFF;
+				int year = header.saveDate & 0xFFFF;
+
+				desc.setSaveDate(year, month, day);
+
+				int hour = (header.saveTime >> 16) & 0xFF;
+				int minutes = (header.saveTime >> 8) & 0xFF;
+
+				desc.setSaveTime(hour, minutes);
+
+				desc.setPlayTime(header.playTime * 1000);
+			}
+
+			return desc;
+		}
+	}
+	*/
+
+	return SaveStateDescriptor();
+}
+
+#if PLUGIN_ENABLED_DYNAMIC(ZVISION)
+	REGISTER_PLUGIN_DYNAMIC(ZVISION, PLUGIN_TYPE_ENGINE, ZVisionMetaEngine);
+#else
+	REGISTER_PLUGIN_STATIC(ZVISION, PLUGIN_TYPE_ENGINE, ZVisionMetaEngine);
+#endif
diff --git a/engines/zvision/detection.h b/engines/zvision/detection.h
new file mode 100644
index 0000000000..f08cfd2fe1
--- /dev/null
+++ b/engines/zvision/detection.h
@@ -0,0 +1,43 @@
+/* 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_DETECTION_H
+#define ZVISION_DETECTION_H
+
+#include "engines/advancedDetector.h"
+
+namespace ZVision {
+
+enum ZVisionGameId {
+	None = 0,
+	ZorkNemesis = 1,
+	ZorkGrandInquisitor = 2
+};
+
+struct ZVisionGameDescription {
+	ADGameDescription desc;
+	ZVisionGameId gameId;
+};
+
+}
+
+#endif
diff --git a/engines/zvision/events.cpp b/engines/zvision/events.cpp
new file mode 100644
index 0000000000..ca96f52457
--- /dev/null
+++ b/engines/zvision/events.cpp
@@ -0,0 +1,204 @@
+/* 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/zvision.h"
+#include "zvision/console.h"
+#include "common/events.h"
+#include "engines/util.h"
+#include "common/system.h"
+#include "common/rational.h"
+
+#include "zvision/cursor_manager.h"
+#include "zvision/render_manager.h"
+#include "zvision/mouse_event.h"
+
+namespace ZVision {
+
+void ZVision::registerMouseEvent(const MouseEvent &event) {
+	_mouseEvents.push_back(event);
+}
+
+void ZVision::clearAllMouseEvents() {
+	_mouseEvents.clear();
+}
+
+void ZVision::processEvents() {
+	while (_eventMan->pollEvent(_event)) {
+		switch (_event.type) {
+		case Common::EVENT_LBUTTONDOWN:
+			onMouseDown(_event.mouse);
+			break;
+
+		case Common::EVENT_LBUTTONUP:
+			onMouseUp(_event.mouse);
+			break;
+
+		case Common::EVENT_RBUTTONDOWN:
+			break;
+
+		case Common::EVENT_MOUSEMOVE:
+			onMouseMove(_event.mouse);
+			break;
+
+		case Common::EVENT_KEYDOWN:
+			switch (_event.kbd.keycode) {
+			case Common::KEYCODE_d:
+				if (_event.kbd.hasFlags(Common::KBD_CTRL)) {
+					// Start the debugger
+					_console->attach();
+					_console->onFrame();
+				}
+				break;
+			case Common::KEYCODE_q:
+				if (_event.kbd.hasFlags(Common::KBD_CTRL))
+					quitGame();
+				break;
+			case Common::KEYCODE_F1:
+				cycleThroughCursors();
+				break;
+			default:
+				break;
+			}
+
+			onKeyDown(_event.kbd.keycode);
+			break;
+
+		default:
+			break;
+		}
+	}
+}
+
+void ZVision::onMouseDown(const Common::Point &pos) {
+	_cursorManager->cursorDown(true);
+}
+
+void ZVision::onMouseUp(const Common::Point &pos) {
+	_cursorManager->cursorDown(false);
+
+	Common::Point imageCoord(_renderManager->screenSpaceToImageSpace(pos));
+
+	for (Common::List<MouseEvent>::iterator iter = _mouseEvents.begin(); iter != _mouseEvents.end(); iter++) {
+		if (iter->withinHotspot(imageCoord)) {
+			iter->onClick(this);
+		}
+	}
+}
+
+void ZVision::onMouseMove(const Common::Point &pos) {
+	Common::Point imageCoord(_renderManager->screenSpaceToImageSpace(pos));
+
+	bool isWithinAHotspot = false;
+	if (_workingWindow.contains(pos)) {
+		for (Common::List<MouseEvent>::iterator iter = _mouseEvents.begin(); iter != _mouseEvents.end(); iter++) {
+			if (iter->withinHotspot(imageCoord)) {
+				_cursorManager->changeCursor(iter->getHoverCursor());
+				isWithinAHotspot = true;
+			}
+		}
+	}
+
+	// Graph of the function governing rotation velocity:
+	//
+	//                                    |---------------- working window ------------------|
+	//               ^                    |---------|
+	//               |                          |
+	// +Max velocity |                        rotation screen edge offset
+	//               |                                                                      /|
+	//               |                                                                     / |
+	//               |                                                                    /  |
+	//               |                                                                   /   |
+	//               |                                                                  /    |
+	//               |                                                                 /     |
+	//               |                                                                /      |
+	//               |                                                               /       |
+	//               |                                                              /        |
+	// Zero velocity |______________________________ ______________________________/_________|__________________________>
+	//               | Position ->        |         /
+	//               |                    |        /
+	//               |                    |       /
+	//               |                    |      /
+	//               |                    |     /
+	//               |                    |    /
+	//               |                    |   /
+	//               |                    |  /
+	//               |                    | /
+	// -Max velocity |                    |/
+	//               |
+	//               |
+	//               ^
+
+	if (_workingWindow.contains(pos)) {
+		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();
+				isWithinAHotspot = 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();
+				isWithinAHotspot = true;
+			} else {
+				_renderManager->setBackgroundVelocity(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();
+				isWithinAHotspot = 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();
+				isWithinAHotspot = true;
+			} else {
+				_renderManager->setBackgroundVelocity(0);
+			}
+		}
+	} else {
+		_renderManager->setBackgroundVelocity(0);
+	}
+
+	if (!isWithinAHotspot) {
+		_cursorManager->revertToIdle();
+	}
+}
+
+void ZVision::onKeyDown(uint keyCode) {
+
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/lzss_read_stream.cpp b/engines/zvision/lzss_read_stream.cpp
new file mode 100644
index 0000000000..03ab12d8be
--- /dev/null
+++ b/engines/zvision/lzss_read_stream.cpp
@@ -0,0 +1,103 @@
+/* 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/lzss_read_stream.h"
+
+namespace ZVision {
+
+LzssReadStream::LzssReadStream(Common::SeekableReadStream *source)
+		: _source(source),
+		  // It's convention to set the starting cursor position to blockSize - 16
+		  _windowCursor(0x0FEE),
+		  _eosFlag(false) {
+	// Clear the window to null
+	memset(_window, 0, BLOCK_SIZE);
+}
+
+uint32 LzssReadStream::decompressBytes(byte *destination, uint32 numberOfBytes) {
+	uint32 destinationCursor = 0;
+
+	while (destinationCursor < numberOfBytes) {
+		byte flagbyte = _source->readByte();
+		if (_source->eos())
+			break;
+		uint mask = 1;
+
+		for (int i = 0; i < 8; i++) {
+			if ((flagbyte & mask) == mask)
+			{
+				byte data = _source->readByte();
+				if (_source->eos())
+					return destinationCursor;
+
+				_window[_windowCursor] = data;
+				destination[destinationCursor++] = data;
+
+				// Increment and wrap the window cursor
+				_windowCursor = (_windowCursor + 1) & 0xFFF;
+			}
+			else
+			{
+				byte low = _source->readByte();
+				if (_source->eos())
+					return destinationCursor;
+
+				byte high = _source->readByte();
+				if (_source->eos())
+					return destinationCursor;
+
+				uint16 length = (high & 0xF) + 2;
+				uint16 offset = low | ((high & 0xF0)<<4);
+
+				for(int j = 0; j <= length; j++)
+				{
+					byte temp = _window[(offset + j) & 0xFFF];
+					_window[_windowCursor] = temp;
+					destination[destinationCursor++] = temp;
+					_windowCursor = (_windowCursor + 1) & 0xFFF;
+				}
+			};
+
+			mask = mask << 1;
+		}
+	}
+
+	return destinationCursor;
+}
+
+bool LzssReadStream::eos() const {
+	return _eosFlag;
+}
+
+uint32 LzssReadStream::read(void *dataPtr, uint32 dataSize) {
+	uint32 bytesRead = decompressBytes(static_cast<byte *>(dataPtr), dataSize);
+	if (bytesRead < dataSize) {
+		// Flag that we're at EOS
+		_eosFlag = true;
+	}
+
+	return dataSize;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/lzss_read_stream.h b/engines/zvision/lzss_read_stream.h
new file mode 100644
index 0000000000..25a8b67222
--- /dev/null
+++ b/engines/zvision/lzss_read_stream.h
@@ -0,0 +1,72 @@
+/* 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_LZSS_STREAM_H
+#define ZVISION_LZSS_STREAM_H
+
+#include "common/types.h"
+#include "common/stream.h"
+#include "common/array.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace ZVision {
+
+class LzssReadStream : public Common::ReadStream {
+public:
+	/**
+	 * A class that decompresses LZSS data and implements ReadStream for easy access 
+	 * to the decompiled data.
+	 *
+	 * @param source              The source data
+	 */
+	LzssReadStream(Common::SeekableReadStream *source);
+
+private:
+	enum {
+		BLOCK_SIZE = 0x1000
+	};
+
+private:
+	Common::SeekableReadStream *_source;
+	byte _window[BLOCK_SIZE];
+	uint _windowCursor;
+	bool _eosFlag;
+
+public:
+	bool eos() const;
+	uint32 read(void *dataPtr, uint32 dataSize);
+
+private:
+	/**
+	 * Decompress the next <numberOfBytes> from the source stream. Or until EOS
+	 *
+	 * @param numberOfBytes    How many bytes to decompress. This is a count of source bytes, not destination bytes
+	 */
+	uint32 decompressBytes(byte* destination, uint32 numberOfBytes);
+};
+
+}
+
+#endif
diff --git a/engines/zvision/module.mk b/engines/zvision/module.mk
new file mode 100644
index 0000000000..f072520d16
--- /dev/null
+++ b/engines/zvision/module.mk
@@ -0,0 +1,37 @@
+MODULE := engines/zvision
+ 
+MODULE_OBJS := \
+	action_node.o \
+	actions.o \
+	clock.o \
+	console.o \
+	control.o \
+	cursor.o \
+	cursor_manager.o \
+	detection.o \
+	events.o \
+	lzss_read_stream.o \
+	mouse_event.o \
+	render_manager.o \
+	render_table.o \
+	scr_file_handling.o \
+	script_manager.o \
+	scripts.o \
+	single_value_container.o \
+	utility.o \
+	video.o \
+	zvision.o \
+	zfs_archive.o \
+	zork_avi_decoder.o \
+	zork_raw.o
+ 
+MODULE_DIRS += \
+	engines/zvision
+ 
+# This module can be built as a plugin
+ifeq ($(ENABLE_ZVISION), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+ 
+# Include common rules 
+include $(srcdir)/rules.mk
\ No newline at end of file
diff --git a/engines/zvision/mouse_event.cpp b/engines/zvision/mouse_event.cpp
new file mode 100644
index 0000000000..a7c9fe5573
--- /dev/null
+++ b/engines/zvision/mouse_event.cpp
@@ -0,0 +1,45 @@
+/* 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/zvision.h"
+#include "zvision/script_manager.h"
+#include "zvision/mouse_event.h"
+
+namespace ZVision {
+
+MouseEvent::MouseEvent(uint32 key, const Common::Rect &hotspot, const Common::String hoverCursor)
+	: _key(key),
+	  _hotspot(hotspot),
+	  _hoverCursor(hoverCursor) {
+}
+
+bool MouseEvent::withinHotspot(const Common::Point &point) {
+	return _hotspot.contains(point);
+}
+
+void MouseEvent::onClick(ZVision *engine) {
+	engine->getScriptManager()->setStateValue(_key, 1);
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/mouse_event.h b/engines/zvision/mouse_event.h
new file mode 100644
index 0000000000..5537bcc4e5
--- /dev/null
+++ b/engines/zvision/mouse_event.h
@@ -0,0 +1,74 @@
+/* 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_MOUSE_EVENT_H
+#define ZVISION_MOUSE_EVENT_H
+
+#include "common/types.h"
+#include "common/rect.h"
+#include "common/str.h"
+
+namespace ZVision {
+
+class ZVision;
+
+class MouseEvent {
+public:
+	MouseEvent(uint32 key, const Common::Rect &hotspot, const Common::String hoverCursor);
+
+private:
+	/** The Control key */
+	uint32 _key;
+	/** 
+	 * The area that will trigger the event
+	 * This is in image space coordinates, NOT screen space 
+	 */
+	Common::Rect _hotspot;
+	/** The cursor to use when hovering over _hotspot */
+	Common::String _hoverCursor;
+
+public:
+	/**
+	 * Does a simple Rect::contains() using _hotspot
+	 *
+	 * @param point    The point to check against _hotspot
+	 * @return         The point is inside _hotspot (true) or not (false)
+	 */
+	bool withinHotspot(const Common::Point &point);
+	/**
+	 * Calls ScriptManager::setStateValue(_key, 1)
+	 *
+	 * @param engine    The base engine
+	 */
+	void onClick(ZVision *engine);
+	/**
+	 * Gets the name of the cursor that should be displayed when withinHotspot returns true
+	 *
+	 * @return    The name of the cursor. This should correspond to one of the names in CursorManager::_cursorNames[]
+	 */
+	const Common::String getHoverCursor() { return _hoverCursor; }
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/puzzle.h b/engines/zvision/puzzle.h
new file mode 100644
index 0000000000..e7846f5296
--- /dev/null
+++ b/engines/zvision/puzzle.h
@@ -0,0 +1,80 @@
+/* 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_PUZZLE_H
+#define ZVISION_PUZZLE_H
+
+
+#include "common/list.h"
+#include "common/ptr.h"
+
+namespace ZVision {
+
+class ResultAction;
+
+struct Puzzle {
+	/** How criteria should be decided */
+	enum CriteriaOperator {
+		EQUAL_TO,
+		NOT_EQUAL_TO,
+		GREATER_THAN,
+		LESS_THAN
+	};
+
+	/** Criteria for a Puzzle result to be fired */
+	struct Criteria {
+		/** The key of a global state */
+		uint32 key;
+		/**  
+		 * What we're comparing the value of the global state against
+		 * This can either be a pure value or it can be the key of another global state
+		 */
+		uint32 argument;
+		/** How to do the comparison */
+		CriteriaOperator criteriaOperator;
+		/** Whether 'argument' is the key of a global state (true) or a pure value (false) */
+		bool argumentIsAKey;
+	};
+
+	enum StateFlags {
+		ONCE_PER_INST = 0x01,
+		DO_ME_NOW = 0x02, // Somewhat useless flag since anything that needs to be done immediately has no criteria
+		DISABLED = 0x04
+	};
+
+	uint32 key;
+	Common::List<Criteria> criteriaList;
+	// This has to be list of pointers because ResultAction is abstract
+	Common::List<Common::SharedPtr<ResultAction> > resultActions;
+	uint flags;
+
+	// Used by the ScriptManager to allow unique-ification of _referenceTable
+	// The unique-ification is done by sorting, then iterating and removing duplicates
+	// The sort uses operator<
+	inline bool operator<(const Puzzle &other) const {
+		return key < other.key;
+	}
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/render_manager.cpp b/engines/zvision/render_manager.cpp
new file mode 100644
index 0000000000..78fcf59a56
--- /dev/null
+++ b/engines/zvision/render_manager.cpp
@@ -0,0 +1,303 @@
+/* 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 "common/file.h"
+#include "common/system.h"
+#include "common/stream.h"
+
+#include "engines/util.h"
+#include "graphics/decoders/tga.h"
+
+#include "zvision/render_manager.h"
+#include "zvision/lzss_read_stream.h"
+
+namespace ZVision {
+
+RenderManager::RenderManager(OSystem *system, const Common::Rect workingWindow)
+	: _system(system),
+	  _workingWidth(workingWindow.width()),
+	  _workingHeight(workingWindow.height()),
+	  _workingWindow(workingWindow),
+	  _currentBackground(0),
+	  _backgroundWidth(0),
+	  _backgroundHeight(0),
+	  _backgroundInverseVelocity(0),
+	  _accumulatedVelocityMilliseconds(0),
+	  _renderTable(workingWindow.width(), workingWindow.height()) {
+}
+
+RenderManager::~RenderManager() {
+	if (_currentBackground != 0) {
+		delete _currentBackground;
+	}
+}
+
+void RenderManager::update(uint deltaTimeInMillis) {
+	// An inverse velocity of 0 would be infinitely fast, so we'll let 0 mean no velocity.
+	if (_backgroundInverseVelocity == 0)
+		return;
+
+	_accumulatedVelocityMilliseconds += deltaTimeInMillis;
+
+	int absVelocity = abs(_backgroundInverseVelocity);
+
+	uint numberOfSteps = 0;
+	while (_accumulatedVelocityMilliseconds >= absVelocity) {
+		_accumulatedVelocityMilliseconds -= absVelocity;
+		numberOfSteps++;
+	}
+
+	// Choose the direction of movement using the sign of the velocity
+	moveBackground(_backgroundInverseVelocity < 0 ? -numberOfSteps : numberOfSteps);
+}
+
+void RenderManager::renderSubRectToScreen(uint16 *buffer, uint32 imageWidth, uint32 imageHeight, uint32 horizontalPitch, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle, bool wrap) {
+	if (wrap) {
+		_backgroundWidth = imageWidth;
+		_backgroundHeight = imageHeight;
+	}
+	
+	// If subRect is empty, use the entire image
+	if (subRectangle.isEmpty())
+		subRectangle = Common::Rect(subRectangle.left, subRectangle.top, subRectangle.left + imageWidth, subRectangle.top + imageHeight);
+
+	// Clip destRect to working window bounds
+	Common::Rect destRect(destinationX, destinationY, destinationX + subRectangle.width(), destinationY + subRectangle.height());
+	destRect.clip(_workingWidth, _workingHeight);
+	// Clip subRect to working window bounds
+	subRectangle.translate(destRect.left - destinationX, destRect.top - destinationY);
+	subRectangle.setWidth(destRect.width());
+	subRectangle.setHeight(destRect.height());
+	// Clip to image bounds
+	Common::Point subRectOrigOrigin(subRectangle.left, subRectangle.top);
+	subRectangle.clip(imageWidth, imageHeight);
+
+	// If the image is to be wrapped, check if it's smaller than destRect
+	// If it is, then call renderSubRectToScreen with a subRect representing wrapping
+	if (wrap && subRectangle.width() < destRect.width()) {
+		uint32 wrapDestX;
+		uint32 wrapDestY; 
+		Common::Rect wrapSubRect;
+
+		if (_backgroundWidth - subRectangle.left < destRect.width()) {
+			wrapDestX = destRect.left + subRectangle.width();
+			wrapDestY = destRect.top;
+			wrapSubRect = Common::Rect(0, 0, destRect.width() - subRectangle.width(), subRectangle.bottom);
+		} else {
+			wrapDestX = destRect.left;
+			wrapDestY = destRect.top;
+			wrapSubRect = Common::Rect(_backgroundWidth - subRectangle.width(), 0, _backgroundWidth - 1, subRectangle.bottom);
+		}
+
+		renderSubRectToScreen(buffer, imageWidth, imageHeight, horizontalPitch, wrapDestX, wrapDestY, wrapSubRect, false);
+	} else if (wrap && subRectangle.height() < destRect.height()) {
+		uint32 wrapDestX;
+		uint32 wrapDestY; 
+		Common::Rect wrapSubRect;
+
+		if (_backgroundHeight - subRectangle.top < destRect.height()) {
+			wrapDestX = destRect.left;
+			wrapDestY = destRect.height() - subRectangle.height();
+			wrapSubRect = Common::Rect(0, 0, subRectangle.right, destRect.height() - subRectangle.height());
+		} else {
+			wrapDestX = destRect.left;
+			wrapDestY = destRect.top;
+			wrapSubRect = Common::Rect(0, _backgroundHeight - subRectangle.height(), subRectangle.right, _backgroundHeight - 1);
+		}
+
+		renderSubRectToScreen(buffer, imageWidth, imageHeight, horizontalPitch, wrapDestX, wrapDestY, wrapSubRect, false);
+	}
+
+	// Clip destRect to image bounds
+	destRect.translate(subRectangle.left - subRectOrigOrigin.x, subRectangle.top - subRectOrigOrigin.y);
+	destRect.setWidth(subRectangle.width());
+	destRect.setHeight(subRectangle.height());
+
+	// Check all Rects for validity
+	if (!subRectangle.isValidRect() || subRectangle.isEmpty() || !destRect.isValidRect() || destRect.isEmpty())
+		return;
+
+	if (_renderTable.getRenderState() == RenderTable::FLAT) {
+		// Convert destRect to screen space by adding _workingWindowOffset
+		_system->copyRectToScreen(buffer + subRectangle.top * horizontalPitch + subRectangle.left, horizontalPitch, destRect.left + _workingWindow.left, destRect.top + _workingWindow.top, destRect.width(), destRect.height());
+	} else {
+		uint16 *destBuffer = new uint16[destRect.width() * destRect.height()];
+		_renderTable.mutateImage((uint16 *)buffer, destBuffer, imageWidth, imageHeight, subRectangle, destRect);
+
+		// Convert destRect to screen space by adding _workingWindow offset
+		_system->copyRectToScreen(destBuffer, subRectangle.width() * sizeof(uint16), destRect.left + _workingWindow.left, destRect.top + _workingWindow.top, destRect.width(), destRect.height());
+		delete[] destBuffer;
+	}
+}
+
+void RenderManager::renderImageToScreen(const Common::String &fileName, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle, bool wrap) {
+	Common::File file;
+
+	if (!file.open(fileName)) {
+		warning("Could not open file %s", fileName.c_str());
+		return;
+	}
+
+	renderImageToScreen(file, destinationX, destinationY, subRectangle);
+}
+
+void RenderManager::renderImageToScreen(Common::SeekableReadStream &stream, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle, bool wrap) {
+	// Read the magic number
+	// Some files are true TGA, while others are TGZ
+	uint32 fileType;
+	fileType = stream.readUint32BE();
+
+	// Check for TGZ files
+	if (fileType == MKTAG('T', 'G', 'Z', '\0')) {
+		// TGZ files have a header and then Bitmap data that is compressed with LZSS
+		uint32 decompressedSize = stream.readSint32LE();
+		uint32 imageWidth = stream.readSint32LE();
+		uint32 imageHeight = stream.readSint32LE();
+
+		LzssReadStream lzssStream(&stream);
+		byte *buffer = new byte[decompressedSize];
+		lzssStream.read(buffer, decompressedSize);
+
+		uint32 horizontalPitch = imageWidth * sizeof(uint16);
+
+		// Panoramas are transposed
+		// The actual data is transposed in mutateImage
+		if (_renderTable.getRenderState() == RenderTable::PANORAMA || _renderTable.getRenderState() == RenderTable::TILT) {
+			uint32 temp = imageHeight;
+			imageHeight = imageWidth;
+			imageWidth = temp;
+		}
+
+		renderSubRectToScreen((uint16 *)buffer, imageWidth, imageHeight, horizontalPitch, destinationX, destinationY, subRectangle, wrap);
+		delete[] buffer;
+	} else {
+		// Reset the cursor
+		stream.seek(0);
+
+		// Decode
+		Graphics::TGADecoder tga;
+		if (!tga.loadStream(stream)) {
+			warning("Error while reading TGA image");
+			return;
+		}
+
+		const Graphics::Surface *tgaSurface = tga.getSurface();
+
+		uint32 imageWidth = tgaSurface->w;
+		uint32 imageHeight = tgaSurface->h;
+
+		// Panoramas are transposed
+		// The actual data is transposed in mutateImage
+		if (_renderTable.getRenderState() == RenderTable::PANORAMA || _renderTable.getRenderState() == RenderTable::TILT) {
+			uint32 temp = imageHeight;
+			imageHeight = imageWidth;
+			imageWidth = temp;
+		}
+
+		renderSubRectToScreen((uint16 *)tgaSurface->pixels, tgaSurface->w, tgaSurface->h, tgaSurface->pitch, destinationX, destinationY, subRectangle, wrap);
+		tga.destroy();
+	}
+}
+
+const Common::Point RenderManager::screenSpaceToImageSpace(const Common::Point &point) {
+	// Convert from screen space to working window space
+	Common::Point newPoint(point - Common::Point(_workingWindow.left, _workingWindow.top));
+
+	if (_renderTable.getRenderState() == RenderTable::PANORAMA || _renderTable.getRenderState() == RenderTable::TILT) {
+		newPoint = _renderTable.convertWarpedCoordToFlatCoord(newPoint);
+	}
+
+	newPoint -= _backgroundOffset;
+	if (newPoint.x < 0)
+		newPoint.x += _backgroundWidth;
+	if (newPoint.y < 0)
+		newPoint.y += _backgroundHeight;
+
+	return newPoint;
+}
+
+RenderTable *RenderManager::getRenderTable() {
+	return &_renderTable;
+}
+
+void RenderManager::setBackgroundImage(const Common::String &fileName) {
+	Common::File *file = new Common::File;
+
+	if (!file->open(fileName)) {
+		warning("Could not open file %s", fileName.c_str());
+		return;
+	}
+
+	if (_currentBackground != 0) {
+		delete _currentBackground;
+	}
+	_currentBackground = file;
+
+	// Purposely make the subRectangle empty. renderImageToScreen will then set the width and height automatically.
+	renderImageToScreen(*_currentBackground, 0, 0, Common::Rect(_backgroundOffset.x, _backgroundOffset.y, _backgroundOffset.x, _backgroundOffset.y), true);
+}
+
+void RenderManager::setBackgroundPosition(int offset) {
+	if (_renderTable.getRenderState() == RenderTable::TILT) {
+		_backgroundOffset = Common::Point(0, offset);
+	} else {
+		_backgroundOffset = Common::Point(offset, 0);
+	}
+}
+
+void RenderManager::setBackgroundVelocity(int velocity) {
+	// setBackgroundVelocity(0) will be called quite often, so make sure
+	// _backgroundInverseVelocity isn't already 0 to prevent an extraneous assignment
+	if (velocity == 0) {
+		if (_backgroundInverseVelocity != 0) {
+			_backgroundInverseVelocity = 0;
+		}
+	} else {
+		_backgroundInverseVelocity = 1000 / velocity;
+	}
+}
+
+void RenderManager::moveBackground(int offset) {
+	if (_renderTable.getRenderState() == RenderTable::TILT) {
+		_backgroundOffset += Common::Point(0, offset);
+	} else {
+		_backgroundOffset += Common::Point(offset, 0);
+	}
+
+	// Make sure the offset is within image bounds
+	if (_backgroundOffset.x < 0)
+		_backgroundOffset.x += _backgroundWidth;
+	if (_backgroundOffset.x > _backgroundWidth)
+		_backgroundOffset.x -= _backgroundWidth;
+	if (_backgroundOffset.y < 0)
+		_backgroundOffset.y += _backgroundHeight;
+	if (_backgroundOffset.y > _backgroundHeight)
+		_backgroundOffset.y -= _backgroundHeight;
+
+	_currentBackground->seek(0);
+	// Purposely make the subRectangle empty. renderImageToScreen will then set the width and height automatically.
+	renderImageToScreen(*_currentBackground, 0, 0, Common::Rect(_backgroundOffset.x, _backgroundOffset.y, _backgroundOffset.x, _backgroundOffset.y), true);
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/render_manager.h b/engines/zvision/render_manager.h
new file mode 100644
index 0000000000..073a2f61e0
--- /dev/null
+++ b/engines/zvision/render_manager.h
@@ -0,0 +1,173 @@
+/* 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_RENDER_MANAGER_H
+#define ZVISION_RENDER_MANAGER_H
+
+#include "common/types.h"
+#include "common/rect.h"
+
+#include "zvision/render_table.h"
+
+class OSystem;
+
+namespace Common {
+class String;
+class SeekableReadStream;
+}
+
+namespace Video {
+class VideoDecoder;
+}
+
+namespace ZVision {
+
+class RenderManager {
+public:
+	RenderManager(OSystem *system, const Common::Rect workingWindow);
+	~RenderManager();
+
+private:
+	OSystem *_system;
+
+	/** Width of the working window. Saved to prevent extraneous calls to _workingWindow.width() */
+	const int _workingWidth;
+	/** Height of the working window. Saved to prevent extraneous calls to _workingWindow.height() */
+	const int _workingHeight;
+	/** 
+	 * A Rectangle centered inside the actual window. All in-game coordinates
+	 * are given in this coordinate space. Also, all images are clipped to the
+	 * edges of this Rectangle
+	 */
+	const Common::Rect _workingWindow;
+	/** Used to warp the background image */
+	RenderTable _renderTable;
+
+	Common::SeekableReadStream *_currentBackground;
+	/** The (x1,y1) coordinates of the subRectangle of the background that is currently displayed on the screen */
+	Common::Point _backgroundOffset;
+	/** The width of the current background image */
+	uint16 _backgroundWidth;
+	/** The height of the current background image */
+	uint16 _backgroundHeight;
+
+	/** 
+	 * The "velocity" at which the background image is panning. We actually store the inverse of velocity (ms/pixel instead of pixels/ms)
+	 * because it allows you to accumulate whole pixels 'steps' instead of rounding pixels every frame
+	 */
+	int _backgroundInverseVelocity;
+	/** Holds any 'leftover' milliseconds between frames */
+	uint _accumulatedVelocityMilliseconds;
+
+	byte *_scaledVideoFrameBuffer;
+
+public:
+	void initialize();
+	/**
+	 * Rotates the background image in accordance to the current _backgroundInverseVelocity
+	 *
+	 * @param deltaTimeInMillis    The amount of time that has passed since the last frame
+	 */
+	void update(uint deltaTimeInMillis);
+
+	/**
+	 * Blits the image or a portion of the image to the screen. Actual screen updates won't happen until the end of the frame.
+	 * The image will be clipped to fit inside the working window. Coords are in working window space, not screen space!
+	 *
+	 * @param fileName        Name of the image file
+	 * @param destinationX    X position where the image should be put. Coords are in working window space, not screen space!
+	 * @param destinationY    Y position where the image should be put. Coords are in working window space, not screen space!
+	 * @param subRectangle    The subrectangle of the image that should be rendered. If this is an empty rectangle, it will blit the entire image. Coords are in working window space, not screen space!
+	 */
+	void renderImageToScreen(const Common::String &fileName, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle = Common::Rect(0, 0, 0, 0), bool wrap = false);
+
+	/**
+	 * Blits the image or a portion of the image to the screen. Actual screen updates won't happen until the end of the frame.
+	 * The image will be clipped to fit inside the working window. Coords are in working window space, not screen space!
+	 *
+	 * @param stream          Stream to read the image data from
+	 * @param destinationX    X position where the image should be put. Coords are in working window space, not screen space!
+	 * @param destinationY    Y position where the image should be put. Coords are in working window space, not screen space!
+	 * @param subRectangle    The subrectangle of the image that should be rendered. If this is an empty rectangle, it will blit the entire image. Coords are in working window space, not screen space!
+	 */
+	void renderImageToScreen(Common::SeekableReadStream &stream, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle = Common::Rect(0, 0, 0, 0), bool wrap = false);
+
+	/**
+	 * Sets the current background image to be used by the RenderManager and immediately
+	 * blits it to the screen. (It won't show up until the end of the frame)
+	 *
+	 * @param fileName    The name of the image file
+	 */
+	void setBackgroundImage(const Common::String &fileName);
+
+	/**
+	 * Set the background position (_backgroundOffset). If the current RenderState is PANORAMA, the offset
+	 * will be in the horizontal direction. If the current RenderState is TILT, the offset will be in the
+	 * vertical direction. 
+	 *
+	 * This method will not render anything on the screen. So if nothing else is called that renders the 
+	 * background, the change won't be seen until next frame.
+	 *
+	 * @param offset The amount to offset the background
+	 */
+	void setBackgroundPosition(int offset);
+	
+	/**
+	 * Set the background scroll velocity. Negative velocities correspond to left / up scrolling and 
+	 * positive velocities correspond to right / down scrolling
+	 *
+	 * @param velocity    Velocity
+	 */
+	void setBackgroundVelocity(int velocity);
+
+	/**
+	 * Converts a point in screen coordinate space to image coordinate space
+	 *
+	 * @param point    Point in screen coordinate space
+	 * @return         Point in image coordinate space
+	 */
+	const Common::Point screenSpaceToImageSpace(const Common::Point &point);
+
+	RenderTable *getRenderTable();
+
+private:
+	/**
+	 * Renders a subRectangle of an image to the screen. The destinationRect and SubRect
+	 * will be clipped to image bound and to working window bounds
+	 *
+	 * @param buffer             Pointer to (0, 0) of the image data
+	 * @param imageWidth         The width of the original image (not of the subRectangle)
+	 * @param imageHeight        The width of the original image (not of the subRectangle)
+	 * @param horizontalPitch    The horizontal pitch of the original image
+	 * @param destinationX       The x coordinate (in working window space) of where to put the final image
+	 * @param destinationY       The y coordinate (in working window space) of where to put the final image
+	 * @param subRectangle       A rectangle representing the part of the image that should be rendered
+	 * @param wrap               Should the image wrap (tile) if it doesn't completely fill the screen?
+	 */
+	void renderSubRectToScreen(uint16 *buffer, uint32 imageWidth, uint32 imageHeight, uint32 horizontalPitch, uint32 destinationX, uint32 destinationY, Common::Rect subRectangle, bool wrap);
+
+	void moveBackground(int offset);
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/render_table.cpp b/engines/zvision/render_table.cpp
new file mode 100644
index 0000000000..aab4735d81
--- /dev/null
+++ b/engines/zvision/render_table.cpp
@@ -0,0 +1,219 @@
+/* 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 "graphics/colormasks.h"
+
+#include "zvision/render_table.h"
+#include "zvision/vector2.h"
+
+namespace ZVision {
+
+RenderTable::RenderTable(uint numColumns, uint numRows)
+		: _numRows(numRows),
+		  _numColumns(numColumns),
+		  _renderState(FLAT) {
+	assert(numRows != 0 && numColumns != 0);
+
+	_internalBuffer = new Vector2[numRows * numColumns];
+}
+
+RenderTable::~RenderTable() {
+	delete[] _internalBuffer;
+}
+
+void RenderTable::setRenderState(RenderState newState) {
+	_renderState = newState;
+
+	switch (newState) {
+	case PANORAMA:
+		_panoramaOptions.fieldOfView = 27.0f;
+		_panoramaOptions.linearScale = 0.55f;
+		_panoramaOptions.reverse = false;
+		break;
+	case TILT:
+
+		break;
+	case FLAT:
+		// Intentionally left empty
+		break;
+	}
+}
+
+const Common::Point RenderTable::convertWarpedCoordToFlatCoord(const Common::Point &point) {
+	// If we're outside the range of the RenderTable, no warping is happening. Return the maximum image coords
+	if (point.x >= _numColumns || point.y >= _numRows) {
+		int16 x = CLIP<int16>(point.x, 0, _numColumns);
+		int16 y = CLIP<int16>(point.y, 0, _numRows);
+		return Common::Point(x, y);
+	}
+
+	uint32 index = point.y * _numColumns + point.x;
+
+	Common::Point newPoint(point);
+	newPoint.x += _internalBuffer[index].x;
+	newPoint.y += _internalBuffer[index].y;
+
+	return newPoint;
+}
+
+uint16 mixTwoRGB(uint16 colorOne, uint16 colorTwo, float percentColorOne) {
+	assert(percentColorOne < 1.0f);
+
+	float rOne = float((colorOne & Graphics::ColorMasks<555>::kRedMask) >> Graphics::ColorMasks<555>::kRedShift);
+	float rTwo = float((colorTwo & Graphics::ColorMasks<555>::kRedMask) >> Graphics::ColorMasks<555>::kRedShift);
+	float gOne = float((colorOne & Graphics::ColorMasks<555>::kGreenMask) >> Graphics::ColorMasks<555>::kGreenShift);
+	float gTwo = float((colorTwo & Graphics::ColorMasks<555>::kGreenMask) >> Graphics::ColorMasks<555>::kGreenShift);
+	float bOne = float((colorOne & Graphics::ColorMasks<555>::kBlueMask) >> Graphics::ColorMasks<555>::kBlueShift);
+	float bTwo = float((colorTwo & Graphics::ColorMasks<555>::kBlueMask) >> Graphics::ColorMasks<555>::kBlueShift);
+
+	float rFinal = rOne * percentColorOne + rTwo * (1.0f - percentColorOne);
+	float gFinal = gOne * percentColorOne + gTwo * (1.0f - percentColorOne);
+	float bFinal = bOne * percentColorOne + bTwo * (1.0f - percentColorOne);
+
+	uint16 returnColor = (byte(rFinal + 0.5f) << Graphics::ColorMasks<555>::kRedShift) |
+	                     (byte(gFinal + 0.5f) << Graphics::ColorMasks<555>::kGreenShift) |
+						 (byte(bFinal + 0.5f) << Graphics::ColorMasks<555>::kBlueShift);
+
+	return returnColor;
+}
+
+void RenderTable::mutateImage(uint16 *sourceBuffer, uint16* destBuffer, uint32 imageWidth, uint32 imageHeight, Common::Rect subRectangle, Common::Rect destRectangle) {
+	bool isTransposed = _renderState == RenderTable::PANORAMA || _renderState == RenderTable::TILT;
+
+	for (int y = subRectangle.top; y < subRectangle.bottom; y++) {
+		uint normalizedY = y - subRectangle.top;
+
+		for (int x = subRectangle.left; x < subRectangle.right; x++) {
+			uint normalizedX = x - subRectangle.left;
+
+			uint32 index = (normalizedY + destRectangle.top) * _numColumns + (normalizedX + destRectangle.left);
+
+			// RenderTable only stores offsets from the original coordinates
+			uint32 sourceYIndex = y + _internalBuffer[index].y;
+			uint32 sourceXIndex = x + _internalBuffer[index].x;
+
+			// Clamp the yIndex to the size of the image
+			sourceYIndex = CLIP<uint32>(sourceYIndex, 0, imageHeight - 1);
+
+			// Clamp the xIndex to the size of the image
+			sourceXIndex = CLIP<uint32>(sourceXIndex, 0, imageWidth - 1);
+
+			// TODO: Figure out a way to not have branching every loop. The only way that comes to mind is to have a whole separate set of for loops for isTransposed, but that's ugly. The compiler might do this anyway in the end
+			if (isTransposed) {
+				destBuffer[normalizedY * subRectangle.width() + normalizedX] = sourceBuffer[sourceXIndex * imageHeight + sourceYIndex];
+			} else {
+				destBuffer[normalizedY * subRectangle.width() + normalizedX] = sourceBuffer[sourceYIndex * imageWidth + sourceXIndex];
+			}
+		}
+	}
+}
+
+void RenderTable::generateRenderTable() {
+	switch (_renderState) {
+	case ZVision::RenderTable::PANORAMA:
+		generatePanoramaLookupTable();
+		break;
+	case ZVision::RenderTable::TILT:
+		generateTiltLookupTable();
+		break;
+	case ZVision::RenderTable::FLAT:
+		// Intentionally left empty
+		break;
+	}
+}
+
+void RenderTable::generatePanoramaLookupTable() {
+	memset(_internalBuffer, 0, _numRows * _numColumns * sizeof(uint16));
+
+	float halfWidth = (float)_numColumns / 2.0f;
+	float halfHeight = (float)_numRows / 2.0f;
+
+	float fovRadians = (_panoramaOptions.fieldOfView * M_PI / 180.0f);
+	float halfHeightOverTan = halfHeight / tan(fovRadians);
+	float tanOverHalfHeight = tan(fovRadians) / halfHeight;
+
+	// TODO: Change the algorithm to write a whole row at a time instead of a whole column at a time. AKA: for(y) { for(x) {}} instead of for(x) { for(y) {}}
+	for (uint x = 0; x < _numColumns; x++) {
+		// Add an offset of 0.01 to overcome zero tan/atan issue (vertical line on half of screen)
+		float temp = atan(tanOverHalfHeight * ((float)x - halfWidth + 0.01f));
+
+		int32 newX = int32(floor((halfHeightOverTan * _panoramaOptions.linearScale * temp) + halfWidth));
+		float cosX = cos(temp);
+
+		for (uint y = 0; y < _numRows; y++) {
+			int32 newY = int32(floor(halfHeight + ((float)y - halfHeight) * cosX));
+
+			uint32 index = y * _numColumns + x;
+
+			// Only store the x,y offsets instead of the absolute positions
+			_internalBuffer[index].x = newX - x;
+			_internalBuffer[index].y = newY - y;
+		}
+	}
+}
+
+void RenderTable::generateTiltLookupTable() {
+	for (uint x = 0; x < _numColumns; x++) {
+		for (uint y = 0; y < _numRows; y++) {
+			uint32 index = y * _numColumns + x;
+
+			_internalBuffer[index].x = 0;
+			_internalBuffer[index].y = 0;
+		}
+	}
+}
+
+void RenderTable::setPanoramaFoV(float fov) {
+	assert(fov > 0.0f);
+
+	_panoramaOptions.fieldOfView = fov;
+}
+
+void RenderTable::setPanoramaScale(float scale) {
+	assert(scale > 0.0f);
+
+	_panoramaOptions.linearScale = scale;
+}
+
+void RenderTable::setPanoramaReverse(bool reverse) {
+	_panoramaOptions.reverse = reverse;
+}
+
+void RenderTable::setTiltFoV(float fov) {
+	assert(fov > 0.0f);
+
+	_tiltOptions.fieldOfView = fov;
+}
+
+void RenderTable::setTiltScale(float scale) {
+	assert(scale > 0.0f);
+
+	_tiltOptions.linearScale = scale;
+}
+
+void RenderTable::setTiltReverse(bool reverse) {
+	_tiltOptions.reverse = reverse;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/render_table.h b/engines/zvision/render_table.h
new file mode 100644
index 0000000000..c38b5a6f0b
--- /dev/null
+++ b/engines/zvision/render_table.h
@@ -0,0 +1,87 @@
+/* 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_RENDER_TABLE_H
+#define ZVISION_RENDER_TABLE_H
+
+#include "common/types.h"
+#include "common/rect.h"
+
+#include "zvision/vector2.h"
+
+namespace ZVision {
+
+class RenderTable {
+public:
+	RenderTable(uint numRows, uint numColumns);
+	~RenderTable();
+
+public:
+	enum RenderState {
+		PANORAMA,
+		TILT,
+		FLAT
+	};
+
+private:
+	uint _numColumns, _numRows;
+	Vector2 *_internalBuffer;
+	RenderState _renderState;
+
+	struct {
+		float fieldOfView;
+		float linearScale;
+		bool reverse;
+	} _panoramaOptions;
+
+	// TODO: See if tilt and panorama need to have separate options
+	struct {
+		float fieldOfView;
+		float linearScale;
+		bool reverse;
+	} _tiltOptions;
+
+public:
+	RenderState getRenderState() { return _renderState; }
+	void setRenderState(RenderState newState);
+
+	const Common::Point convertWarpedCoordToFlatCoord(const Common::Point &point);
+
+	void mutateImage(uint16 *sourceBuffer, uint16* destBuffer, uint32 imageWidth, uint32 imageHeight, Common::Rect subRectangle, Common::Rect destRectangle);
+	void generateRenderTable();
+
+	void setPanoramaFoV(float fov);
+	void setPanoramaScale(float scale);
+	void setPanoramaReverse(bool reverse);
+
+	void setTiltFoV(float fov);
+	void setTiltScale(float scale);
+	void setTiltReverse(bool reverse);
+
+private:
+	void generatePanoramaLookupTable();
+	void generateTiltLookupTable();
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/scr_file_handling.cpp b/engines/zvision/scr_file_handling.cpp
new file mode 100644
index 0000000000..5b8af48047
--- /dev/null
+++ b/engines/zvision/scr_file_handling.cpp
@@ -0,0 +1,329 @@
+/* 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/script_manager.h"
+#include "zvision/utility.h"
+#include "zvision/puzzle.h"
+#include "zvision/actions.h"
+
+#include "common/textconsole.h"
+#include "common/file.h"
+#include "common/tokenizer.h"
+
+namespace ZVision {
+
+void ScriptManager::parseScrFile(const Common::String &fileName, bool isGlobal) {
+	Common::File file;
+	if (!file.open(fileName)) {
+		warning("Script file not found: %s", fileName.c_str());
+		return;
+	}
+
+	while(!file.eos()) {
+		Common::String line = file.readLine();
+		if (file.err()) {
+			warning("Error parsing scr file: %s", fileName.c_str());
+			return;
+		}
+
+		trimCommentsAndWhiteSpace(&line);
+		if (line.empty())
+			continue;
+
+		if (line.matchString("puzzle:*", true)) {
+			Puzzle puzzle;
+			sscanf(line.c_str(),"puzzle:%u",&(puzzle.key));
+
+			parsePuzzle(puzzle, file);
+			if (isGlobal) {
+				_globalPuzzles.push_back(puzzle);
+			} else {
+				_activePuzzles.push_back(puzzle);
+			}
+		} else if (line.matchString("control:*", true)) {
+			Common::SharedPtr<Control> control;
+
+			// Some controls don't require nodes. They just initialize the scene
+			if (parseControl(line, file, control)) {
+				_activeControls.push_back(control);
+			}
+		}
+	}
+}
+
+void ScriptManager::parsePuzzle(Puzzle &puzzle, Common::SeekableReadStream &stream) {
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	while (!line.contains('}')) {
+		if (line.matchString("criteria {", true)) {
+			Puzzle::Criteria criteria;
+			if (parseCriteria(&criteria, stream)) {
+				puzzle.criteriaList.push_back(criteria);
+			}
+		} else if (line.matchString("results {", true)) {
+			parseResults(stream, puzzle.resultActions);
+		} else if (line.matchString("flags {", true)) {
+			puzzle.flags = parseFlags(stream);
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+}
+
+bool ScriptManager::parseCriteria(Puzzle::Criteria *criteria, Common::SeekableReadStream &stream) const {
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	// Criteria can be empty
+	if (line.contains('}')) {
+		return false;
+	}
+
+	while (!line.contains('}')) {
+		// Split the string into tokens using ' ' as a delimiter
+		Common::StringTokenizer tokenizer(line);
+		Common::String token;
+
+		// Parse the id out of the first token
+		token = tokenizer.nextToken();
+		sscanf(token.c_str(), "[%u]", &(criteria->key));
+
+		// Parse the operator out of the second token
+		token = tokenizer.nextToken();
+		if (token.c_str()[0] == '=')
+			criteria->criteriaOperator = Puzzle::EQUAL_TO;
+		else if (token.c_str()[0] == '!')
+			criteria->criteriaOperator = Puzzle::NOT_EQUAL_TO;
+		else if (token.c_str()[0] == '>')
+			criteria->criteriaOperator = Puzzle::GREATER_THAN;
+		else if (token.c_str()[0] == '<')
+			criteria->criteriaOperator = Puzzle::LESS_THAN;
+
+		// First determine if the last token is an id or a value
+		// Then parse it into 'argument'
+		token = tokenizer.nextToken();
+		if (token.contains('[')) {
+			sscanf(token.c_str(), "[%u]", &(criteria->argument));
+			criteria->argumentIsAKey = true;
+		} else {
+			sscanf(token.c_str(), "%u", &(criteria->argument));
+			criteria->argumentIsAKey = false;
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	return true;
+}
+
+void ScriptManager::parseResults(Common::SeekableReadStream &stream, Common::List<Common::SharedPtr<ResultAction> > &actionList) const {
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	// TODO: Re-order the if-then statements in order of highest occurrence
+	while (!line.contains('}')) {
+		if (line.empty()) {
+			line = stream.readLine();
+			trimCommentsAndWhiteSpace(&line);
+
+			continue;
+		}
+
+		// Parse for the action type
+		if (line.matchString("*:add*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionAdd(line)));
+		} else if (line.matchString("*:animplay*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionPlayAnimation(line)));
+		} else if (line.matchString("*:animpreload*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionPreloadAnimation(line)));
+		} else if (line.matchString("*:animunload*", true)) {
+			//actionList.push_back(Common::SharedPtr<ResultAction>(new ActionUnloadAnimation(line)));
+		} else if (line.matchString("*:attenuate*", true)) {
+			
+
+		} else if (line.matchString("*:assign*", true)) {
+			
+
+		} else if (line.matchString("*:change_location*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionChangeLocation(line)));
+		} else if (line.matchString("*:crossfade*", true)) {
+			
+
+		} else if (line.matchString("*:debug*", true)) {
+			
+
+		} else if (line.matchString("*:delay_render*", true)) {
+			
+
+		} else if (line.matchString("*:disable_control*", true)) {
+			
+
+		} else if (line.matchString("*:disable_venus*", true)) {
+			
+
+		} else if (line.matchString("*:display_message*", true)) {
+			
+
+		} else if (line.matchString("*:dissolve*", true)) {
+			
+
+		} else if (line.matchString("*:distort*", true)) {
+			
+
+		} else if (line.matchString("*:enable_control*", true)) {
+			
+
+		} else if (line.matchString("*:flush_mouse_events*", true)) {
+			
+
+		} else if (line.matchString("*:inventory*", true)) {
+			
+
+		} else if (line.matchString("*:kill*", true)) {
+			
+
+		} else if (line.matchString("*:menu_bar_enable*", true)) {
+			
+
+		} else if (line.matchString("*:music*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionMusic(line)));
+		} else if (line.matchString("*:pan_track*", true)) {
+			
+
+		} else if (line.matchString("*:playpreload*", true)) {
+			
+
+		} else if (line.matchString("*:preferences*", true)) {
+			
+
+		} else if (line.matchString("*:quit*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionQuit()));
+		} else if (line.matchString("*:random*", true)) {
+			
+
+		} else if (line.matchString("*:region*", true)) {
+			
+
+		} else if (line.matchString("*:restore_game*", true)) {
+			
+
+		} else if (line.matchString("*:rotate_to*", true)) {
+			
+
+		} else if (line.matchString("*:save_game*", true)) {
+			
+
+		} else if (line.matchString("*:set_partial_screen*", true)) {
+			
+
+		} else if (line.matchString("*:set_screen*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionSetScreen(line)));
+		} else if (line.matchString("*:set_venus*", true)) {
+			
+
+		} else if (line.matchString("*:stop*", true)) {
+			
+
+		} else if (line.matchString("*:streamvideo*", true)) {
+			actionList.push_back(Common::SharedPtr<ResultAction>(new ActionStreamVideo(line)));
+		} else if (line.matchString("*:syncsound*", true)) {
+			
+
+		} else if (line.matchString("*:timer*", true)) {
+			
+
+		} else if (line.matchString("*:ttytext*", true)) {
+			
+
+		} else if (line.matchString("*:universe_music*", true)) {
+			
+
+		} else if (line.matchString("*:copy_file*", true)) {
+			// Not used. Purposely left empty
+		} else {
+			warning("Unhandled result action type: %s", line.c_str());
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	return;
+}
+
+uint ScriptManager::parseFlags(Common::SeekableReadStream &stream) const {
+	uint flags = 0;
+
+	// Loop until we find the closing brace
+	Common::String line = stream.readLine();
+	trimCommentsAndWhiteSpace(&line);
+
+	while (!line.contains('}')) {
+		if (line.matchString("ONCE_PER_INST", true)) {
+			flags |= Puzzle::ONCE_PER_INST;
+		} else if (line.matchString("DO_ME_NOW", true)) {
+			flags |= Puzzle::DO_ME_NOW;
+		} else if (line.matchString("DISABLED", true)) {
+			flags |= Puzzle::DISABLED;
+		}
+
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
+	return flags;
+}
+
+bool ScriptManager::parseControl(Common::String &line, Common::SeekableReadStream &stream, Common::SharedPtr<Control> &control) {
+	uint32 key;
+	char controlTypeBuffer[20];
+
+	sscanf(line.c_str(), "control:%u %s {", &key, controlTypeBuffer);
+
+	Common::String controlType(controlTypeBuffer);
+
+	if (controlType.equalsIgnoreCase("push_toggle")) {
+		Control::parsePushToggleControl(key, _engine, stream);
+		return false;
+	} else if (controlType.equalsIgnoreCase("flat")) {
+		Control::parseFlatControl(_engine);
+		return false;
+	} else if (controlType.equalsIgnoreCase("pana")) {
+		Control::parsePanoramaControl(_engine, stream);
+		return false;
+	}
+	else if (controlType.equalsIgnoreCase("tilt")) {
+		Control::parseTiltControl(_engine, stream);
+		return false;
+	}
+
+	return true;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/script_manager.cpp b/engines/zvision/script_manager.cpp
new file mode 100644
index 0000000000..6aaf5773e0
--- /dev/null
+++ b/engines/zvision/script_manager.cpp
@@ -0,0 +1,243 @@
+/* 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 "common/algorithm.h"
+#include "common/hashmap.h"
+#include "common/debug.h"
+
+#include "zvision/zvision.h"
+#include "zvision/script_manager.h"
+#include "zvision/render_manager.h"
+#include "zvision/cursor_manager.h"
+#include "zvision/actions.h"
+#include "zvision/action_node.h"
+#include "zvision/utility.h"
+
+namespace ZVision {
+
+ScriptManager::ScriptManager(ZVision *engine)
+	: _engine(engine),
+	  _changeLocation(false) {
+}
+
+void ScriptManager::initialize() {
+	parseScrFile("universe.scr", true);
+	changeLocation('g', 'a', 'r', 'y', 0);
+}
+
+void ScriptManager::update(uint deltaTimeMillis) {
+	updateNodes(deltaTimeMillis);
+	checkPuzzleCriteria();
+
+	if (_changeLocation) {
+		changeLocationIntern();
+		_changeLocation = false;
+	}
+}
+
+void ScriptManager::createReferenceTable() {
+	// Iterate through each local Puzzle
+	for (Common::List<Puzzle>::iterator activePuzzleIter = _activePuzzles.begin(); activePuzzleIter != _activePuzzles.end(); activePuzzleIter++) {
+		Puzzle *puzzlePtr = &(*activePuzzleIter);
+
+		// Iterate through each Criteria and add a reference from the criteria key to the Puzzle
+		for (Common::List<Puzzle::Criteria>::iterator criteriaIter = activePuzzleIter->criteriaList.begin(); criteriaIter != (*activePuzzleIter).criteriaList.end(); criteriaIter++) {
+			_referenceTable[criteriaIter->key].push_back(puzzlePtr);
+
+			// If the argument is a key, add a reference to it as well
+			if (criteriaIter->argumentIsAKey)
+				_referenceTable[criteriaIter->argument].push_back(puzzlePtr);
+		}
+	}
+
+	// Iterate through each global Puzzle
+	for (Common::List<Puzzle>::iterator globalPuzzleIter = _globalPuzzles.begin(); globalPuzzleIter != _globalPuzzles.end(); globalPuzzleIter++) {
+		Puzzle *puzzlePtr = &(*globalPuzzleIter);
+
+		// Iterate through each Criteria and add a reference from the criteria key to the Puzzle
+		for (Common::List<Puzzle::Criteria>::iterator criteriaIter = globalPuzzleIter->criteriaList.begin(); criteriaIter != (*globalPuzzleIter).criteriaList.end(); criteriaIter++) {
+			_referenceTable[criteriaIter->key].push_back(puzzlePtr);
+
+			// If the argument is a key, add a reference to it as well
+			if (criteriaIter->argumentIsAKey)
+				_referenceTable[criteriaIter->argument].push_back(puzzlePtr);
+		}
+	}
+
+	// Remove duplicate entries
+	for (Common::HashMap<uint32, Common::Array<Puzzle *> >::iterator referenceTableIter = _referenceTable.begin(); referenceTableIter != _referenceTable.end(); referenceTableIter++) {
+		removeDuplicateEntries(referenceTableIter->_value);
+	}
+}
+
+void ScriptManager::updateNodes(uint deltaTimeMillis) {
+	// If process() returns true, it means the node can be deleted
+	for (Common::List<Common::SharedPtr<ActionNode> >::iterator iter = _activeNodes.begin(); iter != _activeNodes.end();) {
+		if ((*iter)->process(_engine, deltaTimeMillis)) {
+			// Remove the node from _activeNodes, the SharedPtr destructor will delete the actual ActionNode
+			iter = _activeNodes.erase(iter);
+		} else {
+			iter++;
+		}
+	}
+}
+
+void ScriptManager::checkPuzzleCriteria() {
+	while (!_puzzlesToCheck.empty()) {
+		Puzzle *puzzle = _puzzlesToCheck.pop();
+
+		// Check if the puzzle is already finished
+		// If it doesn't have the flag ONCE_PER_INST it can be done more than once
+		// Also check that the puzzle isn't disabled
+		if (getStateValue(puzzle->key) == 1 &&
+		    (puzzle->flags & Puzzle::ONCE_PER_INST) == Puzzle::ONCE_PER_INST &&
+		    (puzzle->flags & Puzzle::DISABLED) == 0) {
+			continue;
+		}
+
+		// Check each Criteria
+		bool criteriaMet = false;
+		for (Common::List<Puzzle::Criteria>::iterator iter = puzzle->criteriaList.begin(); iter != puzzle->criteriaList.end(); iter++) {
+			// Get the value to compare against
+			uint argumentValue;
+			if ((*iter).argumentIsAKey)
+				argumentValue = getStateValue(iter->argument);
+			else
+				argumentValue = iter->argument;
+
+			// Do the comparison
+			switch ((*iter).criteriaOperator) {
+			case Puzzle::EQUAL_TO:
+				criteriaMet = getStateValue(iter->key) == argumentValue;
+				break;
+			case Puzzle::NOT_EQUAL_TO:
+				criteriaMet = getStateValue(iter->key) != argumentValue;
+				break;
+			case Puzzle::GREATER_THAN:
+				criteriaMet = getStateValue(iter->key) > argumentValue;
+				break;
+			case Puzzle::LESS_THAN:
+				criteriaMet = getStateValue(iter->key) < argumentValue;
+				break;
+			}
+
+			if (!criteriaMet) {
+				break;
+			}
+		}
+
+		// criteriaList can be empty. Aka, the puzzle should be executed immediately
+		if (puzzle->criteriaList.empty() || criteriaMet) {
+			debug("Puzzle %u criteria passed. Executing its ResultActions", puzzle->key);
+
+			bool shouldContinue = true;
+			for (Common::List<Common::SharedPtr<ResultAction> >::iterator resultIter = puzzle->resultActions.begin(); resultIter != puzzle->resultActions.end(); resultIter++) {
+				shouldContinue = shouldContinue && (*resultIter)->execute(_engine);
+			}
+
+			// Set the puzzle as completed
+			setStateValue(puzzle->key, 1);
+
+			if (!shouldContinue) {
+				break;
+			}
+		}
+	}
+}
+
+uint ScriptManager::getStateValue(uint32 key) {
+	if (_globalState.contains(key))
+		return _globalState[key];
+	else
+		return 0;
+}
+
+void ScriptManager::setStateValue(uint32 key, uint value) {
+	_globalState[key] = value;
+
+	if (_referenceTable.contains(key)) {
+		for (Common::Array<Puzzle *>::iterator iter = _referenceTable[key].begin(); iter != _referenceTable[key].end(); iter++) {
+			_puzzlesToCheck.push((*iter));
+		}
+	}
+}
+
+void ScriptManager::addToStateValue(uint32 key, uint valueToAdd) {
+	_globalState[key] += valueToAdd;
+}
+
+void ScriptManager::addActionNode(const Common::SharedPtr<ActionNode> &node) {
+	_activeNodes.push_back(node);
+}
+
+void ScriptManager::changeLocation(char world, char room, char node, char view, uint32 x) {
+	_nextLocation.world = world;
+	_nextLocation.room = room;
+	_nextLocation.node = node;
+	_nextLocation.view = view;
+	_nextLocation.x = x;
+
+	_changeLocation = true;
+}
+
+void ScriptManager::changeLocationIntern() {
+	assert(_nextLocation.world != 0);
+	debug("Changing location to: %c %c %c %c %u", _nextLocation.world, _nextLocation.room, _nextLocation.node, _nextLocation.view, _nextLocation.x);
+
+	// Clear all the containers
+	_referenceTable.clear();
+	_puzzlesToCheck.clear();
+	_activePuzzles.clear();
+	// We can clear without deleting from the heap because we use SharedPtr
+	_activeControls.clear();
+	_engine->clearAllMouseEvents();
+
+	// Revert to the idle cursor
+	_engine->getCursorManager()->revertToIdle();
+
+	// Change the background position
+	_engine->getRenderManager()->setBackgroundPosition(_nextLocation.x);
+
+	// Reset the background velocity
+	_engine->getRenderManager()->setBackgroundVelocity(0);
+
+	// Parse into puzzles and controls
+	Common::String fileName = Common::String::format("%c%c%c%c.scr", _nextLocation.world, _nextLocation.room, _nextLocation.node, _nextLocation.view);
+	parseScrFile(fileName);
+
+	// Create the puzzle reference table
+	createReferenceTable();
+
+	// Add all the local puzzles to the stack to be checked
+	for (Common::List<Puzzle>::iterator iter = _activePuzzles.begin(); iter != _activePuzzles.end(); iter++) {
+		_puzzlesToCheck.push(&(*iter));
+	}
+
+	// Add all the global puzzles to the stack to be checked
+	for (Common::List<Puzzle>::iterator iter = _globalPuzzles.begin(); iter != _globalPuzzles.end(); iter++) {
+		_puzzlesToCheck.push(&(*iter));
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/script_manager.h b/engines/zvision/script_manager.h
new file mode 100644
index 0000000000..8e79548f77
--- /dev/null
+++ b/engines/zvision/script_manager.h
@@ -0,0 +1,154 @@
+/* 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_SCRIPT_MANAGER_H
+#define ZVISION_SCRIPT_MANAGER_H
+
+#include "common/hashmap.h"
+#include "common/stack.h"
+
+#include "zvision/puzzle.h"
+#include "zvision/control.h"
+
+namespace Common {
+class String;
+class SeekableReadStream;
+}
+
+namespace ZVision {
+
+class ZVision;
+class ActionNode;
+
+struct Location {
+	char world;
+	char room;
+	char node;
+	char view;
+	uint32 x;
+};
+
+class ScriptManager {
+public:
+	ScriptManager(ZVision *engine);
+
+private:
+	ZVision *_engine;
+	/** 
+	 * Holds the global state variable. Do NOT directly modify this. Use the accessors and 
+	 * mutators getStateValue() and setStateValue(). This ensures that Puzzles that reference a 
+	 * particular state key are checked after the key is modified.
+	 */
+	Common::HashMap<uint32, uint> _globalState;
+	/** Holds the currently active ActionNodes */
+	Common::List<Common::SharedPtr<ActionNode> > _activeNodes;
+	/** References _globalState keys to Puzzles */
+	Common::HashMap<uint32, Common::Array<Puzzle *> > _referenceTable;
+	/** Holds the Puzzles that should be checked this frame */
+	Common::Stack<Puzzle *> _puzzlesToCheck;
+	/** Holds the currently active puzzles */
+	Common::List<Puzzle> _activePuzzles;
+	/** Holds the global puzzles */
+	Common::List<Puzzle>_globalPuzzles;
+	/** Holds the currently active controls */
+	Common::List<Common::SharedPtr<Control> > _activeControls;
+
+	Location _nextLocation;
+	bool _changeLocation;
+
+public:
+	
+	void initialize();
+	void update(uint deltaTimeMillis);
+
+	uint getStateValue(uint32 key);
+	void setStateValue(uint32 key, uint value);
+	void addToStateValue(uint32 key, uint valueToAdd);
+
+	void addActionNode(const Common::SharedPtr<ActionNode> &node);
+
+	void changeLocation(char world, char room, char node, char view, uint32 x);
+
+private:
+	void createReferenceTable();
+	void changeLocationIntern();
+	void updateNodes(uint deltaTimeMillis);
+	void checkPuzzleCriteria();
+
+	/**
+	 * Parses a script file into triggers and events
+	 *
+	 * @param fileName    Name of the .scr file
+	 * @param isGlobal    Are the puzzles included in the file global (true). AKA, the won't be purged during location changes
+	 */
+	void parseScrFile(const Common::String &fileName, bool isGlobal = false);
+
+	/**
+	 * Parses the stream into a Puzzle object
+	 * Helper method for parseScrFile. 
+	 *
+	 * @param puzzle    The object to store what is parsed
+	 * @param stream    Scr file stream
+	 */
+	void parsePuzzle(Puzzle &puzzle, Common::SeekableReadStream &stream);
+
+	/**
+	 * Parses the stream into a Criteria object
+	 * Helper method for parsePuzzle. 
+	 *
+	 * @param criteria    Pointer to the Criteria object to fill
+	 * @param stream      Scr file stream
+	 * @return            Whether any criteria were read
+	 */
+	bool parseCriteria(Puzzle::Criteria *criteria, Common::SeekableReadStream &stream) const;
+
+	/**
+	 * Parses the stream into a ResultAction objects
+	 * Helper method for parsePuzzle. 
+	 *
+	 * @param stream        Scr file stream
+	 * @param actionList    The list where the results will be added
+	 * @return              Created Results object
+	 */
+	void parseResults(Common::SeekableReadStream &stream, Common::List<Common::SharedPtr<ResultAction> > &actionList) const;
+
+	/**
+	 * Helper method for parsePuzzle. Parses the stream into a bitwise or of the StateFlags enum
+	 *
+	 * @param stream    Scr file stream
+	 * @return          Bitwise OR of all the flags set within the puzzle
+	 */
+	uint parseFlags(Common::SeekableReadStream &stream) const;
+
+	/**
+	 * Helper method for parseScrFile. Parses the stream into a Control object
+	 *
+	 * @param line      The line initially read
+	 * @param stream    Scr file stream
+	 */
+	bool parseControl(Common::String &line, Common::SeekableReadStream &stream, Common::SharedPtr<Control> &control);
+};
+
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/scripts.cpp b/engines/zvision/scripts.cpp
new file mode 100644
index 0000000000..b6deb1b510
--- /dev/null
+++ b/engines/zvision/scripts.cpp
@@ -0,0 +1,31 @@
+/* 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/zvision.h"
+
+namespace ZVision {
+
+
+
+} // End of namespace ZVision
diff --git a/engines/zvision/single_value_container.cpp b/engines/zvision/single_value_container.cpp
new file mode 100644
index 0000000000..0fd758a85e
--- /dev/null
+++ b/engines/zvision/single_value_container.cpp
@@ -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.
+ *
+ */
+
+#include "common/scummsys.h"
+
+#include "common/textconsole.h"
+#include "common/str.h"
+
+#include "zvision/single_value_container.h"
+
+namespace ZVision {
+
+SingleValueContainer::SingleValueContainer(ValueType type) : _objectType(type) { }
+
+SingleValueContainer::SingleValueContainer(bool value) : _objectType(BOOL) {
+	_value.boolVal = value;
+}
+
+SingleValueContainer::SingleValueContainer(byte value) : _objectType(BYTE) {
+	_value.byteVal = value;
+}
+
+SingleValueContainer::SingleValueContainer(int16 value) : _objectType(INT16) {
+	_value.int16Val = value;
+}
+
+SingleValueContainer::SingleValueContainer(uint16 value) : _objectType(UINT16) {
+	_value.uint16Val = value;
+}
+
+SingleValueContainer::SingleValueContainer(int32 value) : _objectType(INT32) {
+	_value.int32Val = value;
+}
+
+SingleValueContainer::SingleValueContainer(uint32 value) : _objectType(UINT32) {
+	_value.uint32Val = value;
+}
+
+SingleValueContainer::SingleValueContainer(float value) : _objectType(FLOAT) {
+	_value.floatVal = value;
+}
+
+SingleValueContainer::SingleValueContainer(double value) : _objectType(DOUBLE) {
+	_value.doubleVal = value;
+}
+
+SingleValueContainer::SingleValueContainer(Common::String value) : _objectType(BYTE) {
+	_value.stringVal = new char[value.size() + 1];
+	memcpy(_value.stringVal, value.c_str(), value.size() + 1);
+}
+
+SingleValueContainer::SingleValueContainer(const SingleValueContainer &other) {
+	_objectType = other._objectType;
+
+	switch (_objectType) {
+	case BOOL:
+		_value.boolVal = other._value.boolVal;
+		break;
+	case BYTE:
+		_value.byteVal = other._value.byteVal;
+		break;
+	case INT16:
+		_value.int16Val = other._value.int16Val;
+		break;
+	case UINT16:
+		_value.uint16Val = other._value.uint16Val;
+		break;
+	case INT32:
+		_value.int32Val = other._value.int32Val;
+		break;
+	case UINT32:
+		_value.uint32Val = other._value.uint32Val;
+		break;
+	case FLOAT:
+		_value.floatVal = other._value.floatVal;
+		break;
+	case DOUBLE:
+		_value.doubleVal = other._value.doubleVal;
+		break;
+	case STRING:
+		uint32 length = strlen(other._value.stringVal);
+		_value.stringVal = new char[length + 1];
+		memcpy(_value.stringVal, other._value.stringVal, length + 1);
+		break;
+	}
+}
+
+SingleValueContainer::~SingleValueContainer() {
+	deleteCharPointer();
+}
+
+void SingleValueContainer::deleteCharPointer() {
+	if (_objectType == STRING)
+		delete[] _value.stringVal;
+}
+
+
+SingleValueContainer &SingleValueContainer::operator=(const bool &rhs) {
+	if (_objectType == BOOL) {
+		_value.boolVal = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = BOOL;
+	_value.boolVal = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const byte &rhs) {
+	if (_objectType == BYTE) {
+		_value.byteVal = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = BYTE;
+	_value.byteVal = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const int16 &rhs) {
+	if (_objectType == INT16) {
+		_value.int16Val = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = INT16;
+	_value.int16Val = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const uint16 &rhs) {
+	if (_objectType == UINT16) {
+		_value.uint16Val = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = UINT16;
+	_value.uint16Val = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const int32 &rhs) {
+	if (_objectType == INT32) {
+		_value.int32Val = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = INT32;
+	_value.int32Val = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const uint32 &rhs) {
+	if (_objectType == UINT32) {
+		_value.uint32Val = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = UINT32;
+	_value.uint32Val = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const float &rhs) {
+	if (_objectType == FLOAT) {
+		_value.floatVal = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = FLOAT;
+	_value.floatVal = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const double &rhs) {
+	if (_objectType == DOUBLE) {
+		_value.doubleVal = rhs;
+		return *this;
+	}
+
+	deleteCharPointer();
+	_objectType = DOUBLE;
+	_value.doubleVal = rhs;
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const Common::String &rhs) {
+	if (_objectType != STRING) {
+		_objectType = STRING;
+		_value.stringVal = new char[rhs.size() + 1];
+		memcpy(_value.stringVal, rhs.c_str(), rhs.size() + 1);
+
+		return *this;
+	}
+
+	uint32 length = strlen(_value.stringVal);
+	if (length <= rhs.size() + 1) {
+		memcpy(_value.stringVal, rhs.c_str(), rhs.size() + 1);
+	} else {
+		delete[] _value.stringVal;
+		_value.stringVal = new char[rhs.size() + 1];
+		memcpy(_value.stringVal, rhs.c_str(), rhs.size() + 1);
+	}
+
+	return *this;
+}
+
+SingleValueContainer &SingleValueContainer::operator=(const SingleValueContainer &rhs) {
+	switch (_objectType) {
+	case BOOL:
+		return operator=(rhs._value.boolVal);
+	case BYTE:
+		return operator=(rhs._value.byteVal);
+	case INT16:
+		return operator=(rhs._value.int16Val);
+	case UINT16:
+		return operator=(rhs._value.uint16Val);
+	case INT32:
+		return operator=(rhs._value.int32Val);
+	case UINT32:
+		return operator=(rhs._value.uint32Val);
+	case FLOAT:
+		return operator=(rhs._value.floatVal);
+	case DOUBLE:
+		return operator=(rhs._value.doubleVal);
+	case STRING:
+		uint32 length = strlen(rhs._value.stringVal);
+
+		_value.stringVal = new char[length + 1];
+		memcpy(_value.stringVal, rhs._value.stringVal, length + 1);
+
+		return *this;
+	}
+
+	return *this;
+}
+
+
+bool SingleValueContainer::getBoolValue(bool *returnValue) const {
+	if (_objectType !=  BOOL) {
+		warning("'Object' is not storing a bool.");
+		return false;
+	}
+
+	*returnValue = _value.boolVal;
+	return true;
+}
+
+bool SingleValueContainer::getByteValue(byte *returnValue) const {
+	if (_objectType !=  BYTE)
+		warning("'Object' is not storing a byte.");
+
+	*returnValue = _value.byteVal;
+	return true;
+}
+
+bool SingleValueContainer::getInt16Value(int16 *returnValue) const {
+	if (_objectType !=  INT16)
+		warning("'Object' is not storing an int16.");
+
+	*returnValue = _value.int16Val;
+	return true;
+}
+
+bool SingleValueContainer::getUInt16Value(uint16 *returnValue) const {
+	if (_objectType !=  UINT16)
+		warning("'Object' is not storing a uint16.");
+
+	*returnValue = _value.uint16Val;
+	return true;
+}
+
+bool SingleValueContainer::getInt32Value(int32 *returnValue) const {
+	if (_objectType !=  INT32)
+		warning("'Object' is not storing an int32.");
+
+	*returnValue = _value.int32Val;
+	return true;
+}
+
+bool SingleValueContainer::getUInt32Value(uint32 *returnValue) const {
+	if (_objectType !=  UINT32)
+		warning("'Object' is not storing a uint32.");
+
+	*returnValue = _value.uint32Val;
+	return true;
+}
+
+bool SingleValueContainer::getFloatValue(float *returnValue) const {
+	if (_objectType !=  FLOAT)
+		warning("'Object' is not storing a float.");
+
+	*returnValue = _value.floatVal;
+	return true;
+}
+
+bool SingleValueContainer::getDoubleValue(double *returnValue) const {
+	if (_objectType !=  DOUBLE)
+		warning("'Object' is not storing a double.");
+
+	*returnValue = _value.doubleVal;
+	return true;
+}
+
+bool SingleValueContainer::getStringValue(Common::String *returnValue) const {
+	if (_objectType !=  STRING)
+		warning("'Object' is not storing a Common::String.");
+
+	*returnValue = _value.stringVal;
+	return true;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/single_value_container.h b/engines/zvision/single_value_container.h
new file mode 100644
index 0000000000..45b5a89e95
--- /dev/null
+++ b/engines/zvision/single_value_container.h
@@ -0,0 +1,183 @@
+/* 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_SINGLE_VALUE_CONTAINER_H
+#define ZVISION_SINGLE_VALUE_CONTAINER_H
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+/**
+ * A generic single value storage class. It is useful for storing different 
+ * value types in a single List, Hashmap, etc.
+ */
+class SingleValueContainer {
+public:
+	enum ValueType {
+		BOOL,
+		BYTE,
+		INT16,
+		UINT16,
+		INT32,
+		UINT32,
+		FLOAT,
+		DOUBLE,
+		STRING
+	};
+
+	// Constructors
+	explicit SingleValueContainer(ValueType type);
+	explicit SingleValueContainer(bool value);
+	explicit SingleValueContainer(byte value);
+	explicit SingleValueContainer(int16 value);
+	explicit SingleValueContainer(uint16 value);
+	explicit SingleValueContainer(int32 value);
+	explicit SingleValueContainer(uint32 value);
+	explicit SingleValueContainer(float value);
+	explicit SingleValueContainer(double value);
+	explicit SingleValueContainer(Common::String value);
+
+	// Copy constructor
+	explicit SingleValueContainer(const SingleValueContainer& other);
+
+	// Destructor
+	~SingleValueContainer();
+
+private:
+	ValueType _objectType;
+
+	union {
+		bool boolVal;
+		byte byteVal;
+		int16 int16Val;
+		uint16 uint16Val;
+		int32 int32Val;
+		uint32 uint32Val;
+		float floatVal;
+		double doubleVal;
+		char *stringVal;
+	} _value;
+
+public:
+	SingleValueContainer &operator=(const bool &rhs);
+	SingleValueContainer &operator=(const byte &rhs);
+	SingleValueContainer &operator=(const int16 &rhs);
+	SingleValueContainer &operator=(const uint16 &rhs);
+	SingleValueContainer &operator=(const int32 &rhs);
+	SingleValueContainer &operator=(const uint32 &rhs);
+	SingleValueContainer &operator=(const float &rhs);
+	SingleValueContainer &operator=(const double &rhs);
+	SingleValueContainer &operator=(const Common::String &rhs);
+
+	SingleValueContainer& operator=(const SingleValueContainer &rhs);
+
+	/**
+	 * Retrieve a bool from the container. If the container is not storing a 
+	 * bool, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getBoolValue(bool *returnValue) const;
+	/**
+	 * Retrieve a byte from the container. If the container is not storing a 
+	 * byte, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getByteValue(byte *returnValue) const;
+	/**
+	 * Retrieve an int16 from the container. If the container is not storing an 
+	 * int16, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getInt16Value(int16 *returnValue) const;
+	/**
+	 * Retrieve a uint16 from the container. If the container is not storing a 
+	 * uint16, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getUInt16Value(uint16 *returnValue) const;
+	/**
+	 * Retrieve an int32 from the container. If the container is not storing an 
+	 * int32, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getInt32Value(int32 *returnValue) const;
+	/**
+	 * Retrieve a uint32 from the container. If the container is not storing a 
+	 * uint32, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getUInt32Value(uint32 *returnValue) const;
+	/**
+	 * Retrieve a float from the container. If the container is not storing a 
+	 * float, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getFloatValue(float *returnValue) const;
+	/**
+	 * Retrieve a double from the container. If the container is not storing a 
+	 * double, this will return false and display a warning().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getDoubleValue(double *returnValue) const;
+	/**
+	 * Retrieve a String from the container. If the container is not storing a 
+	 * string, this will return false and display a warning().
+	 * 
+	 * Caution: Strings are internally stored as char[]. getStringValue uses
+	 * Common::String::operator=(char *) to do the assigment, which uses both
+	 * strlen() AND memmove().
+	 *
+	 * @param returnValue    Pointer to where you want the value stored
+	 * @return               Value indicating whether the value assignment was successful
+	 */
+	bool getStringValue(Common::String *returnValue) const;
+
+private:
+	/**
+	 * Helper method for destruction and assignment. It checks to see
+	 * if the char pointer is being used, and if so calls delete on it
+	 */
+	void deleteCharPointer();
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/tests.h b/engines/zvision/tests.h
new file mode 100644
index 0000000000..14f80ed83b
--- /dev/null
+++ b/engines/zvision/tests.h
@@ -0,0 +1,54 @@
+
+namespace ZVision {
+
+void tests() {
+#if 0
+	// Video test
+	Video::VideoDecoder *videoDecoder = new ZorkAVIDecoder();
+	if (videoDecoder && videoDecoder->loadFile("zassets/temple/t000a11c.avi")) {
+		Common::List<Graphics::PixelFormat> formats;
+		formats.push_back(videoDecoder->getPixelFormat());
+		//initGraphics(640, 480, true, formats);
+
+		playVideo(videoDecoder);
+	}
+#endif
+
+	Common::File f;
+
+#if 1
+	// Image test
+
+	//initGraphics(640, 480, true, &format);
+
+	if (f.open(" zassets/global/GJDEB11C.TGA")) {
+		Graphics::TGADecoder tga;
+		if (!tga.loadStream(f))
+			error("Error while reading TGA image");
+		f.close();
+
+		const Graphics::Surface *tgaSurface = tga.getSurface();
+
+		Graphics::Surface *screen = g_system->lockScreen();
+		for (uint16 y = 0; y < tgaSurface->h; y++)
+			memcpy(screen->getBasePtr(0, y), tgaSurface->getBasePtr(0, y), tgaSurface->pitch);
+		g_system->unlockScreen();
+
+		tga.destroy();
+	}
+
+
+#endif
+
+#if 0
+	// Sound test
+	if (f.open("zassets/castle/c000h9tc.raw")) {
+		Audio::SeekableAudioStream *audioStream = makeRawZorkStream(&f, 22050, DisposeAfterUse::YES);
+		Audio::SoundHandle handle;
+		g_system->getMixer()->playStream(Audio::Mixer::kSFXSoundType, &handle, audioStream);
+	}
+
+#endif
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/utility.cpp b/engines/zvision/utility.cpp
new file mode 100644
index 0000000000..fb4fe22ff8
--- /dev/null
+++ b/engines/zvision/utility.cpp
@@ -0,0 +1,235 @@
+/* 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 "common/tokenizer.h"
+#include "common/file.h"
+
+#include "zvision/utility.h"
+#include "zvision/zvision.h"
+#include "zvision/zork_raw.h"
+
+namespace ZVision {
+
+void writeFileContentsToFile(const Common::String &sourceFile, const Common::String &destFile) {
+	Common::File f;
+	if (!f.open(sourceFile)) {
+		return;
+	}
+
+	byte* buffer = new byte[f.size()];
+	f.read(buffer, f.size());
+
+	Common::DumpFile dumpFile;
+	dumpFile.open(destFile);
+
+	dumpFile.write(buffer, f.size());
+	dumpFile.flush();
+	dumpFile.close();
+
+	delete[] buffer;
+}
+
+void trimCommentsAndWhiteSpace(Common::String *string) {
+	for (int i = string->size() - 1; i >= 0; i--) {
+		if ((*string)[i] == '#') {
+			string->erase(i);
+		}
+	}
+
+	string->trim();
+}
+
+void tryToDumpLine(const Common::String &key,
+				   Common::String &line,
+				   Common::HashMap<Common::String, byte> *count,
+				   Common::HashMap<Common::String, bool> *fileAlreadyUsed,
+				   Common::DumpFile &output) {
+	const byte numberOfExamplesPerType = 8;
+
+	if ((*count)[key] < numberOfExamplesPerType && !(*fileAlreadyUsed)[key]) {
+		output.writeString(line);
+		output.writeByte('\n');
+		(*count)[key]++;
+		(*fileAlreadyUsed)[key] = true;
+	}
+}
+
+void dumpEveryResultAction(const Common::String &destFile) {
+	Common::HashMap<Common::String, byte> count;
+	Common::HashMap<Common::String, bool> fileAlreadyUsed;
+
+	Common::DumpFile output;
+	output.open(destFile);
+
+	// Find scr files
+	Common::ArchiveMemberList list;
+	SearchMan.listMatchingMembers(list, "*.scr");
+
+	for (Common::ArchiveMemberList::iterator iter = list.begin(); iter != list.end(); ++iter) {
+		Common::SeekableReadStream *stream = (*iter)->createReadStream();
+
+		Common::String line = stream->readLine();
+		trimCommentsAndWhiteSpace(&line);
+
+		while (!stream->eos()) {
+			if (line.matchString("*:add*", true)) {
+				tryToDumpLine("add", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:animplay*", true)) {
+				tryToDumpLine("animplay", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:animpreload*", true)) {
+				tryToDumpLine("animpreload", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:animunload*", true)) {
+				tryToDumpLine("animunload", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:attenuate*", true)) {
+				tryToDumpLine("attenuate", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:assign*", true)) {
+				tryToDumpLine("assign", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:change_location*", true)) {
+				tryToDumpLine("change_location", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:crossfade*", true) && !fileAlreadyUsed["add"]) {
+				tryToDumpLine("crossfade", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:debug*", true)) {
+				tryToDumpLine("debug", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:delay_render*", true)) {
+				tryToDumpLine("delay_render", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:disable_control*", true)) {
+				tryToDumpLine("disable_control", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:disable_venus*", true)) {
+				tryToDumpLine("disable_venus", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:display_message*", true)) {
+				tryToDumpLine("display_message", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:dissolve*", true)) {
+				tryToDumpLine("dissolve", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:distort*", true)) {
+				tryToDumpLine("distort", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:enable_control*", true)) {
+				tryToDumpLine("enable_control", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:flush_mouse_events*", true)) {
+				tryToDumpLine("flush_mouse_events", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:inventory*", true)) {
+				tryToDumpLine("inventory", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:kill*", true)) {
+				tryToDumpLine("kill", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:menu_bar_enable*", true)) {
+				tryToDumpLine("menu_bar_enable", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:music*", true)) {
+				tryToDumpLine("music", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:pan_track*", true)) {
+				tryToDumpLine("pan_track", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:playpreload*", true)) {
+				tryToDumpLine("playpreload", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:preferences*", true)) {
+				tryToDumpLine("preferences", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:quit*", true)) {
+				tryToDumpLine("quit", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:random*", true)) {
+				tryToDumpLine("random", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:region*", true)) {
+				tryToDumpLine("region", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:restore_game*", true)) {
+				tryToDumpLine("restore_game", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:rotate_to*", true)) {
+				tryToDumpLine("rotate_to", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:save_game*", true)) {
+				tryToDumpLine("save_game", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:set_partial_screen*", true)) {
+				tryToDumpLine("set_partial_screen", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:set_screen*", true)) {
+				tryToDumpLine("set_screen", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:set_venus*", true)) {
+				tryToDumpLine("set_venus", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:stop*", true)) {
+				tryToDumpLine("stop", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:streamvideo*", true)) {
+				tryToDumpLine("streamvideo", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:syncsound*", true)) {
+				tryToDumpLine("syncsound", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:timer*", true)) {
+				tryToDumpLine("timer", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:ttytext*", true)) {
+				tryToDumpLine("ttytext", line, &count, &fileAlreadyUsed, output);
+			} else if (line.matchString("*:universe_music*", true)) {
+				tryToDumpLine("universe_music", line, &count, &fileAlreadyUsed, output);
+			}
+
+			line = stream->readLine();
+			trimCommentsAndWhiteSpace(&line);
+		}
+
+		for (Common::HashMap<Common::String, bool>::iterator fileUsedIter = fileAlreadyUsed.begin(); fileUsedIter != fileAlreadyUsed.end(); ++fileUsedIter) {
+			fileUsedIter->_value = false;
+		}
+	}
+
+	output.close();
+}
+
+Common::String getFileName(const Common::String &fullPath) {
+	Common::StringTokenizer tokenizer(fullPath, "/\\");
+	Common::String token;
+	while (!tokenizer.empty()) {
+		token = tokenizer.nextToken();
+	}
+
+	return token;
+}
+
+void convertRawToWav(const Common::String &inputFile, ZVision *engine, const Common::String &outputFile) {
+	Common::File file;
+	if (!file.open(inputFile))
+		return;
+
+	Audio::AudioStream *audioStream = makeRawZorkStream(inputFile, engine);
+	
+	Common::DumpFile output;
+	output.open(outputFile);
+
+	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());
+	output.write(buffer, file.size() * 2);
+
+	delete[] buffer;
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/utility.h b/engines/zvision/utility.h
new file mode 100644
index 0000000000..3348a43fe3
--- /dev/null
+++ b/engines/zvision/utility.h
@@ -0,0 +1,100 @@
+/* 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_UTILITY_H
+#define ZVISION_UTILITY_H
+
+#include "common/array.h"
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+class ZVision;
+
+/**
+ * Opens the sourceFile utilizing Common::File (aka SearchMan) and writes the
+ * contents to destFile. destFile is created in the working directory
+ *
+ * @param sourceFile    The 'file' you want the contents of
+ * @param destFile      The name of the file where the content will be written to
+ */
+void writeFileContentsToFile(const Common::String &sourceFile, const Common::String &destFile);
+
+/**
+ * Removes any line comments using '#' as a sequence start.
+ * Then removes any trailing and leading 'whitespace' using String::trim()
+ * Note: String::trim uses isspace() to determine what is whitespace and what is not.
+ *
+ * @param string    The string to modify. It is modified in place
+ */
+void trimCommentsAndWhiteSpace(Common::String *string);
+
+/**
+ * Searches through all the .scr files and dumps 'numberOfExamplesPerType' examples of each type of ResultAction
+ * ZVision::initialize() must have been called before this function can be used.
+ *
+ * @param destFile    Where to write the examples
+ */
+void dumpEveryResultAction(const Common::String &destFile);
+
+/**
+ * Removes all duplicate entries from container.
+ *
+ * @param container        
+ * @return                
+ */
+template<class T>
+void removeDuplicateEntries(Common::Array<T> &container) {
+	Common::sort(container.begin(), container.end());
+
+	for (uint i = 0; i + 1 < container.size(); i++) {
+		while (i + 1 < container.size() && container[i] == container[i + 1]) {
+			container.remove_at(i + 1);
+		}
+	}
+}
+
+/**
+ * Gets the name of the file (including extension). Forward or back slashes 
+ * are interpreted as directory changes
+ *
+ * @param fullPath    A full or partial path to the file. Ex: folderOne/folderTwo/file.txt
+ * @return            The name of the file without any preceding directories. Ex: file.txt
+ */
+Common::String getFileName(const Common::String &fullPath);
+
+/**
+ * Converts a ZVision .RAW file to a .WAV
+ * The .WAV will be created in the working directory and will overwrite any existing file
+ *
+ * @param inputFile     The path to the input .RAW file
+ * @param outputFile    The name of the output .WAV file
+ */
+void convertRawToWav(const Common::String &inputFile, ZVision *engine, const Common::String &outputFile);
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/vector2.h b/engines/zvision/vector2.h
new file mode 100644
index 0000000000..575915c87d
--- /dev/null
+++ b/engines/zvision/vector2.h
@@ -0,0 +1,79 @@
+/* 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_VECTOR2_H
+#define ZVISION_VECTOR2_H
+
+#include "common/scummsys.h"
+
+namespace ZVision {
+
+/**
+ * Simple class for handling both 2D position and size.
+ */
+class Vector2 {
+public:
+	int16 x;	///< The horizontal part of the point
+	int16 y;	///< The vertical part of the point
+
+public:
+	Vector2() : x(0), y(0) {}
+	Vector2(int16 x1, int16 y1) : x(x1), y(y1) {}
+
+public:
+	bool operator==(const Vector2 &p) const { return x == p.x && y == p.y; }
+	bool operator!=(const Vector2 &p) const { return x != p.x || y != p.y; }
+	Vector2 operator+(const Vector2 &delta) const {	return Vector2(x + delta.x, y + delta.y);	}
+	Vector2 operator-(const Vector2 &delta) const {	return Vector2(x - delta.x, y - delta.y);	}
+
+	void operator+=(const Vector2 &delta) {
+		x += delta.x;
+		y += delta.y;
+	}
+
+	void operator-=(const Vector2 &delta) {
+		x -= delta.x;
+		y -= delta.y;
+	}
+
+	/**
+	 * Return the square of the distance between this point and the point p.
+	 *
+	 * @param p		the other point
+	 * @return the distance between this and p
+	 */
+	uint sqrDist(const Vector2 &p) const {
+		int diffx = ABS(p.x - x);
+		if (diffx >= 0x1000)
+			return 0xFFFFFF;
+
+		int diffy = ABS(p.y - y);
+		if (diffy >= 0x1000)
+			return 0xFFFFFF;
+
+		return uint(diffx * diffx + diffy * diffy);
+	}
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/video.cpp b/engines/zvision/video.cpp
new file mode 100644
index 0000000000..5497d0af0c
--- /dev/null
+++ b/engines/zvision/video.cpp
@@ -0,0 +1,174 @@
+/* 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 "common/system.h"
+#include "video/video_decoder.h"
+#include "engines/util.h"
+#include "graphics/surface.h"
+
+#include "zvision/clock.h"
+#include "zvision/render_manager.h"
+#include "zvision/zvision.h"
+
+
+namespace ZVision {
+
+// Taken/modified from SCI
+void scaleBuffer(const byte *src, byte *dst, uint32 srcWidth, uint32 srcHeight, byte bytesPerPixel, uint scaleAmount) {
+	assert(bytesPerPixel == 1 || bytesPerPixel == 2);
+
+	const uint32 newWidth = srcWidth * scaleAmount;
+	const uint32 pitch = newWidth * bytesPerPixel;
+	const byte *srcPtr = src;
+
+	if (bytesPerPixel == 1) {
+		for (uint32 y = 0; y < srcHeight; y++) {
+			for (uint32 x = 0; x < srcWidth; x++) {
+				const byte color = *srcPtr++;
+
+				for (uint i = 0; i < scaleAmount; i++) {
+					dst[i] = color;
+					dst[pitch + i] = color;
+				}
+				dst += scaleAmount;
+			}
+			dst += pitch;
+		}
+	} else if (bytesPerPixel == 2) {
+		for (uint32 y = 0; y < srcHeight; y++) {
+			for (uint32 x = 0; x < srcWidth; x++) {
+				const byte color = *srcPtr++;
+				const byte color2 = *srcPtr++;
+
+				for (uint i = 0; i < scaleAmount; i++) {
+					uint index = i *2;
+
+					dst[index] = color;
+					dst[index + 1] = color2;
+					dst[pitch + index] = color;
+					dst[pitch + index + 1] = color2;
+				}
+				dst += 2 * scaleAmount;
+			}
+			dst += pitch;
+		}
+	}
+}
+
+void ZVision::playVideo(Video::VideoDecoder &videoDecoder, const Common::Rect &destRect, bool skippable) {
+	// Videos use a different pixel format
+	Common::List<Graphics::PixelFormat> formats;
+	formats.push_back(videoDecoder.getPixelFormat());
+	initGraphics(WINDOW_WIDTH, WINDOW_HEIGHT, true, formats);
+
+	byte bytesPerPixel = videoDecoder.getPixelFormat().bytesPerPixel;
+
+	uint16 origWidth = videoDecoder.getWidth();
+	uint16 origHeight = videoDecoder.getHeight();
+
+	uint scale = 1;
+	// If destRect is empty, no specific scaling was requested. However, we may choose to do scaling anyway
+	if (destRect.isEmpty()) {
+		// Most videos are very small. Therefore we do a simple 2x scale
+		if (origWidth * 2 <= 640 && origHeight * 2 <= 480) {
+			scale = 2;
+		}
+	} else {
+		// Assume bilinear scaling. AKA calculate the scale from just the width.
+		// Also assume that the scaling is in integral intervals. AKA no 1.5x scaling
+		// TODO: Test ^these^ assumptions
+		scale = destRect.width() / origWidth;
+
+		// TODO: Test if we need to support downscale.
+	}
+
+	uint16 pitch = origWidth * bytesPerPixel;
+
+	uint16 finalWidth = origWidth * scale;
+	uint16 finalHeight = origHeight * scale;
+
+	byte *scaledVideoFrameBuffer;
+	if (scale != 1) {
+		scaledVideoFrameBuffer = new byte[finalWidth * finalHeight * bytesPerPixel];
+	}
+
+	uint16 x = ((WINDOW_WIDTH - finalWidth) / 2) + destRect.left;
+	uint16 y = ((WINDOW_HEIGHT - finalHeight) / 2) + destRect.top;
+
+	_clock.stop();
+	videoDecoder.start();
+
+	// Only continue while the video is still playing
+	while (!shouldQuit() && !videoDecoder.endOfVideo() && videoDecoder.isPlaying()) {
+		// Check for engine quit and video stop key presses
+		while (!videoDecoder.endOfVideo() && videoDecoder.isPlaying() && _eventMan->pollEvent(_event)) {
+			switch (_event.type) {
+			case Common::EVENT_KEYDOWN:
+				switch (_event.kbd.keycode) {
+				case Common::KEYCODE_q:
+					if (_event.kbd.hasFlags(Common::KBD_CTRL))
+						quitGame();
+					break;
+				case Common::KEYCODE_SPACE:
+					if (skippable) {
+						videoDecoder.stop();
+					}
+					break;
+				default:
+					break;
+				}
+			default:
+				break;
+			}
+		}
+
+		if (videoDecoder.needsUpdate()) {
+			const Graphics::Surface *frame = videoDecoder.decodeNextFrame();
+
+			if (frame) {
+				if (scale != 1) {
+					scaleBuffer((byte *)frame->pixels, scaledVideoFrameBuffer, origWidth, origHeight, bytesPerPixel, scale);
+					_system->copyRectToScreen(scaledVideoFrameBuffer, pitch * 2, x, y, finalWidth, finalHeight);
+				} else {
+					_system->copyRectToScreen((byte *)frame->pixels, pitch, x, y, finalWidth, finalHeight);
+				}
+
+				_system->updateScreen();
+			}
+		}
+
+		_system->delayMillis(videoDecoder.getTimeToNextFrame());
+	}
+
+	_clock.start();
+
+	if (scale != 1) {
+		delete[] scaledVideoFrameBuffer;
+	}
+
+	// Reset the pixel format to the original state
+	initGraphics(WINDOW_WIDTH, WINDOW_HEIGHT, true, &_pixelFormat);
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/zfs_archive.cpp b/engines/zvision/zfs_archive.cpp
new file mode 100644
index 0000000000..3577ce3d14
--- /dev/null
+++ b/engines/zvision/zfs_archive.cpp
@@ -0,0 +1,158 @@
+/* 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 "common/hashmap.h"
+#include "common/memstream.h"
+#include "common/debug.h"
+#include "common/file.h"
+
+#include "zvision/zfs_archive.h"
+
+namespace ZVision {
+
+ZfsArchive::ZfsArchive(const Common::String &fileName) : _fileName(fileName) {
+	Common::File zfsFile;
+
+	if (!zfsFile.open(_fileName)) {
+		warning("ZFSArchive::ZFSArchive(): Could not find the archive file");
+		return;
+	}
+
+	readHeaders(&zfsFile);
+
+	debug(0, "ArjArchive::ArjArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
+}
+
+ZfsArchive::ZfsArchive(const Common::String &fileName, Common::SeekableReadStream *stream) : _fileName(fileName) {
+	readHeaders(stream);
+
+	debug(0, "ArjArchive::ArjArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
+}
+
+ZfsArchive::~ZfsArchive() {
+	debug(0, "ZfsArchive Destructor Called");
+	ZfsEntryHeaderMap::iterator it = _entryHeaders.begin();
+	for ( ; it != _entryHeaders.end(); ++it) {
+		delete it->_value;
+	}
+}
+
+void ZfsArchive::readHeaders(Common::SeekableReadStream *stream) {
+	// Don't do a straight struct cast since we can't guarantee endianness
+	_header.magic = stream->readUint32LE();
+	_header.unknown1 = stream->readUint32LE();
+	_header.maxNameLength = stream->readUint32LE();
+	_header.filesPerBlock = stream->readUint32LE();
+	_header.fileCount = stream->readUint32LE();
+	_header.xorKey[0] = stream->readByte();
+	_header.xorKey[1] = stream->readByte();
+	_header.xorKey[2] = stream->readByte();
+	_header.xorKey[3] = stream->readByte();
+	_header.fileSectionOffset = stream->readUint32LE();
+
+	uint32 nextOffset;
+
+	do {
+		// Read the offset to the next block
+		nextOffset = stream->readUint32LE();
+
+		// Read in each entry header
+		for (uint32 i = 0; i < _header.filesPerBlock; i++) {
+			ZfsEntryHeader entryHeader;
+			
+			entryHeader.name = readEntryName(stream);
+			entryHeader.offset = stream->readUint32LE();
+			entryHeader.id = stream->readUint32LE();
+			entryHeader.size = stream->readUint32LE();
+			entryHeader.time = stream->readUint32LE();
+			entryHeader.unknown = stream->readUint32LE();
+
+			if (entryHeader.size != 0)
+				_entryHeaders[entryHeader.name] = new ZfsEntryHeader(entryHeader);
+		}
+
+		// Seek to the next block of headers
+		stream->seek(nextOffset);
+	} while (nextOffset != 0);
+}
+
+Common::String ZfsArchive::readEntryName(Common::SeekableReadStream *stream) const {
+	// Entry Names are at most 16 bytes and are null padded
+	char buffer[16];
+	stream->read(buffer, 16);
+
+	return Common::String(buffer);
+}
+
+bool ZfsArchive::hasFile(const Common::String &name) const {
+	return _entryHeaders.contains(name);
+}
+
+int ZfsArchive::listMembers(Common::ArchiveMemberList &list) const {
+	int matches = 0;
+
+	for (ZfsEntryHeaderMap::const_iterator it = _entryHeaders.begin(); it != _entryHeaders.end(); ++it) {
+		list.push_back(Common::ArchiveMemberList::value_type(new Common::GenericArchiveMember(it->_value->name, this)));
+		matches++;
+	}
+
+	return matches;
+}
+
+const Common::ArchiveMemberPtr ZfsArchive::getMember(const Common::String &name) const {
+	if (!_entryHeaders.contains(name))
+		return Common::ArchiveMemberPtr();
+
+	return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this));
+}
+
+Common::SeekableReadStream *ZfsArchive::createReadStreamForMember(const Common::String &name) const {
+	if (!_entryHeaders.contains(name)) {
+		return 0;
+	}
+
+	ZfsEntryHeader *entryHeader = _entryHeaders[name];
+
+	Common::File zfsArchive;
+	zfsArchive.open(_fileName);
+	zfsArchive.seek(entryHeader->offset);
+
+	// This *HAS* to be malloc (not new[]) because MemoryReadStream uses free() to free the memory
+	byte* buffer = (byte *)malloc(entryHeader->size);
+	zfsArchive.read(buffer, entryHeader->size);
+	// Decrypt the data in place
+	if (_header.xorKey != 0)
+		unXor(buffer, entryHeader->size, _header.xorKey);
+
+	return new Common::MemoryReadStream(buffer, entryHeader->size, DisposeAfterUse::YES);
+}
+
+void ZfsArchive::unXor(byte *buffer, uint32 length, const byte *xorKey) const {
+	for (uint32 i = 0; i < length; i++)
+		buffer[i] ^= xorKey[i % 4];
+}
+
+} // End of namespace ZVision
+
+
diff --git a/engines/zvision/zfs_archive.h b/engines/zvision/zfs_archive.h
new file mode 100644
index 0000000000..3bf492578c
--- /dev/null
+++ b/engines/zvision/zfs_archive.h
@@ -0,0 +1,125 @@
+/* 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_ZFS_ARCHIVE_H
+#define ZVISION_ZFS_ARCHIVE_H
+
+#include "common/archive.h"
+#include "common/hashmap.h"
+
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+struct ZfsHeader {
+	uint32 magic;
+	uint32 unknown1;
+	uint32 maxNameLength;
+	uint32 filesPerBlock;
+	uint32 fileCount;
+	byte xorKey[4];
+	uint32 fileSectionOffset;
+};
+
+struct ZfsEntryHeader {
+	Common::String name;
+	uint32 offset;
+	uint32 id;
+	uint32 size;
+	uint32 time;
+	uint32 unknown;
+};
+
+typedef Common::HashMap<Common::String, ZfsEntryHeader*, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> ZfsEntryHeaderMap;
+
+class ZfsArchive : public Common::Archive {
+public:
+	ZfsArchive(const Common::String &fileName);
+	ZfsArchive(const Common::String &fileName, Common::SeekableReadStream *stream);
+	~ZfsArchive();
+
+	/**
+	 * Check if a member with the given name is present in the Archive.
+	 * Patterns are not allowed, as this is meant to be a quick File::exists()
+	 * replacement.
+	 */
+	bool hasFile(const Common::String &fileName) const;
+
+	/**
+	 * Add all members of the Archive to list.
+	 * Must only append to list, and not remove elements from it.
+	 *
+	 * @return    The number of names added to list
+	 */
+	int listMembers(Common::ArchiveMemberList &list) const;
+
+	/**
+	 * Returns a ArchiveMember representation of the given file.
+	 */
+	const Common::ArchiveMemberPtr getMember(const Common::String &name) const;
+
+	/**
+	 * Create a stream bound to a member with the specified name in the
+	 * archive. If no member with this name exists, 0 is returned.
+	 *
+	 * @return    The newly created input stream
+	 */
+	Common::SeekableReadStream *createReadStreamForMember(const Common::String &name) const;
+
+private:
+	const Common::String _fileName;
+	ZfsHeader _header;
+	ZfsEntryHeaderMap _entryHeaders;
+
+	/**
+	 * Parses the zfs file into file entry headers that can be used later
+	 * to get the entry data.
+	 *
+	 * @param stream    The contents of the zfs file
+	 */
+	void readHeaders(Common::SeekableReadStream *stream);
+
+	/**
+	 * Entry names are contained within a 16 byte block. This reads the block
+	 * and converts it the name to a Common::String
+	 *
+	 * @param stream    The zfs file stream
+	 * @return          The entry file name
+	 */
+	Common::String readEntryName(Common::SeekableReadStream *stream) const;
+
+	/**
+	 * ZFS file entries can be encrypted using XOR encoding. This method
+	 * decodes the buffer in place using the supplied xorKey.
+	 *
+	 * @param buffer    The data to decode
+	 * @param length    Length of buffer
+	 */
+	void unXor(byte *buffer, uint32 length, const byte *xorKey) const;
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/zork_avi_decoder.cpp b/engines/zvision/zork_avi_decoder.cpp
new file mode 100644
index 0000000000..d9b9511175
--- /dev/null
+++ b/engines/zvision/zork_avi_decoder.cpp
@@ -0,0 +1,50 @@
+/* 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 "common/stream.h"
+#include "audio/audiostream.h"
+
+#include "zvision/zork_avi_decoder.h"
+#include "zvision/zork_raw.h"
+
+namespace ZVision {
+
+Video::AVIDecoder::AVIAudioTrack *ZorkAVIDecoder::createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo) {
+	ZorkAVIDecoder::ZorkAVIAudioTrack *audioTrack = new ZorkAVIDecoder::ZorkAVIAudioTrack(sHeader, wvInfo, _soundType);
+	return (Video::AVIDecoder::AVIAudioTrack *)audioTrack;
+}
+
+void ZorkAVIDecoder::ZorkAVIAudioTrack::queueSound(Common::SeekableReadStream *stream) {
+	if (_audStream) {
+		if (_wvInfo.tag == kWaveFormatZorkPCM) {
+			assert(_wvInfo.size == 8);
+			_audStream->queueAudioStream(makeRawZorkStream(stream, _wvInfo.samplesPerSec, _audStream->isStereo(), DisposeAfterUse::YES), DisposeAfterUse::YES);
+		}
+	} else {
+		delete stream;
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/zork_avi_decoder.h b/engines/zvision/zork_avi_decoder.h
new file mode 100644
index 0000000000..1ce2508828
--- /dev/null
+++ b/engines/zvision/zork_avi_decoder.h
@@ -0,0 +1,59 @@
+/* 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 ZORK_AVI_DECODER_H
+#define ZORK_AVI_DECODER_H
+
+#include "video/avi_decoder.h"
+ 
+namespace ZVision {
+
+class ZorkAVIDecoder : public Video::AVIDecoder {
+public:
+	ZorkAVIDecoder(Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType) :
+	  Video::AVIDecoder(soundType) {}
+
+	  virtual ~ZorkAVIDecoder() {}
+
+private:
+	class ZorkAVIAudioTrack : public Video::AVIDecoder::AVIAudioTrack {
+	public:
+		ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType) :
+			Video::AVIDecoder::AVIAudioTrack(streamHeader, waveFormat, soundType) {}
+		virtual ~ZorkAVIAudioTrack() {}
+
+		void queueSound(Common::SeekableReadStream *stream);
+	};
+
+	Video::AVIDecoder::AVIAudioTrack *createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo);
+
+private:
+	// Audio Codecs
+	enum {
+		kWaveFormatZorkPCM = 17	// special Zork PCM audio format (clashes with MS IMA ADPCM)
+	};
+};
+
+} // End of namespace ZVision
+ 
+#endif
diff --git a/engines/zvision/zork_raw.cpp b/engines/zvision/zork_raw.cpp
new file mode 100644
index 0000000000..92f659203b
--- /dev/null
+++ b/engines/zvision/zork_raw.cpp
@@ -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.
+ *
+ */
+
+#include "common/scummsys.h"
+
+#include "common/file.h"
+#include "common/str.h"
+#include "common/stream.h"
+#include "common/memstream.h"
+#include "common/bufferedstream.h"
+#include "common/util.h"
+#include "audio/audiostream.h"
+#include "audio/decoders/raw.h"
+
+#include "zvision/zork_raw.h"
+#include "zvision/zvision.h"
+#include "zvision/detection.h"
+#include "zvision/utility.h"
+
+namespace ZVision {
+
+const int16 RawZorkStream::_stepAdjustmentTable[8] = {-1, -1, -1, 1, 4, 7, 10, 12};
+
+const int32 RawZorkStream::_amplitudeLookupTable[89] = {0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E,
+                                                        0x0010, 0x0011, 0x0013, 0x0015, 0x0017, 0x0019, 0x001C, 0x001F,
+                                                        0x0022, 0x0025, 0x0029, 0x002D, 0x0032, 0x0037, 0x003C, 0x0042,
+                                                        0x0049, 0x0050, 0x0058, 0x0061, 0x006B, 0x0076, 0x0082, 0x008F,
+                                                        0x009D, 0x00AD, 0x00BE, 0x00D1, 0x00E6, 0x00FD, 0x0117, 0x0133, 
+                                                        0x0151, 0x0173, 0x0198, 0x01C1, 0x01EE, 0x0220, 0x0256, 0x0292,
+                                                        0x02D4, 0x031C, 0x036C, 0x03C3, 0x0424, 0x048E, 0x0502, 0x0583, 
+                                                        0x0610, 0x06AB, 0x0756, 0x0812, 0x08E0, 0x09C3, 0x0ABD, 0x0BD0,
+                                                        0x0CFF, 0x0E4C, 0x0FBA, 0x114C, 0x1307, 0x14EE, 0x1706, 0x1954, 
+                                                        0x1BDC, 0x1EA5, 0x21B6, 0x2515, 0x28CA, 0x2CDF, 0x315B, 0x364B,
+                                                        0x3BB9, 0x41B2, 0x4844, 0x4F7E, 0x5771, 0x602F, 0x69CE, 0x7462, 0x7FFF};
+
+RawZorkStream::RawZorkStream(uint32 rate, bool stereo, DisposeAfterUse::Flag disposeStream, Common::SeekableReadStream *stream)
+		: _rate(rate),
+		  _stereo(0),
+		  _stream(stream, disposeStream),
+		  _endOfData(false) {
+	if (stereo)
+		_stereo = 1;
+
+	_lastSample[0].index = 0;
+	_lastSample[0].sample = 0;
+	_lastSample[1].index = 0;
+	_lastSample[1].sample = 0;
+
+	// Calculate the total playtime of the stream
+	if (stereo)
+		_playtime = Audio::Timestamp(0, _stream->size() / 2, rate);
+	else
+		_playtime = Audio::Timestamp(0, _stream->size(), rate);
+}
+
+int RawZorkStream::readBuffer(int16 *buffer, const int numSamples) {
+	int bytesRead = 0;
+
+	// 0: Left, 1: Right
+	uint channel = 0;
+
+	while (bytesRead < numSamples) {
+		byte encodedSample = _stream->readByte();
+		if (_stream->eos()) {
+			_endOfData = true;
+			return bytesRead;
+		}
+		bytesRead++;
+
+		int16 index = _lastSample[channel].index;
+		uint32 lookUpSample = _amplitudeLookupTable[index];
+
+		int32 sample = 0;
+
+		if (encodedSample & 0x40)
+			sample += lookUpSample;
+		if (encodedSample & 0x20)
+			sample += lookUpSample >> 1;
+		if (encodedSample & 0x10)
+			sample += lookUpSample >> 2;
+		if (encodedSample & 8)
+			sample += lookUpSample >> 3;
+		if (encodedSample & 4)
+			sample += lookUpSample >> 4;
+		if (encodedSample & 2)
+			sample += lookUpSample >> 5;
+		if (encodedSample & 1)
+			sample += lookUpSample >> 6;
+		if (encodedSample & 0x80)
+			sample = -sample;
+
+		sample += _lastSample[channel].sample;
+		sample = CLIP(sample, -32768, 32767);
+
+		buffer[bytesRead - 1] = (int16)sample;
+
+		index += _stepAdjustmentTable[(encodedSample >> 4) & 7];
+		index = CLIP<int16>(index, 0, 88);
+
+		_lastSample[channel].sample = sample;
+		_lastSample[channel].index = index;
+
+		// Increment and wrap the channel
+		channel = (channel + 1) & _stereo;
+	}
+
+	return bytesRead;
+}
+
+bool RawZorkStream::rewind() {
+	_stream->seek(0, 0);
+	_stream->clearErr();
+	_endOfData = false;
+	_lastSample[0].index = 0;
+	_lastSample[0].sample = 0;
+	_lastSample[1].index = 0;
+	_lastSample[1].sample = 0;
+
+	return true;
+}
+
+Audio::RewindableAudioStream *makeRawZorkStream(Common::SeekableReadStream *stream,
+                                                int rate,
+								                bool stereo,
+                                                DisposeAfterUse::Flag disposeAfterUse) {
+	if (stereo)
+		assert(stream->size() % 2 == 0);
+
+	return new RawZorkStream(rate, stereo, disposeAfterUse, stream);
+}
+
+Audio::RewindableAudioStream *makeRawZorkStream(const byte *buffer, uint32 size,
+                                                int rate,
+								                bool stereo,
+                                                DisposeAfterUse::Flag disposeAfterUse) {
+	return makeRawZorkStream(new Common::MemoryReadStream(buffer, size, disposeAfterUse), rate, stereo, DisposeAfterUse::YES);
+}
+
+Audio::RewindableAudioStream *makeRawZorkStream(const Common::String &filePath, ZVision *engine) {
+	Common::File *file = new Common::File();
+	assert(file->open(filePath));
+
+	Common::String fileName = getFileName(filePath);
+	fileName.toLowercase();
+
+	SoundParams soundParams;
+
+	if (engine->getGameId() == ZorkNemesis) {
+		for (int i = 0; i < 6; i++) {
+			if (zNemSoundParamLookupTable[i].identifier == (fileName[6]))
+				soundParams = zNemSoundParamLookupTable[i];
+		}
+	}
+	else if (engine->getGameId() == ZorkGrandInquisitor) {
+		for (int i = 0; i < 6; i++) {
+			if (zgiSoundParamLookupTable[i].identifier == (fileName[7]))
+				soundParams = zgiSoundParamLookupTable[i];
+		}
+	}
+	
+	if (soundParams.packed) {
+		return makeRawZorkStream(wrapBufferedSeekableReadStream(file, 2048, DisposeAfterUse::YES), soundParams.rate, soundParams.stereo, DisposeAfterUse::YES);
+	} else {
+		byte flags = 0;
+		if (soundParams.stereo)
+			flags |= Audio::FLAG_STEREO;
+
+		return Audio::makeRawStream(file, soundParams.rate, flags, DisposeAfterUse::YES);
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/zork_raw.h b/engines/zvision/zork_raw.h
new file mode 100644
index 0000000000..f19ffc1661
--- /dev/null
+++ b/engines/zvision/zork_raw.h
@@ -0,0 +1,133 @@
+/* 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_ZORK_RAW_H
+#define ZVISION_ZORK_RAW_H
+
+#include "common/types.h"
+#include "audio/audiostream.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace ZVision {
+
+class ZVision;
+
+struct SoundParams {
+	char identifier;
+	uint32 rate;
+	bool stereo;
+	bool packed;
+};
+
+const SoundParams zNemSoundParamLookupTable[6] = {{'6', 0x2B11, false, false},
+                                                  {'a', 0x5622, false,  true}, 
+                                                  {'b', 0x5622, true,  true},
+                                                  {'n', 0x2B11, false, true},
+                                                  {'s', 0x5622, false, true},
+                                                  {'t', 0x5622, true, true}
+};
+
+const SoundParams zgiSoundParamLookupTable[5] = {{'a',0x5622, false, false},
+                                                 {'k',0x2B11, true, true},
+                                                 {'p',0x5622, false, true},
+                                                 {'q',0x5622, true, true},
+                                                 {'u',0xAC44, true, true}
+};
+
+/**
+ * This is a stream, which allows for playing raw ADPCM data from a stream.
+ */
+class RawZorkStream : public Audio::RewindableAudioStream {
+public:
+	RawZorkStream(uint32 rate, bool stereo, DisposeAfterUse::Flag disposeStream, Common::SeekableReadStream *stream);
+
+	~RawZorkStream() {
+	}
+
+public:
+
+private:
+	const int _rate;                                           // Sample rate of stream
+	Audio::Timestamp _playtime;                                // Calculated total play time
+	Common::DisposablePtr<Common::SeekableReadStream> _stream; // Stream to read data from
+	bool _endOfData;                                           // Whether the stream end has been reached
+	uint _stereo;
+
+	/** 
+	 * Holds the frequency and index from the last sample
+	 * 0 holds the left channel, 1 holds the right channel
+	 */
+	struct {
+		int32 sample;
+		int16 index;
+	} _lastSample[2];
+
+	static const int16 _stepAdjustmentTable[8];
+	static const int32 _amplitudeLookupTable[89];
+
+public:
+	int readBuffer(int16 *buffer, const int numSamples);
+
+	bool isStereo() const { return true; }
+	bool endOfData() const { return _endOfData; }
+
+	int getRate() const { return _rate; }
+	Audio::Timestamp getLength() const { return _playtime; }
+
+	bool rewind();
+};
+
+/**
+ * Creates an audio stream, which plays from the given buffer.
+ *
+ * @param buffer Buffer to play from.
+ * @param size   Size of the buffer in bytes.
+ * @param rate   Rate of the sound data.
+ * @param disposeAfterUse Whether to free the buffer after use (with free!).
+ * @return The new SeekableAudioStream (or 0 on failure).
+ */
+Audio::RewindableAudioStream *makeRawZorkStream(const byte *buffer, uint32 size,
+                                                int rate,
+								                bool stereo,
+                                                DisposeAfterUse::Flag disposeAfterUse = DisposeAfterUse::YES);
+
+/**
+ * Creates an audio stream, which plays from the given stream.
+ *
+ * @param stream Stream object to play from.
+ * @param rate   Rate of the sound data.
+ * @param disposeAfterUse Whether to delete the stream after use.
+ * @return The new SeekableAudioStream (or 0 on failure).
+ */
+Audio::RewindableAudioStream *makeRawZorkStream(Common::SeekableReadStream *stream,
+                                                int rate,
+								                bool stereo,
+                                                DisposeAfterUse::Flag disposeAfterUse = DisposeAfterUse::YES);
+
+Audio::RewindableAudioStream *makeRawZorkStream(const Common::String &filePath, ZVision *engine);
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/zvision.cpp b/engines/zvision/zvision.cpp
new file mode 100644
index 0000000000..2090d8abfe
--- /dev/null
+++ b/engines/zvision/zvision.cpp
@@ -0,0 +1,238 @@
+/* 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 "common/config-manager.h"
+#include "common/debug.h"
+#include "common/debug-channels.h"
+#include "common/textconsole.h"
+#include "common/error.h"
+#include "common/system.h"
+#include "common/file.h"
+
+#include "engines/util.h"
+
+#include "audio/mixer.h"
+ 
+#include "zvision/zvision.h"
+#include "zvision/console.h"
+#include "zvision/script_manager.h"
+#include "zvision/render_manager.h"
+#include "zvision/cursor_manager.h"
+#include "zvision/zfs_archive.h"
+#include "zvision/detection.h"
+
+#include "zvision/utility.h"
+
+namespace ZVision {
+ 
+ZVision::ZVision(OSystem *syst, const ZVisionGameDescription *gameDesc)
+		: Engine(syst),
+		  _gameDescription(gameDesc),
+		  _workingWindow((WINDOW_WIDTH - WORKING_WINDOW_WIDTH) / 2, (WINDOW_HEIGHT - WORKING_WINDOW_HEIGHT) / 2, ((WINDOW_WIDTH - WORKING_WINDOW_WIDTH) / 2) + WORKING_WINDOW_WIDTH, ((WINDOW_HEIGHT - WORKING_WINDOW_HEIGHT) / 2) + WORKING_WINDOW_HEIGHT),
+		  _pixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0), /*RGB 555*/
+		  _desiredFrameTime(33), /* ~30 fps */
+		  _clock(_system) {
+	// Put your engine in a sane state, but do nothing big yet;
+	// in particular, do not load data from files; rather, if you
+	// need to do such things, do them from run().
+ 
+	// Do not initialize graphics here
+ 
+	// Here is the right place to set up the engine specific debug channels
+	//DebugMan.addDebugChannel(kZVisionDebugExample, "example", "this is just an example for a engine specific debug channel");
+	//DebugMan.addDebugChannel(kZVisionDebugExample2, "example2", "also an example");
+ 
+	// Register random source
+	_rnd = new Common::RandomSource("zvision");
+
+	// Create managers
+	_scriptManager = new ScriptManager(this);
+	_renderManager = new RenderManager(_system, _workingWindow);
+	_cursorManager = new CursorManager(this, &_pixelFormat);
+
+	debug("ZVision::ZVision");
+}
+
+ZVision::~ZVision() {
+	debug("ZVision::~ZVision");
+ 
+	// Dispose of resources
+	delete _console;
+	delete _cursorManager;
+	delete _renderManager;
+	delete _scriptManager;
+	delete _rnd;
+ 
+	// Remove all of our debug levels
+	DebugMan.clearAllDebugChannels();
+}
+
+void ZVision::initialize() {
+	const Common::FSNode gameDataDir(ConfMan.get("path"));
+	// TODO: There are 10 file clashes when we flatten the directories. From a quick look, the files are exactly the same, so it shouldn't matter. But I'm noting it here just in-case it does become a problem.
+	SearchMan.addSubDirectoryMatching(gameDataDir, "data1", 0, 4, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "data2", 0, 4, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "data3", 0, 4, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "zassets1", 0, 2, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "zassets2", 0, 2, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "znemmx", 0, 1, true);
+	SearchMan.addSubDirectoryMatching(gameDataDir, "zgi", 0, 4, true);
+
+	// Find zfs archive files
+	Common::ArchiveMemberList list;
+	SearchMan.listMatchingMembers(list, "*.zfs");
+
+	// Register the file entries within the zfs archives with the SearchMan
+	for (Common::ArchiveMemberList::iterator iter = list.begin(); iter != list.end(); ++iter) {
+		Common::String name = (*iter)->getName();
+		Common::SeekableReadStream *stream = (*iter)->createReadStream();
+		ZfsArchive *archive = new ZfsArchive(name, stream);
+
+		delete stream;
+
+		SearchMan.add(name, archive);
+	}
+
+	initGraphics(WINDOW_WIDTH, WINDOW_HEIGHT, true, &_pixelFormat);
+
+	_cursorManager->initialize();
+	_scriptManager->initialize();
+
+	// Create debugger console. It requires GFX to be initialized
+	_console = new Console(this);
+}
+
+Common::Error ZVision::run() {
+	initialize();
+
+	// Main loop
+	while (!shouldQuit()) {
+		_clock.update();
+		uint32 currentTime = _clock.getLastMeasuredTime();
+		uint32 deltaTime = _clock.getDeltaTime();
+
+		processEvents();
+
+		_scriptManager->update(deltaTime);
+		_renderManager->update(deltaTime);
+
+		// Update the screen
+		_system->updateScreen();
+
+		// Calculate the frame delay based off a desired frame time
+		int delay = _desiredFrameTime - int32(_system->getMillis() - currentTime);
+		// Ensure non-negative
+		delay = delay < 0 ? 0 : delay;
+		_system->delayMillis(delay);
+	}
+
+	return Common::kNoError;
+}
+
+void ZVision::pauseEngineIntern(bool pause) {
+	_mixer->pauseAll(pause);
+
+	if (pause) {
+		_clock.stop();
+	} else {
+		_clock.start();
+	}
+}
+
+ScriptManager *ZVision::getScriptManager() const {
+	return _scriptManager;
+}
+
+RenderManager *ZVision::getRenderManager() const {
+	return _renderManager;
+}
+
+CursorManager *ZVision::getCursorManager() const {
+	return _cursorManager;
+}
+
+Common::RandomSource *ZVision::getRandomSource() const {
+	return _rnd;
+}
+
+ZVisionGameId ZVision::getGameId() const {
+	return _gameDescription->gameId;
+}
+
+void ZVision::cycleThroughCursors() {
+	Common::ArchiveMemberList list;
+	SearchMan.listMatchingMembers(list, "*.zcr");
+
+	Common::ArchiveMemberList::iterator iter = list.begin();
+	ZorkCursor cursor;
+	bool cursorChanged = false;
+
+	_system->showMouse(true);
+
+	bool done = false;
+	while (!done && !shouldQuit()) {
+		_clock.update();
+		uint32 currentTime = _clock.getLastMeasuredTime();
+
+		while (_eventMan->pollEvent(_event)) {
+			if (_event.type == Common::EVENT_KEYDOWN) {
+				switch (_event.kbd.keycode) {
+				case Common::KEYCODE_LEFT:
+					--iter;
+					cursorChanged = true;
+					break;
+				case Common::KEYCODE_RIGHT:
+					++iter;
+					cursorChanged = true;
+					break;
+				case Common::KEYCODE_RETURN:
+					debug("%s", (*iter)->getName().c_str());
+					break;
+				case Common::KEYCODE_ESCAPE:
+					done = true;
+					break;
+				default:
+					break;
+				}
+			}
+		}
+
+		if (cursorChanged) {
+			cursor = ZorkCursor((*iter)->getName());
+
+			_system->setMouseCursor(cursor.getSurface(), cursor.getWidth(), cursor.getHeight(), cursor.getHotspotX(), cursor.getHotspotY(), cursor.getHeight(), true, &_pixelFormat);
+			cursorChanged = false;
+		}
+
+		_system->updateScreen();
+
+		// Calculate the frame delay based off a desired frame time
+		int delay = _desiredFrameTime - int32(_system->getMillis() - currentTime);
+		// Ensure non-negative
+		delay = delay < 0 ? 0 : delay;
+		_system->delayMillis(delay);
+	}
+}
+
+} // End of namespace ZVision
diff --git a/engines/zvision/zvision.h b/engines/zvision/zvision.h
new file mode 100644
index 0000000000..58812d4d11
--- /dev/null
+++ b/engines/zvision/zvision.h
@@ -0,0 +1,160 @@
+/* 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_H
+#define ZVISION_H
+
+#include "common/random.h"
+#include "common/events.h"
+
+#include "engines/engine.h"
+
+#include "graphics/pixelformat.h"
+
+#include "zvision/detection.h"
+#include "zvision/clock.h"
+#include "zvision/mouse_event.h"
+
+#include "gui/debugger.h"
+
+
+namespace Video {
+class VideoDecoder;
+}
+
+namespace ZVision {
+
+struct ZVisionGameDescription;
+class Console;
+class ScriptManager;
+class RenderManager;
+class CursorManager;
+ 
+// our engine debug channels
+enum {
+	kZDebugExample = 1 << 0,
+	kZDebugExample2 = 1 << 1
+	// next new channel must be 1 << 2 (4)
+	// the current limitation is 32 debug channels (1 << 31 is the last one)
+};
+ 
+class ZVision : public Engine {
+public:
+	ZVision(OSystem *syst, const ZVisionGameDescription *gameDesc);
+	~ZVision();
+
+private:
+	enum {
+		WINDOW_WIDTH = 640,
+		WINDOW_HEIGHT = 480,
+		WORKING_WINDOW_WIDTH = 512,
+		WORKING_WINDOW_HEIGHT = 320,
+
+		ROTATION_SCREEN_EDGE_OFFSET = 60,
+		MAX_ROTATION_SPEED = 150 // Pixels per second
+	};
+
+	Console *_console;
+	const ZVisionGameDescription *_gameDescription;
+	/** 
+	 * A Rectangle centered inside the actual window. All in-game coordinates
+	 * are given in this coordinate space. Also, all images are clipped to the
+	 * edges of this Rectangle
+	 */
+	const Common::Rect _workingWindow;
+	const Graphics::PixelFormat _pixelFormat;
+
+	const int _desiredFrameTime;
+
+	// We need random numbers
+	Common::RandomSource *_rnd;
+
+	// Managers
+	ScriptManager *_scriptManager;
+	RenderManager *_renderManager;
+	CursorManager *_cursorManager;
+
+	// Clock
+	Clock _clock;
+
+	// To store the current mouse events
+	Common::List<MouseEvent> _mouseEvents;
+
+	// To prevent allocation every time we process events
+	Common::Event _event;
+
+public:
+	uint32 getFeatures() const;
+	Common::Language getLanguage() const;
+	Common::Error run();
+	void pauseEngineIntern(bool pause);
+
+	ScriptManager *getScriptManager() const;
+	RenderManager *getRenderManager() const;
+	CursorManager *getCursorManager() const;
+	Common::RandomSource *getRandomSource() const;
+	ZVisionGameId getGameId() const;
+
+	/**
+	 * Play a video until it is finished. This is a blocking call. It will call
+	 * _clock.stop() when the video starts and _clock.start() when the video finishes.
+	 * It will also consume all events during video playback.
+	 *
+	 * @param videoDecoder    The video to play
+	 * @param destRect        Where to put the video. (In working window coords)
+	 * @param skippable       If true, the video can be skipped at any time using [Spacebar]
+	 */
+	void playVideo(Video::VideoDecoder &videoDecoder, const Common::Rect &destRect = Common::Rect(0, 0, 0, 0), bool skippable = true);
+
+	/**
+	 * Register a MouseEvent with the event system. These will be checked at every
+	 * MOUSE_UP, MOUSE_DOWN, MOUSE_MOVE, etc.
+	 *
+	 * @param event    The event to register
+	 */
+	void registerMouseEvent(const MouseEvent &event);
+	/** Remove all MouseEvents from the event system */
+	void clearAllMouseEvents();
+
+	/**
+	 * Utility method to cycle through all the cursors in the game. After
+	 * calling, use Left and Right arrows to cycle. Esc to quit. This is a
+	 * blocking function call.              
+	 */
+	void cycleThroughCursors();
+
+private:
+	void initialize();
+
+	/** Called every frame from ZVision::run() to process any events from EventMan */
+	void processEvents();
+
+	void onMouseDown(const Common::Point &pos);
+	void onMouseUp(const Common::Point &pos);
+	void onMouseMove(const Common::Point &pos);
+	void onKeyDown(uint keyCode);
+};
+
+} // End of namespace ZVision
+ 
+#endif
diff --git a/video/codecs/truemotion1.h b/video/codecs/truemotion1.h
index b2a35cf873..39950b3ea6 100644
--- a/video/codecs/truemotion1.h
+++ b/video/codecs/truemotion1.h
@@ -23,7 +23,7 @@
 // Based on the TrueMotion 1 decoder by Alex Beregszaszi & Mike Melanson in FFmpeg
 
 // Only compile if SCI32 is enabled or if we're building dynamic modules
-#if defined(ENABLE_SCI32) || defined(DYNAMIC_MODULES)
+//#if defined(ENABLE_SCI32) || defined(DYNAMIC_MODULES)
 
 #ifndef VIDEO_CODECS_TRUEMOTION1_H
 #define VIDEO_CODECS_TRUEMOTION1_H
@@ -106,4 +106,4 @@ private:
 } // End of namespace Video
 
 #endif // VIDEO_CODECS_TRUEMOTION1_H
-#endif // SCI32/Plugins guard
+//#endif // SCI32/Plugins guard