Merge pull request #807 from blorente/macventure-clean

MACVENTURE: Add MacVenture engine.

47 files changed, 8706 insertions, 0 deletions

diff --git a/Makefile.common b/Makefile.common
index df24d397de..762b9051d0 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -285,6 +285,9 @@ endif
 ifdef ENABLE_WINTERMUTE
 DIST_FILES_ENGINEDATA+=wintermute.zip
 endif
+ifdef ENABLE_MACVENTURE
+DIST_FILES_ENGINEDATA+=macventure.dat
+endif
 DIST_FILES_ENGINEDATA:=$(addprefix $(srcdir)/dists/engine-data/,$(DIST_FILES_ENGINEDATA))
 
 # pred.dic is currently only used for the AGI engine
diff --git a/devtools/create_macventure/AltBox_act.bmp b/devtools/create_macventure/AltBox_act.bmp
new file mode 100644
index 0000000000..aa9fa7e841
--- /dev/null
+++ b/devtools/create_macventure/AltBox_act.bmp
diff --git a/devtools/create_macventure/AltBox_inac.bmp b/devtools/create_macventure/AltBox_inac.bmp
new file mode 100644
index 0000000000..aa9fa7e841
--- /dev/null
+++ b/devtools/create_macventure/AltBox_inac.bmp
diff --git a/devtools/create_macventure/InvWindow_act.bmp b/devtools/create_macventure/InvWindow_act.bmp
new file mode 100644
index 0000000000..a38b0a9834
--- /dev/null
+++ b/devtools/create_macventure/InvWindow_act.bmp
diff --git a/devtools/create_macventure/InvWindow_inac.bmp b/devtools/create_macventure/InvWindow_inac.bmp
new file mode 100644
index 0000000000..f3f2cfaa8b
--- /dev/null
+++ b/devtools/create_macventure/InvWindow_inac.bmp
diff --git a/devtools/create_macventure/NoGrowDoc_act.bmp b/devtools/create_macventure/NoGrowDoc_act.bmp
new file mode 100644
index 0000000000..3570e798d9
--- /dev/null
+++ b/devtools/create_macventure/NoGrowDoc_act.bmp
diff --git a/devtools/create_macventure/NoGrowDoc_inac.bmp b/devtools/create_macventure/NoGrowDoc_inac.bmp
new file mode 100644
index 0000000000..f3f97652e5
--- /dev/null
+++ b/devtools/create_macventure/NoGrowDoc_inac.bmp
diff --git a/devtools/create_macventure/PlainDBox_act.bmp b/devtools/create_macventure/PlainDBox_act.bmp
new file mode 100644
index 0000000000..6521080588
--- /dev/null
+++ b/devtools/create_macventure/PlainDBox_act.bmp
diff --git a/devtools/create_macventure/PlainDBox_inac.bmp b/devtools/create_macventure/PlainDBox_inac.bmp
new file mode 100644
index 0000000000..6521080588
--- /dev/null
+++ b/devtools/create_macventure/PlainDBox_inac.bmp
diff --git a/devtools/create_macventure/RDoc4_act.bmp b/devtools/create_macventure/RDoc4_act.bmp
new file mode 100644
index 0000000000..ab78661359
--- /dev/null
+++ b/devtools/create_macventure/RDoc4_act.bmp
diff --git a/devtools/create_macventure/RDoc4_inac.bmp b/devtools/create_macventure/RDoc4_inac.bmp
new file mode 100644
index 0000000000..ab78661359
--- /dev/null
+++ b/devtools/create_macventure/RDoc4_inac.bmp
diff --git a/devtools/create_macventure/ZoomDoc_act.bmp b/devtools/create_macventure/ZoomDoc_act.bmp
new file mode 100644
index 0000000000..b2ccc9c602
--- /dev/null
+++ b/devtools/create_macventure/ZoomDoc_act.bmp
diff --git a/devtools/create_macventure/ZoomDoc_inac.bmp b/devtools/create_macventure/ZoomDoc_inac.bmp
new file mode 100644
index 0000000000..963949b392
--- /dev/null
+++ b/devtools/create_macventure/ZoomDoc_inac.bmp
diff --git a/devtools/create_macventure/create_macventure.sh b/devtools/create_macventure/create_macventure.sh
new file mode 100755
index 0000000000..1408179039
--- /dev/null
+++ b/devtools/create_macventure/create_macventure.sh
@@ -0,0 +1,8 @@
+printf "Creating border file...\n"
+
+zip -r macventure.zip *.bmp
+mv macventure.zip macventure.dat
+
+echo done
+
+ls -l macventure.dat
diff --git a/engines/macventure/configure.engine b/engines/macventure/configure.engine
new file mode 100644
index 0000000000..dc7cf7912c
--- /dev/null
+++ b/engines/macventure/configure.engine
@@ -0,0 +1,3 @@
+# This file is included from the main "configure" script
+# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps]
+add_engine macventure "MacVenture" no
diff --git a/engines/macventure/container.cpp b/engines/macventure/container.cpp
new file mode 100644
index 0000000000..ff98d6961f
--- /dev/null
+++ b/engines/macventure/container.cpp
@@ -0,0 +1,187 @@
+/* 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 "macventure/container.h"
+
+namespace MacVenture {
+
+Container::Container(Common::String filename) {
+	_filename = filename;
+
+	if (!_file.open(_filename)) {
+		error("CONTAINER: Could not open %s", _filename.c_str());
+	}
+
+	_res = _file.readStream(_file.size());
+	_header = _res->readUint32BE();
+	_simplified = false;
+
+	for (uint i = 0; i < 16; ++i) {
+		_huff.push_back(0);
+	}
+
+	for (uint i = 0; i < 16; ++i) {
+		_lens.push_back(0);
+	}
+
+	if (!(_header & 0x80000000)) {
+		// Is simplified container
+		_simplified = true;
+		int dataLen = _res->size() - sizeof(_header);
+		_lenObjs = _header;
+		_numObjs = dataLen / _lenObjs;
+	} else {
+		_header &= 0x7fffffff;
+		_res->seek(_header, SEEK_SET);
+		_numObjs = _res->readUint16BE();
+
+		for (uint i = 0; i < 15; ++i) {
+			_huff[i] = _res->readUint16BE();
+		}
+
+		for (uint i = 0; i < 16; ++i) {
+			_lens[i] = _res->readByte();
+		}
+
+		// Read groups
+		uint numGroups = _numObjs / 64;
+		if ((_numObjs % 64) > 0) {
+			numGroups++;
+		}
+
+		for (uint i = 0; i < numGroups; ++i) {
+			ItemGroup group;
+
+			// Place myself in the correct position to read group
+			_res->seek(_header + (i * 6) + 0x30, SEEK_SET);
+			byte b1, b2, b3;
+			b1 = _res->readByte();
+			b2 = _res->readByte();
+			b3 = _res->readByte();
+			group.bitOffset = (b1 << 16) + (b2 << 8) + (b3 << 0);
+
+			b1 = _res->readByte();
+			b2 = _res->readByte();
+			b3 = _res->readByte();
+			group.offset = (b1 << 16) + (b2 << 8) + (b3 << 0);
+
+			// Place the bit reader in the correct position
+			// group.bitOffset indicates the offset from the start of the subHeader
+			_res->seek(_header + (group.bitOffset >> 3), SEEK_SET);
+			uint32 bits = group.bitOffset & 7;
+
+			for (uint j = 0; j < 64; ++j) {
+				uint32 length = 0;
+				uint32 mask = 0;
+				mask = _res->readUint32BE();
+				mask >>= (16 - bits);
+				mask &= 0xFFFF;
+				debugC(4, kMVDebugContainer, "Load mask of object &%d:%d is %x", i, j, mask);
+				_res->seek(-4, SEEK_CUR);
+				// Look in the Huffman table
+				int x = 0;
+				for (x = 0; x < 16; x++) {
+					if (_huff[x] > mask) {
+						break;
+					}
+				}
+
+				// I will opt to copy the code from webventure,
+				// But according to the docs, this call should suffice:
+				// length = bitStream.getBits(_lens[x]);
+				// The problem is that _lens[] usually contains values larger
+				// Than 32, so we have to read them with the method below
+
+				//This code below, taken from the implementation, seems to give the same results.
+
+				uint32 bitSize = _lens[x];
+				bits += bitSize & 0xF;
+				if (bits & 0x10) {
+					bits &= 0xF;
+					_res->seek(2, SEEK_CUR);
+				}
+				bitSize >>= 4;
+				if (bitSize) {
+					length = _res->readUint32BE();
+					_res->seek(-4, SEEK_CUR);
+					bitSize--;
+					if (bitSize == 0) {
+						length = 0;
+					} else {
+						length >>= (32 - bitSize) - bits;
+					}
+					length &= (1 << bitSize) - 1;
+					length |= 1 << bitSize;
+					bits += bitSize;
+					if (bits & 0x10) {
+						bits &= 0xF;
+						_res->seek(2, SEEK_CUR);
+					}
+				}
+				group.lengths[j] = length;
+				debugC(4, kMVDebugContainer, "Load legth of object %d:%d is %d", i, j, length);
+			}
+			_groups.push_back(group);
+		}
+	}
+}
+
+Container::~Container() {
+
+	if (_file.isOpen())
+		_file.close();
+
+	if (_res)
+		delete _res;
+}
+
+uint32 Container::getItemByteSize(uint32 id) {
+	if (_simplified) {
+		return _lenObjs;
+	} else {
+		uint32 groupID = (id >> 6);
+		uint32 objectIndex = id & 0x3f; // Index within the group
+		return _groups[groupID].lengths[objectIndex];
+	}
+}
+
+Common::SeekableReadStream *Container::getItem(uint32 id) {
+	if (_simplified) {
+		_res->seek((id * _lenObjs) + sizeof(_header), SEEK_SET);
+	} else {
+		uint32 groupID = (id >> 6);
+		uint32 objectIndex = id & 0x3f; // Index within the group
+
+		uint32 offset = 0;
+		for (uint i = 0; i < objectIndex; i++) {
+			offset += _groups[groupID].lengths[i];
+		}
+		_res->seek(_groups[groupID].offset + offset + sizeof(_header), SEEK_SET);
+	}
+
+	// HACK Should Limit the size of the stream returned
+	Common::SeekableReadStream *res = _res->readStream(_res->size() - _res->pos() + 1);
+	return res;
+}
+
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/container.h b/engines/macventure/container.h
new file mode 100644
index 0000000000..e630bdf1be
--- /dev/null
+++ b/engines/macventure/container.h
@@ -0,0 +1,81 @@
+/* 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 MACVENTURE_CONTAINER_H
+#define MACVENTURE_CONTAINER_H
+
+#include "macventure/macventure.h"
+
+#include "common/file.h"
+#include "common/fs.h"
+#include "common/bitstream.h"
+
+namespace MacVenture {
+
+struct ItemGroup {
+	uint32 bitOffset; //It's really uint24
+	uint32 offset; //It's really uint24
+	uint32 lengths[64];
+};
+
+typedef uint32 ContainerHeader;
+
+class Container {
+
+public:
+	Container(Common::String filename);
+	~Container();
+
+public:
+	/**
+	* Must be called before retrieving an object.
+	*/
+	uint32 getItemByteSize(uint32 id);
+
+	/**
+	* getItemByteSize should be called before this one
+	*/
+	Common::SeekableReadStream *getItem(uint32 id);
+
+protected:
+
+	bool _simplified;
+
+	uint _lenObjs; // In the case of simple container, lenght of an object
+	uint _numObjs;
+
+	ContainerHeader _header;
+
+	Common::Array<uint16> _huff; // huffman masks
+	Common::Array<uint8> _lens; // huffman lengths
+	Common::Array<ItemGroup> _groups;
+
+	Common::String _filename;
+	Common::File _file;
+	Common::SeekableReadStream *_res;
+
+};
+
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/controls.cpp b/engines/macventure/controls.cpp
new file mode 100644
index 0000000000..078ea88dce
--- /dev/null
+++ b/engines/macventure/controls.cpp
@@ -0,0 +1,77 @@
+/* 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 "macventure/gui.h"
+
+namespace MacVenture {
+CommandButton::CommandButton() {
+	_gui = NULL;
+}
+
+CommandButton::CommandButton(ControlData data, Gui *g) {
+	_data = data;
+	_gui = g;
+	_selected = false;
+}
+
+void CommandButton::draw(Graphics::ManagedSurface &surface) const {
+
+	uint colorFill = _selected ? kColorBlack : kColorWhite;
+	uint colorText = _selected ? kColorWhite : kColorBlack;
+
+	surface.fillRect(_data.bounds, colorFill);
+	surface.frameRect(_data.bounds, kColorBlack);
+
+	if (_data.titleLength > 0) {
+		const Graphics::Font &font = _gui->getCurrentFont();
+		Common::String title(_data.title);
+		font.drawString(
+			&surface,
+			title,
+			_data.bounds.left,
+			_data.bounds.top,
+			_data.bounds.right - _data.bounds.left,
+			colorText,
+			Graphics::kTextAlignCenter);
+	}
+}
+
+bool CommandButton::isInsideBounds(const Common::Point point) const {
+	return _data.bounds.contains(point);
+}
+
+const ControlData &CommandButton::getData() const {
+	return _data;
+}
+
+void CommandButton::select() {
+	_selected = true;
+}
+
+void CommandButton::unselect() {
+	_selected = false;
+}
+
+bool CommandButton::isSelected() {
+	return _selected;
+}
+}
diff --git a/engines/macventure/controls.h b/engines/macventure/controls.h
new file mode 100644
index 0000000000..81b5278396
--- /dev/null
+++ b/engines/macventure/controls.h
@@ -0,0 +1,106 @@
+/* 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 MACVENTURE_CONTROLS_H
+#define MACVENTURE_CONTROLS_H
+
+namespace MacVenture {
+
+class Gui;
+
+enum ControlType { // HACK, should correspond exactly with the types of controls (sliders etc)
+	kControlExitBox = 0,
+	kControlExamine = 1,
+	kControlOpen = 2,
+	kControlClose = 3,
+	kControlSpeak = 4,
+	kControlOperate = 5,
+	kControlGo = 6,
+	kControlHit = 7,
+	kControlConsume = 8,
+	kControlClickToContinue = 9
+};
+
+enum ControlAction {
+	kNoCommand = 0,
+	kStartOrResume = 1,
+	kClose = 2,
+	kTick = 3,
+	kActivateObject = 4,
+	kMoveObject = 5,
+	kConsume = 6,
+	kExamine = 7,
+	kGo = 8,
+	kHit = 9,
+	kOpen = 10,
+	kOperate = 11,
+	kSpeak = 12,
+	kBabble = 13,
+	kTargetName = 14,
+	kDebugObject = 15,
+	kClickToContinue = 16
+};
+
+struct ControlData {
+	Common::Rect bounds;
+	uint16 scrollValue;
+	uint8 visible;
+	uint16 scrollMax;
+	uint16 scrollMin;
+	uint16 cdef;
+	ControlAction refcon;
+	ControlType type;
+	uint8 titleLength;
+	Common::String title;
+	uint16 border;
+};
+
+class CommandButton {
+
+enum {
+	kCommandsLeftPadding = 0,
+	kCommandsTopPadding = 0
+};
+
+public:
+
+	CommandButton();
+
+	CommandButton(ControlData data, Gui *g);
+	~CommandButton() {}
+
+	void draw(Graphics::ManagedSurface &surface) const;
+	bool isInsideBounds(const Common::Point point) const;
+	const ControlData &getData() const;
+	void select();
+	void unselect();
+	bool isSelected();
+
+private:
+	bool _selected;
+	ControlData _data;
+	Gui *_gui;
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/cursor.cpp b/engines/macventure/cursor.cpp
new file mode 100644
index 0000000000..655615a523
--- /dev/null
+++ b/engines/macventure/cursor.cpp
@@ -0,0 +1,128 @@
+/* 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 "macventure/gui.h"
+
+namespace MacVenture {
+
+static void cursorTimerHandler(void *refCon);
+
+static const ClickState _transitionTable[kCursorStateCount][kCursorInputCount] = {
+	/*				Button down,		Button Up,		Tick		*/
+	/* Idle */		{kCursorSCStart,	kCursorIdle,	kCursorIdle	},
+	/* SC Start */	{kCursorSCStart,	kCursorDCStart,	kCursorSCDrag},
+	/* SC Do */		{kCursorSCDrag, 	kCursorIdle,	kCursorSCDrag},
+	/* DC Start */	{kCursorDCDo,		kCursorDCStart,	kCursorSCSink},
+	/* DC Do */		{kCursorDCDo,		kCursorIdle,	kCursorDCDo	},
+	/* SC Sink */	{kCursorIdle,		kCursorIdle,	kCursorIdle	}
+};
+
+Cursor::Cursor(Gui *gui) {
+	_gui = gui;
+	_state = kCursorIdle;
+}
+Cursor::~Cursor() {}
+
+void Cursor::tick() {
+	changeState(kTickCol);
+}
+
+bool Cursor::processEvent(const Common::Event &event) {
+	if (event.type == Common::EVENT_MOUSEMOVE) {
+		_pos = event.mouse;
+		return true;
+	}
+	if (event.type == Common::EVENT_LBUTTONDOWN) {
+		changeState(kButtonDownCol);
+		return true;
+	}
+	if (event.type == Common::EVENT_LBUTTONUP) {
+		changeState(kButtonUpCol);
+		return true;
+	}
+
+	return false;
+}
+
+Common::Point Cursor::getPos() {
+	return _pos;
+}
+
+bool Cursor::canSelectDraggable() {
+	return _state == kCursorSCDrag;
+}
+
+void Cursor::changeState(CursorInput input) {
+	debugC(3, kMVDebugGUI, "Change cursor state: [%d] -> [%d]", _state, _transitionTable[_state][input]);
+	if (_state != _transitionTable[_state][input]) {
+		executeStateOut();
+		_state = _transitionTable[_state][input];
+		executeStateIn();
+	}
+}
+
+void Cursor::executeStateIn() {
+	switch (_state) {
+	case kCursorSCStart:
+		g_system->getTimerManager()->installTimerProc(&cursorTimerHandler, 300000, this, "macVentureCursor");
+		_gui->selectForDrag(_pos);
+		break;
+	case kCursorDCStart:
+		g_system->getTimerManager()->installTimerProc(&cursorTimerHandler, 300000, this, "macVentureCursor");
+		break;
+	case kCursorSCSink:
+		_gui->handleSingleClick();
+		changeState(kTickCol);
+		break;
+	default:
+		break;
+	}
+}
+
+void Cursor::executeStateOut() {
+	switch (_state) {
+	case kCursorIdle:
+		break;
+	case kCursorSCStart:
+		g_system->getTimerManager()->removeTimerProc(&cursorTimerHandler);
+		break;
+	case kCursorSCDrag:
+		_gui->handleSingleClick();
+		break;
+	case kCursorDCStart:
+		g_system->getTimerManager()->removeTimerProc(&cursorTimerHandler);
+		break;
+	case kCursorDCDo:
+		_gui->handleDoubleClick();
+		break;
+	default:
+		break;
+	}
+}
+
+static void cursorTimerHandler(void *refCon) {
+	Cursor *cursor = (Cursor *)refCon;
+	cursor->tick();
+}
+
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/datafiles.cpp b/engines/macventure/datafiles.cpp
new file mode 100644
index 0000000000..2c17b66209
--- /dev/null
+++ b/engines/macventure/datafiles.cpp
@@ -0,0 +1,88 @@
+/* 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 MACVENTURE_DATAFILES_H
+#define MACVENTURE_DATAFILES_H
+
+#include "macventure/macventure.h"
+#include "macventure/windows.h"
+
+#include "common/unzip.h"
+
+namespace MacVenture {
+
+#define MACVENTURE_DATA_BUNDLE Common::String("macventure.dat")
+
+struct BorderName {
+	MVWindowType type;
+	const char *name;
+};
+
+static const BorderName g_borderNames[] = {
+	{kDocument, "Document"},
+	{kDBox, "DBox"},
+	{kPlainDBox, "PlainDBox"},
+	{kAltBox, "AltBox"},
+	{kNoGrowDoc, "NoGrowDoc"},
+	{kMovableDBox, "MovableDBox"},
+	{kZoomDoc, "ZoomDoc"},
+	{kZoomNoGrow, "ZoomNoGrow"},
+	{kInvWindow, "InvWindow"},
+	{kRDoc16, "RDoc16"},
+	{kRDoc4, "RDoc4"},
+	{kRDoc6, "RDoc6"},
+	{kRDoc10, "RDoc10"},
+	{kNoType, "No type"}
+};
+
+Common::String windowTypeName(MVWindowType windowType) {
+	int i = 0;
+	while (g_borderNames[i].type != kNoType) {
+		i++;
+		if (g_borderNames[i].type == windowType) {
+			return g_borderNames[i].name;
+		}
+	}
+	return "";
+}
+
+void MacVentureEngine::loadDataBundle() {
+	_dataBundle = Common::makeZipArchive(MACVENTURE_DATA_BUNDLE);
+	if (!_dataBundle) {
+		error("ENGINE: Couldn't load data bundle '%s'.", MACVENTURE_DATA_BUNDLE.c_str());
+	}
+}
+
+Common::SeekableReadStream *MacVentureEngine::getBorderFile(MVWindowType windowType, bool isActive) {
+	Common::String filename = windowTypeName(windowType);
+	filename += (isActive ? "_act.bmp" : "_inac.bmp");
+	if (!_dataBundle->hasFile(filename)) {
+		warning("Missing border file '%s' in data bundle", filename.c_str());
+		return NULL;
+	}
+
+	return _dataBundle->createReadStreamForMember(filename);
+}
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/debug.h b/engines/macventure/debug.h
new file mode 100644
index 0000000000..c223d01fe4
--- /dev/null
+++ b/engines/macventure/debug.h
@@ -0,0 +1,38 @@
+/* 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 MACVENTURE_DEBUG_H
+#define MACVENTURE_DEBUG_H
+
+namespace MacVenture {
+enum MacVentureDebugChannel {
+   kMVDebugMain = 1 << 0,
+   kMVDebugGUI = 1 << 1,
+   kMVDebugImage = 1 << 2,
+   kMVDebugText = 1 << 3,
+   kMVDebugScript = 1 << 4,
+   kMVDebugSound = 1 << 5,
+   kMVDebugContainer = 1 << 6
+};
+} // End namespace MacVenture
+
+#endif
diff --git a/engines/macventure/detection.cpp b/engines/macventure/detection.cpp
new file mode 100644
index 0000000000..10676d5b25
--- /dev/null
+++ b/engines/macventure/detection.cpp
@@ -0,0 +1,179 @@
+/* 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 "engines/advancedDetector.h"
+#include "common/system.h"
+
+#include "macventure/macventure.h"
+
+namespace MacVenture {
+
+#define ADGF_DEFAULT (ADGF_DROPLANGUAGE|ADGF_DROPPLATFORM|ADGF_MACRESFORK)
+
+#define BASEGAME(n, v, f, md5, s) {n, v, AD_ENTRY1s(f, md5, s), Common::EN_ANY, Common::kPlatformMacintosh, ADGF_DEFAULT, GUIO0()}
+
+static const ADGameDescription gameDescriptions[] = {
+	BASEGAME("shadowgate", "Zojoi Rerelease", "Shadowgate.bin", "ebbfbcbf93938bd2900cb0c0213b19ad", 68974), // Zojoi Rerelease
+	BASEGAME("deja_vu", "Zojoi Rerelease", "Deja Vu.bin", "5e9f5a8e3c8eb29ed02b34ae5937354f", 69034), // Zojoi Rerelease
+	BASEGAME("deja_vu2", "Zojoi Rerelease", "Lost in Las Vegas.bin", "8f8e1d8d41f577ee0fbc03847969af0d", 66520), // Zojoi Rerelease
+	AD_TABLE_END_MARKER
+};
+
+const char *MacVentureEngine::getGameFileName() const {
+	return _gameDescription->filesDescriptions[0].fileName;
+}
+} // End of namespace MacVenture
+
+static const PlainGameDescriptor macventureGames[] = {
+	{ "shadowgate", "Shadowgate" },
+	{ "deja_vu", "Deja Vu"},
+	{ "deja_vu2", "Deja Vu II"},
+	{ 0, 0 }
+};
+
+namespace MacVenture {
+
+SaveStateDescriptor loadMetaData(Common::SeekableReadStream *s, int slot);
+
+class MacVentureMetaEngine : public AdvancedMetaEngine {
+public:
+	MacVentureMetaEngine() : AdvancedMetaEngine(MacVenture::gameDescriptions, sizeof(ADGameDescription), macventureGames) {
+		_guiOptions = GUIO0();
+		_md5Bytes = 5000000; // TODO: Upper limit, adjust it once all games are added
+	}
+
+	virtual const char *getName() const override {
+		return "MacVenture";
+	}
+	virtual const char *getOriginalCopyright() const override {
+		return "(C) ICOM Simulations";
+	}
+
+	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+	virtual bool hasFeature(MetaEngineFeature f) const;
+	virtual SaveStateList listSaves(const char *target) const;
+	virtual int getMaximumSaveSlot() const;
+	virtual void removeSaveState(const char *target, int slot) const;
+	SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+};
+
+bool MacVentureMetaEngine::hasFeature(MetaEngineFeature f) const {
+	return
+		(f == kSupportsListSaves) ||
+		(f == kSupportsLoadingDuringStartup) ||
+		(f == kSupportsDeleteSave) ||
+		(f == kSavesSupportMetaInfo) ||
+		(f == kSavesSupportThumbnail) ||
+		(f == kSavesSupportCreationDate) ||
+		(f == kSavesSupportPlayTime);
+}
+
+bool MacVentureEngine::hasFeature(EngineFeature f) const {
+	return
+		(f == kSupportsRTL) ||
+		(f == kSupportsLoadingDuringRuntime) ||
+		(f == kSupportsSavingDuringRuntime);
+}
+
+SaveStateList MacVentureMetaEngine::listSaves(const char *target) const {
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::StringArray filenames;
+	Common::String pattern = target;
+	pattern += ".###";
+
+	filenames = saveFileMan->listSavefiles(pattern);
+
+	SaveStateList saveList;
+	for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+		int slotNum = atoi(file->c_str() + file->size() - 3);
+		SaveStateDescriptor desc;
+		// Do not allow save slot 0 (used for auto-saving) to be deleted or
+		// overwritten.
+		desc.setDeletableFlag(slotNum != 0);
+		desc.setWriteProtectedFlag(slotNum == 0);
+
+		if (slotNum >= 0 && slotNum <= getMaximumSaveSlot()) {
+			Common::InSaveFile *in = saveFileMan->openForLoading(*file);
+			if (in) {
+				desc = loadMetaData(in, slotNum);
+				if (desc.getSaveSlot() != slotNum) {
+					// invalid
+					delete in;
+					continue;
+				}
+				saveList.push_back(desc);
+				delete in;
+			}
+		}
+	}
+
+	// Sort saves based on slot number.
+	Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator());
+	return saveList;
+}
+
+int MacVentureMetaEngine::getMaximumSaveSlot() const { return 999; }
+
+bool MacVentureMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *game) const {
+	if (game) {
+		*engine = new MacVenture::MacVentureEngine(syst, game);
+	}
+	return game != 0;
+}
+
+void MacVentureMetaEngine::removeSaveState(const char *target, int slot) const {
+	g_system->getSavefileManager()->removeSavefile(Common::String::format("%s.%03d", target, slot));
+}
+
+
+SaveStateDescriptor MacVentureMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	SaveStateDescriptor desc;
+	Common::String saveFileName;
+	Common::String pattern = target;
+	pattern += ".###";
+	Common::StringArray filenames = saveFileMan->listSavefiles(pattern);
+	for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+		int slotNum = atoi(file->c_str() + file->size() - 3);
+		if (slotNum == slot) {
+			saveFileName = *file;
+		}
+	}
+
+	Common::InSaveFile *in = saveFileMan->openForLoading(saveFileName);
+	if (in) {
+		desc = loadMetaData(in, slot);
+		delete in;
+		return desc;
+	}
+	return SaveStateDescriptor(-1, "");
+}
+
+} // End of namespace MacVenture
+
+#if PLUGIN_ENABLED_DYNAMIC(MACVENTURE)
+ REGISTER_PLUGIN_DYNAMIC(MACVENTURE, PLUGIN_TYPE_ENGINE, MacVenture::MacVentureMetaEngine);
+#else
+ REGISTER_PLUGIN_STATIC(MACVENTURE, PLUGIN_TYPE_ENGINE, MacVenture::MacVentureMetaEngine);
+#endif
diff --git a/engines/macventure/dialog.cpp b/engines/macventure/dialog.cpp
new file mode 100644
index 0000000000..7827bddffd
--- /dev/null
+++ b/engines/macventure/dialog.cpp
@@ -0,0 +1,253 @@
+/* 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/system.h"
+
+#include "macventure/dialog.h"
+namespace MacVenture {
+
+
+Dialog::Dialog(Gui *gui, Common::Point pos, uint width, uint height) :
+	_gui(gui), _bounds(Common::Rect(pos.x, pos.y, pos.x + width, pos.y + height)) {}
+
+Dialog::Dialog(Gui *gui, PrebuiltDialogs prebuilt) {
+	_gui = gui;
+	const PrebuiltDialog &dialog = g_prebuiltDialogs[prebuilt];
+	calculateBoundsFromPrebuilt(dialog.bounds);
+	for (int i = 0; dialog.elements[i].type != kDEEnd; i++) {
+		addPrebuiltElement(dialog.elements[i]);
+	}
+}
+
+Dialog::~Dialog() {
+	for (Common::Array<DialogElement*>::iterator it = _elements.begin(); it != _elements.end(); it++) {
+		delete *it;
+	}
+}
+
+void Dialog::handleDialogAction(DialogElement *trigger, DialogAction action) {
+	switch(action) {
+	case kDACloseDialog:
+		_gui->closeDialog();
+		break;
+	case kDASubmit:
+		_gui->setTextInput(_userInput);
+		_gui->closeDialog();
+		break;
+	case kDASaveAs:
+		_gui->saveGame();
+		_gui->closeDialog();
+		break;
+	case kDALoadGame:
+		_gui->loadGame();
+		_gui->closeDialog();
+		break;
+	case kDANewGame:
+		_gui->newGame();
+		_gui->closeDialog();
+		break;
+	case kDAQuit:
+		_gui->quitGame();
+		_gui->closeDialog();
+		break;
+	default:
+		break;
+	}
+}
+
+const Graphics::Font &Dialog::getFont() {
+	return _gui->getCurrentFont();
+}
+
+bool Dialog::processEvent(Common::Event event) {
+	for (Common::Array<DialogElement*>::iterator it = _elements.begin(); it != _elements.end(); it++) {
+		if ((*it)->processEvent(this, event)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void Dialog::addButton(Common::String title, MacVenture::DialogAction action, Common::Point position, uint width, uint height) {
+	_elements.push_back(new DialogButton(this, title, action, position, width, height));
+}
+
+void Dialog::addText(Common::String content, Common::Point position) {
+	_elements.push_back(new DialogPlainText(this, content, position));
+}
+
+void Dialog::addTextInput(Common::Point position, int width, int height) {
+	_elements.push_back(new DialogTextInput(this, position, width, height));
+}
+
+void Dialog::draw() {
+	Graphics::ManagedSurface compose;
+	// Compose the surface
+	compose.create(_bounds.width(), _bounds.height());
+	Common::Rect base(0, 0, _bounds.width(), _bounds.height());
+	compose.fillRect(base, kColorWhite);
+	compose.frameRect(base, kColorBlack);
+	for (Common::Array<DialogElement*>::iterator it = _elements.begin(); it != _elements.end(); it++) {
+		(*it)->draw(this, compose);
+	}
+
+	g_system->copyRectToScreen(compose.getPixels(), compose.pitch,
+		_bounds.left, _bounds.top, _bounds.width(), _bounds.height());
+	}
+
+void Dialog::localize(Common::Point &point) {
+	point.x -= _bounds.left;
+	point.y -= _bounds.top;
+}
+
+void Dialog::setUserInput(Common::String content) {
+	_userInput = content;
+}
+
+void Dialog::addPrebuiltElement(const MacVenture::PrebuiltDialogElement &element) {
+	Common::Point position(element.left, element.top);
+	switch(element.type) {
+	case kDEButton:
+		addButton(element.title, element.action, position, element.width, element.height);
+		break;
+	case kDEPlainText:
+		addText(element.title, position);
+		break;
+	case kDETextInput:
+		addTextInput(position, element.width, element.height);
+		break;
+	default:
+		break;
+	}
+}
+
+// Dialog Element
+
+DialogElement::DialogElement(Dialog *dialog, Common::String title, DialogAction action, Common::Point position, uint width, uint height) :
+	_text(title), _action(action) {
+	if (width == 0) {
+		width = dialog->getFont().getStringWidth(title);
+	}
+	if (height == 0) {
+		height = dialog->getFont().getFontHeight();
+	}
+	_bounds = Common::Rect(position.x, position.y, position.x + width, position.y + height);
+}
+
+bool DialogElement::processEvent(MacVenture::Dialog *dialog, Common::Event event) {
+	return doProcessEvent(dialog, event);
+}
+
+void DialogElement::draw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target) {
+	doDraw(dialog, target);
+}
+
+const Common::String &DialogElement::getText() {
+	return doGetText();
+}
+
+const Common::String &DialogElement::doGetText() {
+	return _text;
+}
+
+// CONCRETE DIALOG ELEMENTS
+
+DialogButton::DialogButton(Dialog *dialog, Common::String title, DialogAction action, Common::Point position, uint width, uint height):
+	DialogElement(dialog, title, action, position, width, height) {}
+
+bool DialogButton::doProcessEvent(MacVenture::Dialog *dialog, Common::Event event) {
+	Common::Point mouse = event.mouse;
+	if (event.type == Common::EVENT_LBUTTONDOWN) {
+		dialog->localize(mouse);
+		if (_bounds.contains(mouse)) {
+			debugC(2, kMVDebugGUI, "Click! Button: %s", _text.c_str());
+			dialog->handleDialogAction(this, _action);
+			return true;
+		}
+ 	}
+ 	return false;
+}
+
+void DialogButton::doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target) {
+	target.fillRect(_bounds, kColorWhite);
+	target.frameRect(_bounds, kColorBlack);
+	// Draw title
+	dialog->getFont().drawString(
+		&target, _text, _bounds.left, _bounds.top, _bounds.width(), kColorBlack, Graphics::kTextAlignCenter);
+}
+
+DialogPlainText::DialogPlainText(Dialog *dialog, Common::String content, Common::Point position) :
+	DialogElement(dialog, content, kDANone, position, 0, 0) { }
+
+DialogPlainText::~DialogPlainText() {}
+
+bool DialogPlainText::doProcessEvent(MacVenture::Dialog *dialog, Common::Event event) {
+	return false;
+}
+
+void DialogPlainText::doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target) {
+	// Draw contents
+	dialog->getFont().drawString(
+		&target, _text, _bounds.left, _bounds.top, _bounds.width(), kColorBlack, Graphics::kTextAlignCenter);
+
+}
+
+DialogTextInput::DialogTextInput(Dialog *dialog, Common::Point position, uint width, uint height) :
+	DialogElement(dialog, "", kDANone, position, width, height) {}
+DialogTextInput::~DialogTextInput() {}
+
+bool DialogTextInput::doProcessEvent(Dialog *dialog, Common::Event event) {
+	if (event.type == Common::EVENT_KEYDOWN) {
+		switch (event.kbd.keycode) {
+		case Common::KEYCODE_BACKSPACE:
+			if (!_text.empty()) {
+				_text.deleteLastChar();
+				dialog->setUserInput(_text);
+				return true;
+			}
+			break;
+		default:
+			if (event.kbd.ascii >= 0x20 && event.kbd.ascii <= 0x7f) {
+				_text += (char)event.kbd.ascii;
+				dialog->setUserInput(_text);
+				return true;
+			}
+			break;
+		}
+	}
+	return false;
+}
+
+void DialogTextInput::doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target) {
+	target.fillRect(_bounds, kColorWhite);
+	target.frameRect(_bounds, kColorBlack);
+	dialog->getFont().drawString(&target, _text, _bounds.left, _bounds.top, _bounds.width(), kColorBlack);
+}
+
+void Dialog::calculateBoundsFromPrebuilt(const PrebuiltDialogBounds &bounds) {
+	_bounds = Common::Rect(
+		bounds.left,
+		bounds.top,
+		bounds.right,
+		bounds.bottom);
+}
+} // End of namespace MacVenture
diff --git a/engines/macventure/dialog.h b/engines/macventure/dialog.h
new file mode 100644
index 0000000000..67331d7eb3
--- /dev/null
+++ b/engines/macventure/dialog.h
@@ -0,0 +1,123 @@
+/* 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 MACVENTURE_DIALOG_H
+#define MACVENTURE_DIALOG_H
+
+#include "graphics/macgui/macwindowmanager.h"
+
+#include "macventure/macventure.h"
+#include "macventure/prebuilt_dialogs.h"
+
+namespace MacVenture {
+
+using namespace Graphics::MacGUIConstants;
+class Gui;
+class DialogElement;
+
+class Dialog {
+public:
+	Dialog(Gui *gui, Common::Point pos, uint width, uint height);
+	Dialog(Gui *gui, PrebuiltDialogs prebuilt);
+
+	~Dialog();
+
+	bool processEvent(Common::Event event);
+	void draw();
+	void localize(Common::Point &point);
+	void handleDialogAction(DialogElement *trigger, DialogAction action);
+
+	const Graphics::Font &getFont();
+
+	void addButton(Common::String title, DialogAction action, Common::Point position, uint width = 0, uint height = 0);
+	void addText(Common::String content, Common::Point position);
+	void addTextInput(Common::Point position, int width, int height);
+
+	void setUserInput(Common::String content);
+
+private:
+	void addPrebuiltElement(const PrebuiltDialogElement &element);
+
+	void calculateBoundsFromPrebuilt(const PrebuiltDialogBounds &bounds);
+
+private:
+	Gui *_gui;
+
+	Common::String _userInput;
+	Common::Array<DialogElement*> _elements;
+	Common::Rect _bounds;
+};
+
+class DialogElement {
+public:
+	DialogElement(Dialog *dialog, Common::String title, DialogAction action, Common::Point position, uint width = 0, uint height = 0);
+	virtual ~DialogElement() {}
+
+	bool processEvent(Dialog *dialog, Common::Event event);
+	void draw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target);
+	const Common::String &getText();
+
+private:
+	virtual bool doProcessEvent(Dialog *dialog, Common::Event event) = 0;
+	virtual void doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target) = 0;
+	virtual const Common::String &doGetText();
+
+protected:
+	Common::String _text;
+	Common::Rect _bounds;
+	DialogAction _action;
+};
+
+// Dialog elements
+class DialogButton : public DialogElement {
+public:
+	DialogButton(Dialog *dialog, Common::String title, DialogAction action, Common::Point position, uint width = 0, uint height = 0);
+	~DialogButton() {}
+
+private:
+	bool doProcessEvent(Dialog *dialog, Common::Event event);
+	void doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target);
+};
+
+class DialogPlainText : public DialogElement {
+public:
+	DialogPlainText(Dialog *dialog, Common::String content, Common::Point position);
+	~DialogPlainText();
+
+private:
+	bool doProcessEvent(Dialog *dialog, Common::Event event);
+	void doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target);
+};
+
+class DialogTextInput : public DialogElement {
+public:
+	DialogTextInput(Dialog *dialog, Common::Point position, uint width, uint height);
+	~DialogTextInput();
+
+private:
+	bool doProcessEvent(Dialog *dialog, Common::Event event);
+	void doDraw(MacVenture::Dialog *dialog, Graphics::ManagedSurface &target);
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/gui.cpp b/engines/macventure/gui.cpp
new file mode 100644
index 0000000000..dff41b3c23
--- /dev/null
+++ b/engines/macventure/gui.cpp
@@ -0,0 +1,1464 @@
+/* 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/file.h"
+#include "common/system.h"
+#include "common/debug-channels.h"
+#include "common/debug.h"
+#include "image/bmp.h"
+
+#include "macventure/gui.h"
+#include "macventure/dialog.h"
+
+namespace MacVenture {
+
+enum MenuAction;
+
+enum {
+	kCursorWidth = 2,
+	kCursorHeight = 2
+};
+
+enum {
+	kExitButtonWidth = 10,
+	kExitButtonHeight = 10
+};
+
+enum {
+	kMenuHighLevel = -1,
+	kMenuAbout = 0,
+	kMenuFile = 1,
+	kMenuEdit = 2,
+	kMenuSpecial = 3
+};
+
+enum {
+	kCommandNum = 8
+};
+
+enum {
+	kDragThreshold = 5
+};
+
+const bool kLoadStaticMenus = true;
+
+static const Graphics::MenuData menuSubItems[] = {
+	{ kMenuHighLevel,	"File",				0, 0, false },
+	{ kMenuHighLevel,	"Edit",				0, 0, false },
+	{ kMenuHighLevel,	"Special",			0, 0, false },
+	{ kMenuHighLevel,	"Font",				0, 0, false },
+	{ kMenuHighLevel,	"FontSize",			0, 0, false },
+
+	//{ kMenuAbout,		"About",			kMenuActionAbout, 0, true},
+
+	{ kMenuFile,		"New",				kMenuActionNew, 0, true },
+	{ kMenuFile,		NULL,				0, 0, false },
+	{ kMenuFile,		"Open...",			kMenuActionOpen, 0, true },
+	{ kMenuFile,		"Save",				kMenuActionSave, 0, true },
+	{ kMenuFile,		"Save as...",		kMenuActionSaveAs, 0, true },
+	{ kMenuFile,		NULL,				0, 0, false },
+	{ kMenuFile,		"Quit",				kMenuActionQuit, 0, true },
+
+	{ kMenuEdit,		"Undo",				kMenuActionUndo, 'Z', false },
+	{ kMenuEdit,		NULL,				0, 0, false },
+	{ kMenuEdit,		"Cut",				kMenuActionCut, 'K', false },
+	{ kMenuEdit,		"Copy",				kMenuActionCopy, 'C', false },
+	{ kMenuEdit,		"Paste",			kMenuActionPaste, 'V', false },
+	{ kMenuEdit,		"Clear",			kMenuActionClear, 'B', false },
+
+	{ kMenuSpecial,		"Clean Up",			kMenuActionCleanUp, 0, false },
+	{ kMenuSpecial,		"Mess Up",			kMenuActionMessUp, 0, false },
+
+	{ 0,				NULL,				0, 0, false }
+};
+
+
+bool commandsWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool mainGameWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool outConsoleWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool selfWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool exitsWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool diplomaWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+bool inventoryWindowCallback(Graphics::WindowClick, Common::Event &event, void *gui);
+
+void menuCommandsCallback(int action, Common::String &text, void *data);
+
+Gui::Gui(MacVentureEngine *engine, Common::MacResManager *resman) {
+	_engine = engine;
+	_resourceManager = resman;
+	_windowData = NULL;
+	_controlData = NULL;
+	_draggedObj.id = 0;
+	_draggedObj.pos = Common::Point(0, 0);
+	_dialog = NULL;
+
+	_cursor = new Cursor(this);
+
+	_consoleText = new ConsoleText(this);
+	_graphics = NULL;
+
+	initGUI();
+}
+
+Gui::~Gui() {
+
+	if (_windowData)
+		delete _windowData;
+
+	if (_controlData)
+		delete _controlData;
+
+	if (_exitsData)
+		delete _exitsData;
+
+	if (_cursor)
+		delete _cursor;
+
+	if (_consoleText)
+		delete _consoleText;
+
+	if (_dialog)
+		delete _dialog;
+
+	clearAssets();
+
+	if (_graphics)
+		delete _graphics;
+}
+
+void Gui::initGUI() {
+	_screen.create(kScreenWidth, kScreenHeight, Graphics::PixelFormat::createFormatCLUT8());
+	_wm.setScreen(&_screen);
+
+	// Menu
+	_menu = _wm.addMenu();
+	if (!loadMenus())
+		error("GUI: Could not load menus");
+	_menu->setCommandsCallback(menuCommandsCallback, this);
+	_menu->calcDimensions();
+
+	loadGraphics();
+
+	if (!loadWindows())
+		error("GUI: Could not load windows");
+
+	initWindows();
+
+	assignObjReferences();
+
+	if (!loadControls())
+		error("GUI: Could not load controls");
+
+	draw();
+
+}
+
+void Gui::reloadInternals() {
+	clearAssets();
+	loadGraphics();
+}
+
+void Gui::draw() {
+	// Will be performance-improved after the milestone
+	_wm.setFullRefresh(true);
+
+	drawWindows();
+
+	_wm.draw();
+
+	drawDraggedObject();
+	drawDialog();
+	// TODO: When window titles with custom borders are in MacGui, this should be used.
+	//drawWindowTitle(kMainGameWindow, _mainGameWindow->getSurface());
+}
+
+void Gui::drawMenu() {
+	_menu->draw(&_screen);
+}
+
+void Gui::drawTitle() {
+	warning("drawTitle hasn't been tested yet");
+}
+
+void Gui::clearControls() {
+	if (!_controlData)
+		return;
+
+	Common::Array<CommandButton>::iterator it = _controlData->begin();
+	for (; it != _controlData->end(); ++it) {
+		it->unselect();
+	}
+}
+
+void Gui::initWindows() {
+	// Game Controls Window
+	_controlsWindow = _wm.addWindow(false, false, false);
+	_controlsWindow->setDimensions(getWindowData(kCommandsWindow).bounds);
+	_controlsWindow->setActive(false);
+	_controlsWindow->setCallback(commandsWindowCallback, this);
+	loadBorders(_controlsWindow, findWindowData(kCommandsWindow).type);
+
+	// Main Game Window
+	_mainGameWindow = _wm.addWindow(false, false, false);
+	_mainGameWindow->setDimensions(getWindowData(kMainGameWindow).bounds);
+	_mainGameWindow->setActive(false);
+	_mainGameWindow->setCallback(mainGameWindowCallback, this);
+	loadBorders(_mainGameWindow, findWindowData(kMainGameWindow).type);
+
+	// In-game Output Console
+	_outConsoleWindow = _wm.addWindow(true, true, false);
+	// HACK We have to hand-create the dimensions, otherwise they don't fit
+	const WindowData &wd = getWindowData(kOutConsoleWindow);
+	Common::Rect dimensions = wd.bounds;
+	dimensions.setWidth(dimensions.width() - borderBounds(wd.type).rightOffset);
+	_outConsoleWindow->setDimensions(dimensions);
+	_outConsoleWindow->setActive(false);
+	_outConsoleWindow->setCallback(outConsoleWindowCallback, this);
+	loadBorders(_outConsoleWindow, findWindowData(kOutConsoleWindow).type);
+
+	// Self Window
+	_selfWindow = _wm.addWindow(false, true, false);
+	_selfWindow->setDimensions(getWindowData(kSelfWindow).bounds);
+	_selfWindow->setActive(false);
+	_selfWindow->setCallback(selfWindowCallback, this);
+	loadBorders(_selfWindow, findWindowData(kSelfWindow).type);
+
+	// Exits Window
+	_exitsWindow = _wm.addWindow(false, false, false);
+	_exitsWindow->setDimensions(getWindowData(kExitsWindow).bounds);
+	_exitsWindow->setActive(false);
+	_exitsWindow->setCallback(exitsWindowCallback, this);
+	loadBorders(_exitsWindow, findWindowData(kExitsWindow).type);
+}
+
+const WindowData &Gui::getWindowData(WindowReference reference) {
+	return findWindowData(reference);
+}
+
+const Graphics::Font &Gui::getCurrentFont() {
+	return *_wm.getFont("Chicago-12", Graphics::FontManager::kBigGUIFont);
+}
+
+void Gui::bringToFront(WindowReference winID) {
+	findWindow(winID)->setActive(true);
+}
+
+void Gui::setWindowTitle(WindowReference winID, Common::String string) {
+	findWindowData(winID).title = string;
+	findWindowData(winID).titleLength = string.size();
+}
+
+void Gui::updateWindowInfo(WindowReference ref, ObjID objID, const Common::Array<ObjID> &children) {
+	if (ref == kNoWindow) {
+		return;
+	}
+	WindowData &data = findWindowData(ref);
+	data.children.clear();
+	data.objRef = objID;
+	uint32 originx = 0x7fff;
+	uint32 originy = 0x7fff;
+	for (uint i = 0; i < children.size(); i++) {
+		if (children[i] != 1) {
+			ObjID child = children[i];
+			if (ref != kMainGameWindow) {
+				Common::Point childPos = _engine->getObjPosition(child);
+				originx = originx > (uint)childPos.x ? (uint)childPos.x : originx;
+				originy = originy > (uint)childPos.y ? (uint)childPos.y : originy;
+			}
+			data.children.push_back(DrawableObject(child, kBlitBIC));
+		}
+	}
+	if (originx != 0x7fff) {
+		data.bounds.left = originx;
+	}
+	if (originy != 0x7fff) {
+		data.bounds.top = originy;
+	}
+	if (ref != kMainGameWindow) {
+		data.updateScroll = true;
+	}
+}
+
+void Gui::addChild(WindowReference target, ObjID child) {
+	findWindowData(target).children.push_back(DrawableObject(child, kBlitBIC));
+}
+
+void Gui::removeChild(WindowReference target, ObjID child) {
+	WindowData &data = findWindowData(target);
+	uint index = 0;
+	for (;index < data.children.size(); index++) {
+		if (data.children[index].obj == child) {
+			break;
+		}
+	}
+
+	if (index < data.children.size())
+		data.children.remove_at(index);
+}
+
+void Gui::assignObjReferences() {
+	findWindowData(kSelfWindow).objRef = 0;
+}
+
+WindowReference Gui::createInventoryWindow(ObjID objRef) {
+	Graphics::MacWindow *newWindow = _wm.addWindow(true, true, true);
+	WindowData newData;
+	GlobalSettings settings = _engine->getGlobalSettings();
+	newData.refcon = (WindowReference)ABS(_inventoryWindows.size() + kInventoryStart); // This is a HACK
+
+	if (_windowData->back().refcon < 0x80) { // There is already another inventory window
+		newData.bounds = _windowData->back().bounds; // Inventory windows are always last
+		newData.bounds.translate(newData.bounds.left + settings._invOffsetX, newData.bounds.top + settings._invOffsetY);
+	} else {
+		BorderBounds bbs = borderBounds(kInvWindow);
+		newData.bounds = Common::Rect(
+			settings._invLeft - bbs.leftOffset,
+			settings._invTop - bbs.topOffset,
+			settings._invLeft + settings._invWidth,
+			settings._invTop + settings._invHeight);
+	}
+	newData.type = kInvWindow;
+	newData.hasCloseBox = true;
+	newData.visible = true;
+	newData.objRef = objRef;
+	_windowData->push_back(newData);
+
+	newWindow->setDimensions(newData.bounds);
+	newWindow->setCallback(inventoryWindowCallback, this);
+	newWindow->setCloseable(true);
+	loadBorders(newWindow, newData.type);
+	_inventoryWindows.push_back(newWindow);
+
+	debugC(1, kMVDebugGUI, "Create new inventory window. Reference: %d", newData.refcon);
+	return newData.refcon;
+}
+
+void Gui::loadBorders(Graphics::MacWindow *target, MVWindowType type) {
+	loadBorder(target, type, false);
+	loadBorder(target, type, true);
+}
+
+void Gui::loadBorder(Graphics::MacWindow *target, MVWindowType type, bool active) {
+
+	Common::SeekableReadStream *stream = _engine->getBorderFile(type, active);
+
+	if (stream) {
+		BorderBounds bbs = borderBounds(type);
+		target->loadBorder(*stream, active, bbs.leftOffset, bbs.rightOffset, bbs.topOffset, bbs.bottomOffset);
+
+		delete stream;
+	}
+}
+
+void Gui::loadGraphics() {
+	if (_graphics)
+		delete _graphics;
+	_graphics = new Container(_engine->getFilePath(kGraphicPathID));
+}
+
+void Gui::clearAssets() {
+	Common::HashMap<ObjID, ImageAsset*>::const_iterator it = _assets.begin();
+	for (; it != _assets.end(); it++) {
+		delete it->_value;
+	}
+	_assets.clear();
+}
+
+bool Gui::loadMenus() {
+
+	if (kLoadStaticMenus) {
+		// We assume that, if there are static menus, we don't need dynamic ones
+		_menu->addStaticMenus(menuSubItems);
+		return true;
+	}
+
+	Common::MacResIDArray resArray;
+	Common::SeekableReadStream *res;
+	Common::MacResIDArray::const_iterator iter;
+
+	if ((resArray = _resourceManager->getResIDArray(MKTAG('M', 'E', 'N', 'U'))).size() == 0)
+		return false;
+
+	_menu->addMenuSubItem(0, "Abb", kMenuActionAbout, 0, 'A', true);
+
+	int i = 1;
+	for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
+		res = _resourceManager->getResource(MKTAG('M', 'E', 'N', 'U'), *iter);
+		uint16 key;
+		uint16 style;
+		uint8 titleLength;
+		char *title;
+
+		/* Skip menuID, width, height, resourceID, placeholder */
+		for (int skip = 0; skip < 5; skip++) {
+			res->readUint16BE();
+		}
+		titleLength = res->readByte();
+		title = new char[titleLength + 1];
+		res->read(title, titleLength);
+		title[titleLength] = '\0';
+
+		if (titleLength > 1) {
+			_menu->addMenuItem(title);
+
+			// Read submenu items
+			while ((titleLength = res->readByte())) {
+				title = new char[titleLength + 1];
+				res->read(title, titleLength);
+				title[titleLength] = '\0';
+				// Skip icon
+				res->readUint16BE();
+				// Read key
+				key = res->readUint16BE();
+				// Skip mark
+				res->readUint16BE();
+				// Read style
+				style = res->readUint16BE();
+				_menu->addMenuSubItem(i, title, 0, style, key, false);
+			}
+		}
+
+		i++;
+		delete res;
+	}
+
+	return true;
+}
+
+bool Gui::loadWindows() {
+	Common::MacResIDArray resArray;
+	Common::SeekableReadStream *res;
+	Common::MacResIDArray::const_iterator iter;
+
+	_windowData = new Common::List<WindowData>();
+
+	if ((resArray = _resourceManager->getResIDArray(MKTAG('W', 'I', 'N', 'D'))).size() == 0)
+		return false;
+
+	uint32 id = kCommandsWindow;
+	for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
+		res = _resourceManager->getResource(MKTAG('W', 'I', 'N', 'D'), *iter);
+		WindowData data;
+		uint16 top, left, bottom, right;
+		top = res->readUint16BE();
+		left = res->readUint16BE();
+		bottom = res->readUint16BE();
+		right = res->readUint16BE();
+		data.type = (MVWindowType)res->readUint16BE();
+		BorderBounds bbs = borderBounds(data.type);
+		data.bounds = Common::Rect(
+			left - bbs.leftOffset,
+			top - bbs.topOffset,
+			right + bbs.rightOffset,
+			bottom + bbs.bottomOffset);
+
+		data.visible = res->readUint16BE();
+		data.hasCloseBox = res->readUint16BE();
+		data.refcon = (WindowReference)id; id++;
+		res->readUint32BE(); // Skip the true id. For some reason it's reading 0
+		data.titleLength = res->readByte();
+		if (data.titleLength) {
+			char *newTitle = new char[data.titleLength + 1];
+			res->read(newTitle, data.titleLength);
+			newTitle[data.titleLength] = '\0';
+			data.title = Common::String(newTitle);
+			delete[] newTitle;
+		}
+		data.scrollPos = Common::Point(0, 0);
+
+		debugC(1, kMVDebugGUI, "Window loaded: %s", data.title.c_str());
+
+		_windowData->push_back(data);
+
+		delete res;
+	}
+
+	return true;
+}
+
+bool Gui::loadControls() {
+	Common::MacResIDArray resArray;
+	Common::SeekableReadStream *res;
+	Common::MacResIDArray::const_iterator iter;
+
+	_controlData = new Common::Array<CommandButton>();
+	_exitsData = new Common::Array<CommandButton>();
+
+	if ((resArray = _resourceManager->getResIDArray(MKTAG('C', 'N', 'T', 'L'))).size() == 0)
+		return false;
+
+	uint32 id = kControlExitBox;
+	for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
+		res = _resourceManager->getResource(MKTAG('C', 'N', 'T', 'L'), *iter);
+		ControlData data;
+		uint16 top, left, bottom, right;
+		top = res->readUint16BE();
+		left = res->readUint16BE();
+		bottom = res->readUint16BE();
+		right = res->readUint16BE();
+		data.scrollValue = res->readUint16BE();
+		data.visible = res->readByte();
+		res->readByte(); // Unused
+		data.scrollMax = res->readUint16BE();
+		data.scrollMin = res->readUint16BE();
+		data.cdef = res->readUint16BE();
+		data.refcon = (ControlAction)res->readUint32BE();
+		data.type = (ControlType)id; id++;
+		data.titleLength = res->readByte();
+		if (data.titleLength) {
+			char *title = new char[data.titleLength + 1];
+			res->read(title, data.titleLength);
+			title[data.titleLength] = '\0';
+			data.title = Common::String(title);
+			delete[] title;
+		}
+		if (data.type != kControlExitBox) {
+			BorderBounds bbs = borderBounds(getWindowData(kCommandsWindow).type);
+			// We just want to move the button, not change it's size
+			data.bounds = Common::Rect(left + bbs.leftOffset, top + bbs.topOffset, right + bbs.leftOffset, bottom + bbs.topOffset);
+		} else {
+			data.bounds = Common::Rect(left, top, right, bottom);
+		}
+
+
+		_controlData->push_back(CommandButton(data, this));
+
+		delete res;
+	}
+
+	return true;
+}
+
+void Gui::drawWindows() {
+
+	drawCommandsWindow();
+	drawMainGameWindow();
+	drawSelfWindow();
+	drawInventories();
+	drawExitsWindow();
+	drawConsoleWindow();
+
+}
+
+void Gui::drawCommandsWindow() {
+	if (_engine->needsClickToContinue()) {
+		Graphics::ManagedSurface *srf = _controlsWindow->getSurface();
+		WindowData data = getWindowData(kCommandsWindow);
+		srf->fillRect(Common::Rect(0, 0, srf->w, srf->h), kColorWhite);
+		getCurrentFont().drawString(
+			srf,
+			_engine->getCommandsPausedString(),
+			0,
+			(srf->h / 2) - getCurrentFont().getFontHeight(),
+			data.bounds.right - data.bounds.left,
+			kColorBlack,
+			Graphics::kTextAlignCenter);
+	} else {
+		Common::Array<CommandButton>::const_iterator it = _controlData->begin();
+		for (; it != _controlData->end(); ++it) {
+			CommandButton button = *it;
+			if (button.getData().type != kControlExitBox)
+				button.draw(*_controlsWindow->getSurface());
+		}
+	}
+}
+
+void Gui::drawMainGameWindow() {
+	const WindowData &data = getWindowData(kMainGameWindow);
+	BorderBounds border = borderBounds(data.type);
+	ObjID objRef = data.objRef;
+
+	_mainGameWindow->setDirty(true);
+
+	if (data.objRef > 0 && data.objRef < 2000) {
+		ensureAssetLoaded(objRef);
+
+		_assets[objRef]->blitInto(
+			_mainGameWindow->getSurface(),
+			border.leftOffset,
+			border.topOffset,
+			kBlitDirect);
+	}
+
+	drawObjectsInWindow(data, _mainGameWindow->getSurface());
+
+	if (DebugMan.isDebugChannelEnabled(kMVDebugGUI)) {
+		Graphics::MacWindow *win = findWindow(data.refcon);
+		Common::Rect innerDims = win->getInnerDimensions();
+		int x = win->getDimensions().left;
+		int y = win->getDimensions().top;
+		innerDims.translate(-x, -y);
+		win->getSurface()->frameRect(innerDims, kColorGreen);
+	}
+
+	findWindow(kMainGameWindow)->setDirty(true);
+}
+
+void Gui::drawSelfWindow() {
+	drawObjectsInWindow(getWindowData(kSelfWindow), _selfWindow->getSurface());
+	if (_engine->isObjSelected(1)) {
+		invertWindowColors(kSelfWindow);
+	}
+	findWindow(kSelfWindow)->setDirty(true);
+}
+
+void Gui::drawInventories() {
+
+	Graphics::ManagedSurface *srf;
+	for (uint i = 0; i < _inventoryWindows.size(); i++) {
+		const WindowData &data = getWindowData((WindowReference)(kInventoryStart + i));
+		Graphics::MacWindow *win = findWindow(data.refcon);
+		srf = win->getSurface();
+		srf->clear(kColorGreen);
+		srf->fillRect(srf->getBounds(), kColorWhite);
+		drawObjectsInWindow(data, srf);
+
+		if (DebugMan.isDebugChannelEnabled(kMVDebugGUI)) {
+			Common::Rect innerDims = win->getInnerDimensions();
+			int x = win->getDimensions().left;
+			int y = win->getDimensions().top;
+			innerDims.translate(-x, -y);
+			srf->frameRect(innerDims, kColorGreen);
+		}
+
+		findWindow(data.refcon)->setDirty(true);
+	}
+
+}
+
+void Gui::drawExitsWindow() {
+
+	Graphics::ManagedSurface *srf = _exitsWindow->getSurface();
+	BorderBounds border = borderBounds(getWindowData(kExitsWindow).type);
+
+	srf->fillRect(Common::Rect(
+		border.leftOffset,
+		border.topOffset,
+		srf->w + border.rightOffset,
+		srf->h + border.bottomOffset), kColorWhite);
+
+	Common::Array<CommandButton>::const_iterator it = _exitsData->begin();
+	for (; it != _exitsData->end(); ++it) {
+		CommandButton button = *it;
+		button.draw(*_exitsWindow->getSurface());
+	}
+
+	findWindow(kExitsWindow)->setDirty(true);
+}
+
+void Gui::drawConsoleWindow() {
+
+	Graphics::ManagedSurface *srf = _outConsoleWindow->getSurface();
+	BorderBounds bounds = borderBounds(getWindowData(kOutConsoleWindow).type);
+	_consoleText->renderInto(srf, bounds, kConsoleLeftOffset);
+}
+
+void Gui::drawObjectsInWindow(const WindowData &targetData, Graphics::ManagedSurface *surface) {
+	BorderBounds border = borderBounds(targetData.type);
+	Common::Point pos;
+	ObjID child;
+	BlitMode mode;
+
+	if (targetData.children.size() == 0) {
+		return;
+	}
+
+	Graphics::ManagedSurface composeSurface;
+	createInnerSurface(&composeSurface, surface, border);
+	assert(composeSurface.w <= surface->w &&
+			composeSurface.h <= surface->h);
+	composeSurface.clear(kColorGreen);
+
+	for (uint i = 0; i < targetData.children.size(); i++) {
+		child = targetData.children[i].obj;
+		mode = (BlitMode)targetData.children[i].mode;
+		pos = _engine->getObjPosition(child);
+		pos -= targetData.scrollPos;
+		ensureAssetLoaded(child);
+
+		_assets[child]->blitInto(
+			&composeSurface,
+			pos.x,
+			pos.y,
+			mode);
+
+		if (_engine->isObjVisible(child)) {
+			if (_engine->isObjSelected(child) ||
+				child == _draggedObj.id) {
+
+				_assets[child]->blitInto(
+					&composeSurface, pos.x, pos.y, kBlitOR);
+			}
+		}
+
+		if (DebugMan.isDebugChannelEnabled(kMVDebugGUI)) {
+			Common::Rect testBounds = _engine->getObjBounds(child);
+			testBounds.translate(-targetData.scrollPos.x, -targetData.scrollPos.y);
+			surface->frameRect(testBounds, kColorGreen);
+		}
+	}
+	Common::Point composePosition = Common::Point(border.leftOffset, border.topOffset);
+	surface->transBlitFrom(composeSurface, composePosition, kColorGreen);
+}
+
+void Gui::drawWindowTitle(WindowReference target, Graphics::ManagedSurface *surface) {
+	// TODO: Implement when MacGui supports titles in windows with custom borders.
+}
+
+void Gui::drawDraggedObject() {
+	if (_draggedObj.id != 0 &&
+		_engine->isObjVisible(_draggedObj.id)) {
+		ensureAssetLoaded(_draggedObj.id);
+		ImageAsset *asset = _assets[_draggedObj.id];
+
+		// In case of overflow from the right/top
+		uint w = asset->getWidth() + MIN((int16)0, _draggedObj.pos.x);
+		uint h = asset->getHeight() + MIN((int16)0, _draggedObj.pos.y);
+
+		// In case of overflow from the bottom/left
+		if (_draggedObj.pos.x > 0 && _draggedObj.pos.x + w > kScreenWidth) {
+			w = kScreenWidth - _draggedObj.pos.x;
+		}
+		if (_draggedObj.pos.y > 0 && _draggedObj.pos.y + h > kScreenHeight) {
+			h = kScreenHeight - _draggedObj.pos.y;
+		}
+
+		Common::Point target = _draggedObj.pos;
+		if (target.x < 0) {
+			target.x = 0;
+		}
+		if (target.y < 0) {
+			target.y = 0;
+		}
+
+		_draggedSurface.create(w, h, _screen.format);
+		_draggedSurface.blitFrom(
+			_screen,
+			Common::Rect(
+				target.x,
+				target.y,
+				target.x + _draggedSurface.w,
+				target.y + _draggedSurface.h),
+			Common::Point(0, 0));
+		asset->blitInto(&_draggedSurface, MIN((int16)0, _draggedObj.pos.x), MIN((int16)0, _draggedObj.pos.y), kBlitBIC);
+
+		g_system->copyRectToScreen(
+			_draggedSurface.getBasePtr(0, 0),
+			_draggedSurface.pitch,
+			target.x,
+			target.y,
+			_draggedSurface.w,
+			_draggedSurface.h
+		);
+	}
+}
+
+void Gui::drawDialog() {
+	if (_dialog) {
+		_dialog->draw();
+	}
+}
+
+void Gui::updateWindow(WindowReference winID, bool containerOpen) {
+	if (winID == kNoWindow) {
+		return;
+	}
+	if (winID == kSelfWindow || containerOpen) {
+		WindowData &data = findWindowData(winID);
+		if (winID == kCommandsWindow) {
+			Common::Array<CommandButton>::iterator it = _controlData->begin();
+			for (; it != _controlData->end(); ++it) {
+				it->unselect();
+			}
+		}
+		Common::Array<DrawableObject> &children = data.children;
+		for (uint i = 0; i < children.size(); i++) {
+			uint flag = 0;
+			ObjID child = children[i].obj;
+			BlitMode mode = kBlitDirect;
+			bool off = !_engine->isObjVisible(child);
+			if (flag || !off || !_engine->isObjClickable(child)) {
+				mode = kBlitBIC;
+				if (off || flag) {
+					mode = kBlitXOR;
+				} else if (!off && _engine->isObjSelected(child)) {
+					mode = kBlitOR;
+				}
+				children[i] = DrawableObject(child, mode);
+			} else {
+				children[i] = DrawableObject(child, kBlitXOR);
+			}
+		}
+		if (winID == kMainGameWindow) {
+			drawMainGameWindow();
+		} else {
+			Graphics::MacWindow *winRef = findWindow(winID);
+			winRef->getSurface()->fillRect(data.bounds, kColorGray);
+		}
+		if (data.type == kZoomDoc && data.updateScroll) {
+			warning("Unimplemented: update scroll");
+		}
+	}
+}
+
+void Gui::clearExits() {
+	_exitsData->clear();
+}
+
+void Gui::unselectExits() {
+	Common::Array<CommandButton>::const_iterator it = _exitsData->begin();
+	for (; it != _exitsData->end(); ++it) {
+		CommandButton button = *it;
+		button.unselect();
+	}
+}
+
+void Gui::updateExit(ObjID obj) {
+	if (!_engine->isObjExit(obj)) {
+		return;
+	}
+	BorderBounds border = borderBounds(getWindowData(kExitsWindow).type);
+
+	int ctl = -1;
+	int i = 0;
+	Common::Array<CommandButton>::const_iterator it = _exitsData->begin();
+	for (;it != _exitsData->end(); it++) {
+		if (it->getData().refcon == obj)
+			ctl = i;
+		else
+			i++;
+	}
+
+	if (ctl != -1)
+		_exitsData->remove_at(ctl);
+
+	if (!_engine->isHiddenExit(obj) &&
+		_engine->getParent(obj) == _engine->getParent(1)) {
+		ControlData data;
+		data.titleLength = 0;
+		data.refcon = (ControlAction)obj; // Objects can be exits (actions)
+		Common::Point pos = _engine->getObjExitPosition(obj);
+		pos.x += border.leftOffset;
+		pos.y += border.topOffset;
+		data.bounds = Common::Rect(pos.x, pos.y, pos.x + kExitButtonWidth, pos.y + kExitButtonHeight);
+		data.visible = true;
+
+		_exitsData->push_back(CommandButton(data, this));
+	}
+}
+
+void Gui::printText(const Common::String &text) {
+	debugC(1, kMVDebugGUI, "Print Text: %s", text.c_str());
+	_consoleText->printLine(text, _outConsoleWindow->getDimensions().width());
+}
+
+void Gui::showPrebuiltDialog(PrebuiltDialogs type) {
+	closeDialog();
+	_dialog = new Dialog(this, type);
+}
+
+bool Gui::isDialogOpen() {
+	return _dialog != NULL;
+}
+
+void Gui::setTextInput(Common::String str) {
+	_engine->setTextInput(str);
+}
+
+
+void Gui::closeDialog() {
+	delete _dialog;
+	_dialog = NULL;
+}
+
+void Gui::getTextFromUser() {
+	if (_dialog) {
+		delete _dialog;
+	}
+	showPrebuiltDialog(kSpeakDialog);
+}
+
+void Gui::loadGame() {
+	_engine->scummVMSaveLoadDialog(false);
+}
+
+void Gui::saveGame() {
+	_engine->scummVMSaveLoadDialog(true);
+}
+
+void Gui::newGame() {
+	_engine->newGame();
+}
+
+void Gui::quitGame() {
+	_engine->requestQuit();
+}
+
+void Gui::createInnerSurface(Graphics::ManagedSurface *innerSurface, Graphics::ManagedSurface *outerSurface, const BorderBounds &borders) {
+	innerSurface->create(
+		outerSurface->w - borders.leftOffset - borders.rightOffset,
+		outerSurface->h - borders.topOffset - borders.bottomOffset,
+		outerSurface->format);
+}
+
+void Gui::moveDraggedObject(Common::Point target) {
+	ensureAssetLoaded(_draggedObj.id);
+	_draggedObj.pos = target + _draggedObj.mouseOffset;
+
+	// TODO FInd more elegant way of making pow2
+	_draggedObj.hasMoved = (_draggedObj.startPos.sqrDist(_draggedObj.pos) >= (kDragThreshold * kDragThreshold));
+
+	debugC(4, kMVDebugGUI, "Dragged obj position: (%d, %d), mouse offset: (%d, %d), hasMoved: %d, dist: %d, threshold: %d",
+		_draggedObj.pos.x, _draggedObj.pos.y,
+		_draggedObj.mouseOffset.x, _draggedObj.mouseOffset.y,
+		_draggedObj.hasMoved,
+		_draggedObj.startPos.sqrDist(_draggedObj.pos),
+		kDragThreshold * kDragThreshold
+	);
+
+}
+
+WindowReference Gui::findWindowAtPoint(Common::Point point) {
+	Common::List<WindowData>::iterator it;
+	Graphics::MacWindow *win;
+	for (it = _windowData->begin(); it != _windowData->end(); it++) {
+		win = findWindow(it->refcon);
+		if (win && it->refcon != kDiplomaWindow) { //HACK, diploma should be cosnidered
+			if (win->getDimensions().contains(point)) {
+				return it->refcon;
+			}
+		}
+	}
+	return kNoWindow;
+}
+
+Common::Point Gui::getGlobalScrolledSurfacePosition(WindowReference reference) {
+	const WindowData &data = getWindowData(reference);
+	BorderBounds border = borderBounds(data.type);
+	Graphics::MacWindow *win = findWindow(reference);
+	if (!win) {
+		return Common::Point(0, 0);
+	}
+	return Common::Point(
+		win->getDimensions().left + border.leftOffset - data.scrollPos.x,
+		win->getDimensions().top + border.topOffset - data.scrollPos.y);
+}
+
+WindowData &Gui::findWindowData(WindowReference reference) {
+	assert(_windowData);
+
+	Common::List<WindowData>::iterator iter = _windowData->begin();
+	while (iter->refcon != reference && iter != _windowData->end()) {
+		iter++;
+	}
+
+	if (iter->refcon == reference)
+		return *iter;
+
+	error("GUI: Could not locate the desired window data");
+}
+
+Graphics::MacWindow *Gui::findWindow(WindowReference reference) {
+	if (reference < 0x80 && reference >= kInventoryStart) { // It's an inventory window
+		return _inventoryWindows[reference - kInventoryStart];
+	}
+	switch (reference) {
+	case MacVenture::kNoWindow:
+		return NULL;
+	case MacVenture::kCommandsWindow:
+		return _controlsWindow;
+	case MacVenture::kMainGameWindow:
+		return _mainGameWindow;
+	case MacVenture::kOutConsoleWindow:
+		return _outConsoleWindow;
+	case MacVenture::kSelfWindow:
+		return _selfWindow;
+	case MacVenture::kExitsWindow:
+		return _exitsWindow;
+	case MacVenture::kDiplomaWindow:
+		return _diplomaWindow;
+	default:
+		return NULL;
+	}
+	return NULL;
+}
+
+void Gui::ensureInventoryOpen(WindowReference reference, ObjID id) {
+	assert(reference < 0x80 && reference >= kInventoryStart);
+	if (reference - kInventoryStart == (int)_inventoryWindows.size()) {
+		createInventoryWindow(id);
+	}
+}
+
+WindowReference Gui::getObjWindow(ObjID objID) {
+	switch (objID) {
+	case 0xfffc: return kExitsWindow;
+	case 0xfffd: return kSelfWindow;
+	case 0xfffe: return kOutConsoleWindow;
+	case 0xffff: return kCommandsWindow;
+	}
+
+	return findObjWindow(objID);
+}
+
+WindowReference Gui::findObjWindow(ObjID objID) {
+	// This is a bit of a HACK, we take advantage of the consecutive nature of references
+	for (uint i = kCommandsWindow; i <= kDiplomaWindow; i++) {
+		const WindowData &data = getWindowData((WindowReference)i);
+		if (data.objRef == objID) {
+			return data.refcon;
+		}
+	}
+
+	for (uint i = kInventoryStart; i < _inventoryWindows.size() + kInventoryStart; i++) {
+		const WindowData &data = getWindowData((WindowReference)i);
+		if (data.objRef == objID) {
+			return data.refcon;
+		}
+	}
+
+	return kNoWindow;
+}
+
+void Gui::checkSelect(const WindowData &data, Common::Point pos, const Common::Rect &clickRect, WindowReference ref) {
+	ObjID child = 0;
+	for (Common::Array<DrawableObject>::const_iterator it = data.children.begin(); it != data.children.end(); it++) {
+		if (canBeSelected((*it).obj, clickRect, ref)) {
+			child = (*it).obj;
+		}
+	}
+	if (child != 0) {
+		selectDraggable(child, ref, pos);
+		bringToFront(ref);
+	}
+}
+
+bool Gui::canBeSelected(ObjID obj, const Common::Rect &clickRect, WindowReference ref) {
+	return (_engine->isObjClickable(obj) &&
+			isRectInsideObject(clickRect, obj));
+}
+
+bool Gui::isRectInsideObject(Common::Rect target, ObjID obj) {
+	ensureAssetLoaded(obj);
+	Common::Rect bounds = _engine->getObjBounds(obj);
+	Common::Rect intersection = bounds.findIntersectingRect(target);
+	// We translate it to the image's coord system
+	intersection = Common::Rect(
+		intersection.left - bounds.left,
+		intersection.top - bounds.top,
+		intersection.left - bounds.left + intersection.width(),
+		intersection.top - bounds.top + intersection.height());
+
+	return _assets[obj]->isRectInside(intersection);
+}
+
+void Gui::selectDraggable(ObjID child, WindowReference origin, Common::Point click) {
+	if (_engine->isObjClickable(child) && _draggedObj.id == 0) {
+		_draggedObj.hasMoved = false;
+		_draggedObj.id = child;
+		_draggedObj.startWin = origin;
+		Common::Point localizedClick = click - getGlobalScrolledSurfacePosition(origin);
+		_draggedObj.mouseOffset = _engine->getObjPosition(child) - localizedClick;
+		_draggedObj.pos = click + _draggedObj.mouseOffset;
+		_draggedObj.startPos = _draggedObj.pos;
+	}
+}
+
+void Gui::handleDragRelease(bool shiftPressed, bool isDoubleClick) {
+	if (_draggedObj.id != 0) {
+		WindowReference destinationWindow = findWindowAtPoint(_draggedObj.pos);
+		if (destinationWindow == kNoWindow) {
+			return;
+		}
+		if (_draggedObj.hasMoved) {
+			const WindowData &destinationWindowData = getWindowData(destinationWindow);
+			ObjID destObject = destinationWindowData.objRef;
+			Common::Point dropPosition = _draggedObj.pos - _draggedObj.startPos;
+			dropPosition = localizeTravelledDistance(dropPosition, _draggedObj.startWin, destinationWindow);
+			debugC(3, kMVDebugGUI, "Drop the object %d at obj %d, pos (%d, %d)", _draggedObj.id, destObject, dropPosition.x, dropPosition.y);
+
+			_engine->handleObjectDrop(_draggedObj.id, dropPosition, destObject);
+		}
+		_engine->handleObjectSelect(_draggedObj.id, destinationWindow, shiftPressed, isDoubleClick);
+		_draggedObj.id = 0;
+		_draggedObj.hasMoved = false;
+	}
+}
+
+Common::Rect Gui::calculateClickRect(Common::Point clickPos, Common::Rect windowBounds) {
+	int left = clickPos.x - windowBounds.left;
+	int top = clickPos.y - windowBounds.top;
+	return Common::Rect(left - kCursorWidth, top - kCursorHeight, left + kCursorWidth, top + kCursorHeight);
+}
+
+Common::Point Gui::localizeTravelledDistance(Common::Point point, WindowReference origin, WindowReference target) {
+	if (origin != target) {
+		// ori.local to global
+		point += getGlobalScrolledSurfacePosition(origin);
+		if (findWindow(target)) {
+			// dest.globalToLocal
+			point -= getGlobalScrolledSurfacePosition(target);
+		}
+	}
+	return point;
+}
+
+void Gui::removeInventoryWindow(WindowReference ref) {
+	_inventoryWindows.remove_at(ref - kInventoryStart);
+	bool found = false;
+	Common::List<WindowData>::iterator it;
+	for (it = _windowData->begin(); it != _windowData->end() && !found; it++) {
+		if (it->refcon == ref) {
+			_windowData->erase(it);
+			found = true;
+		}
+	}
+}
+
+
+/* HANDLERS */
+void Gui::handleMenuAction(MenuAction action) {
+	switch (action)	{
+	case MacVenture::kMenuActionAbout:
+		warning("Unimplemented MacVenture Menu Action: About");
+		break;
+	case MacVenture::kMenuActionNew:
+		_engine->newGame();
+		break;
+	case MacVenture::kMenuActionOpen:
+		loadGame();
+		break;
+	case MacVenture::kMenuActionSave:
+		saveGame();
+		break;
+	case MacVenture::kMenuActionSaveAs:
+		saveGame();
+		break;
+	case MacVenture::kMenuActionQuit:
+		_engine->requestQuit();
+		break;
+	case MacVenture::kMenuActionUndo:
+		warning("Unimplemented MacVenture Menu Action: Undo");
+		break;
+	case MacVenture::kMenuActionCut:
+		warning("Unimplemented MacVenture Menu Action: Cut");
+		break;
+	case MacVenture::kMenuActionCopy:
+		warning("Unimplemented MacVenture Menu Action: Copy");
+		break;
+	case MacVenture::kMenuActionPaste:
+		warning("Unimplemented MacVenture Menu Action: Paste");
+		break;
+	case MacVenture::kMenuActionClear:
+		warning("Unimplemented MacVenture Menu Action: Clear");
+		break;
+	case MacVenture::kMenuActionCleanUp:
+		warning("Unimplemented MacVenture Menu Action: Clean Up");
+		break;
+	case MacVenture::kMenuActionMessUp:
+		warning("Unimplemented MacVenture Menu Action: Mess Up");
+		break;
+	case MacVenture::kMenuActionCommand:
+		warning("Unimplemented MacVenture Menu Action: GENERIC");
+		break;
+	default:
+		break;
+	}
+}
+
+/* CALLBACKS */
+
+bool commandsWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+	return g->processCommandEvents(click, event);
+}
+
+bool mainGameWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+	return g->processMainGameEvents(click, event);
+}
+
+bool outConsoleWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+	return g->processOutConsoleEvents(click, event);
+}
+
+bool selfWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+
+	return g->processSelfEvents(click, event);
+}
+
+bool exitsWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+
+	return g->processExitsEvents(click, event);
+}
+
+bool diplomaWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+
+	return g->processDiplomaEvents(click, event);
+}
+
+bool inventoryWindowCallback(Graphics::WindowClick click, Common::Event &event, void *gui) {
+	Gui *g = (Gui*)gui;
+
+	return g->processInventoryEvents(click, event);
+}
+
+void menuCommandsCallback(int action, Common::String &text, void *data) {
+	Gui *g = (Gui *)data;
+
+	g->handleMenuAction((MenuAction)action);
+}
+
+
+void Gui::invertWindowColors(WindowReference winID) {
+	Graphics::ManagedSurface *srf = findWindow(winID)->getSurface();
+	for (uint y = 0; y < srf->h; y++) {
+		for (uint x = 0; x < srf->w; x++) {
+			byte p = *(byte *)srf->getBasePtr(x, y);
+			*(byte *)srf->getBasePtr(x, y) =
+				(p == kColorWhite) ? kColorBlack : kColorGray;
+		}
+	}
+}
+
+bool Gui::tryCloseWindow(WindowReference winID) {
+	WindowData data = findWindowData(winID);
+	Graphics::MacWindow *win = findWindow(winID);
+	_wm.removeWindow(win);
+	if (winID < 0x80) {
+		removeInventoryWindow(winID);
+	}
+	return true;
+}
+
+Common::Point Gui::getObjMeasures(ObjID obj) {
+	ensureAssetLoaded(obj);
+ 	int w = _assets[obj]->getWidth();
+	int h = _assets[obj]->getHeight();
+	return Common::Point(w, h);
+}
+
+bool Gui::processEvent(Common::Event &event) {
+	bool processed = false;
+
+	processed |= _cursor->processEvent(event);
+
+	if (_dialog && _dialog->processEvent(event)) {
+		return true;
+	}
+
+	if (event.type == Common::EVENT_MOUSEMOVE) {
+		if (_draggedObj.id != 0) {
+			moveDraggedObject(event.mouse);
+		}
+		processed = true;
+	}
+
+	processed |= _wm.processEvent(event);
+	return (processed);
+}
+
+bool Gui::processCommandEvents(WindowClick click, Common::Event &event) {
+	if (event.type == Common::EVENT_LBUTTONUP) {
+		if (_engine->needsClickToContinue()) {
+			_engine->selectControl(kClickToContinue);
+			return true;
+		}
+
+		Common::Point position(
+			event.mouse.x - _controlsWindow->getDimensions().left,
+			event.mouse.y - _controlsWindow->getDimensions().top);
+
+		CommandButton data;
+		if (!_controlData)
+			return false;
+
+		Common::Array<CommandButton>::iterator it = _controlData->begin();
+		for (; it != _controlData->end(); ++it) {
+			if (it->isInsideBounds(position)) {
+				it->select();
+				data = *it;
+			} else {
+				it->unselect();
+			}
+		}
+
+		_engine->selectControl(data.getData().refcon);
+		_engine->refreshReady();
+		_engine->preparedToRun();
+	}
+	return false;
+}
+
+bool MacVenture::Gui::processMainGameEvents(WindowClick click, Common::Event &event) {
+	if (_engine->needsClickToContinue())
+		return true;
+
+	return false;
+}
+
+bool MacVenture::Gui::processOutConsoleEvents(WindowClick click, Common::Event &event) {
+	if (_engine->needsClickToContinue())
+		return true;
+
+	if (click == kBorderScrollUp && event.type == Common::EVENT_LBUTTONDOWN) {
+		_consoleText->scrollUp();
+		return true;
+	}
+	if (click == kBorderScrollDown && event.type == Common::EVENT_LBUTTONDOWN) {
+		_consoleText->scrollDown();
+		return true;
+	}
+
+	return getWindowData(kOutConsoleWindow).visible;
+}
+
+bool MacVenture::Gui::processSelfEvents(WindowClick click, Common::Event &event) {
+	if (_engine->needsClickToContinue())
+		return true;
+
+	if (event.type == Common::EVENT_LBUTTONUP) {
+		_engine->handleObjectSelect(1, kSelfWindow, false, false);
+	}
+	return true;
+}
+
+bool MacVenture::Gui::processExitsEvents(WindowClick click, Common::Event &event) {
+	if (event.type == Common::EVENT_LBUTTONUP) {
+		if (_engine->needsClickToContinue()) {
+			return true;
+		}
+
+		Common::Point position(
+			event.mouse.x - _exitsWindow->getDimensions().left,
+			event.mouse.y - _exitsWindow->getDimensions().top);
+
+		CommandButton button;
+		if (!_exitsData)
+			return false;
+
+		Common::Array<CommandButton>::iterator it = _exitsData->begin();
+		for (; it != _exitsData->end(); ++it) {
+			if (it->isInsideBounds(position)) {
+				it->select();
+				button = *it;
+				_engine->handleObjectSelect(button.getData().refcon, kExitsWindow, false, false);
+				return true;
+			} else {
+				it->unselect();
+			}
+		}
+
+	}
+	return getWindowData(kExitsWindow).visible;
+}
+
+bool MacVenture::Gui::processDiplomaEvents(WindowClick click, Common::Event &event) {
+	if (_engine->needsClickToContinue())
+		return true;
+
+	return getWindowData(kDiplomaWindow).visible;
+}
+
+bool Gui::processInventoryEvents(WindowClick click, Common::Event &event) {
+	if (event.type == Common::EVENT_LBUTTONDOWN && click == kBorderCloseButton) {
+		WindowReference ref = findWindowAtPoint(event.mouse);
+		if (ref == kNoWindow) {
+			return false;
+		}
+
+		if (click == kBorderCloseButton) {
+			removeInventoryWindow(ref);
+			return true;
+		}
+	}
+
+	if (_engine->needsClickToContinue())
+		return true;
+
+	if (event.type == Common::EVENT_LBUTTONDOWN) {
+		// Find the appropriate window
+		WindowReference ref = findWindowAtPoint(event.mouse);
+		if (ref == kNoWindow) {
+			return false;
+		}
+
+		WindowData &data = findWindowData((WindowReference) ref);
+
+		if (click == kBorderScrollUp) {
+			data.scrollPos.y = MAX(0, data.scrollPos.y - kScrollAmount);
+		}
+		if (click == kBorderScrollDown) {
+			data.scrollPos.y += kScrollAmount;
+		}
+		if (click == kBorderScrollLeft) {
+			data.scrollPos.x = MAX(0, data.scrollPos.x - kScrollAmount);
+		}
+		if (click == kBorderScrollRight) {
+			data.scrollPos.x += kScrollAmount;
+		}
+	}
+	return true;
+}
+
+void Gui::selectForDrag(Common::Point cursorPosition) {
+	WindowReference ref = findWindowAtPoint(cursorPosition);
+	if (ref == kNoWindow) {
+		return;
+	}
+
+	Graphics::MacWindow *win = findWindow(ref);
+	WindowData &data = findWindowData((WindowReference) ref);
+
+	Common::Rect clickRect = calculateClickRect(cursorPosition + data.scrollPos, win->getDimensions());
+	checkSelect(data, cursorPosition, clickRect, (WindowReference)ref);
+}
+
+void Gui::handleSingleClick() {
+	debugC(2, kMVDebugGUI, "Registered Single Click");
+	// HACK THERE HAS TO BE A MORE ELEGANT WAY
+	if (_dialog) {
+		return;
+	}
+	handleDragRelease(false, false);
+}
+
+void Gui::handleDoubleClick() {
+	debugC(2, kMVDebugGUI, "Registered Double Click");
+	if (_dialog) {
+		return;
+	}
+	handleDragRelease(false, true);
+}
+
+void Gui::ensureAssetLoaded(ObjID obj) {
+	if (!_assets.contains(obj)) {
+		_assets[obj] = new ImageAsset(obj, _graphics);
+	}
+}
+
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/gui.h b/engines/macventure/gui.h
new file mode 100644
index 0000000000..8ae4a1534d
--- /dev/null
+++ b/engines/macventure/gui.h
@@ -0,0 +1,369 @@
+/* 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 MACVENTURE_GUI_H
+#define MACVENTURE_GUI_H
+
+#include "graphics/macgui/macwindowmanager.h"
+#include "graphics/macgui/macwindow.h"
+#include "graphics/macgui/macmenu.h"
+
+#include "graphics/font.h"
+
+#include "common/timer.h"
+
+#include "macventure/macventure.h"
+#include "macventure/container.h"
+#include "macventure/image.h"
+#include "macventure/prebuilt_dialogs.h"
+#include "macventure/dialog.h"
+#include "macventure/controls.h"
+#include "macventure/windows.h"
+
+namespace MacVenture {
+
+using namespace Graphics::MacGUIConstants;
+using namespace Graphics::MacWindowConstants;
+class MacVentureEngine;
+typedef uint32 ObjID;
+
+class Cursor;
+class ConsoleText;
+class CommandButton;
+class ImageAsset;
+class Dialog;
+
+BorderBounds borderBounds(MVWindowType type);
+
+enum MenuAction {
+	kMenuActionAbout,
+	kMenuActionNew,
+	kMenuActionOpen,
+	kMenuActionSave,
+	kMenuActionSaveAs,
+	kMenuActionQuit,
+	kMenuActionUndo,
+	kMenuActionCut,
+	kMenuActionCopy,
+	kMenuActionPaste,
+	kMenuActionClear,
+	kMenuActionCleanUp,
+	kMenuActionMessUp,
+
+	kMenuActionCommand
+};
+
+struct DraggedObj {
+	ObjID id;
+	Common::Point pos;
+	Common::Point mouseOffset;
+	Common::Point startPos;
+	WindowReference startWin;
+	bool hasMoved;
+};
+
+class Gui {
+
+public:
+	Gui(MacVentureEngine *engine, Common::MacResManager *resman);
+	~Gui();
+
+	void reloadInternals();
+
+	void draw();
+	void drawMenu();
+	void drawTitle();
+
+	void clearControls();
+	bool processEvent(Common::Event &event);
+	void handleMenuAction(MenuAction action);
+	void updateWindow(WindowReference winID, bool containerOpen);
+	void invertWindowColors(WindowReference winID);
+
+	WindowReference createInventoryWindow(ObjID objRef);
+	bool tryCloseWindow(WindowReference winID);
+
+	Common::Point getObjMeasures(ObjID obj);
+
+	WindowReference getObjWindow(ObjID objID);
+	WindowReference findObjWindow(ObjID objID);
+
+	// Event processors
+	bool processCommandEvents(WindowClick click, Common::Event &event);
+	bool processMainGameEvents(WindowClick click, Common::Event &event);
+	bool processOutConsoleEvents(WindowClick click, Common::Event &event);
+	bool processSelfEvents(WindowClick click, Common::Event &event);
+	bool processExitsEvents(WindowClick click, Common::Event &event);
+	bool processDiplomaEvents(WindowClick click, Common::Event &event);
+	bool processInventoryEvents(WindowClick click, Common::Event &event);
+
+	const WindowData& getWindowData(WindowReference reference);
+
+	const Graphics::Font& getCurrentFont();
+
+	// Clicks
+	void selectForDrag(Common::Point cursorPosition);
+	void handleSingleClick();
+	void handleDoubleClick();
+
+	// Modifiers
+	void bringToFront(WindowReference window);
+	void setWindowTitle(WindowReference winID, Common::String string);
+	void updateWindowInfo(WindowReference ref, ObjID objID, const Common::Array<ObjID> &children);
+	void ensureInventoryOpen(WindowReference reference, ObjID id);
+
+	void addChild(WindowReference target, ObjID child);
+	void removeChild(WindowReference target, ObjID child);
+
+	void clearExits();
+	void unselectExits();
+	void updateExit(ObjID id);
+
+	void printText(const Common::String &text);
+
+	//Dialog interactions
+	void showPrebuiltDialog(PrebuiltDialogs type);
+	bool isDialogOpen();
+
+	void getTextFromUser();
+	void setTextInput(Common::String str);
+	void closeDialog();
+
+	void loadGame();
+	void saveGame();
+	void newGame();
+	void quitGame();
+
+	void createInnerSurface(Graphics::ManagedSurface *innerSurface, Graphics::ManagedSurface *outerSurface, const BorderBounds &borders);
+
+
+private: // Attributes
+
+	MacVentureEngine *_engine;
+	Common::MacResManager *_resourceManager;
+
+	Graphics::ManagedSurface _screen;
+	Graphics::MacWindowManager _wm;
+
+	Common::List<WindowData> *_windowData;
+	Common::Array<CommandButton> *_controlData;
+	Common::Array<CommandButton> *_exitsData;
+
+	Graphics::MacWindow *_controlsWindow;
+	Graphics::MacWindow *_mainGameWindow;
+	Graphics::MacWindow *_outConsoleWindow;
+	Graphics::MacWindow *_selfWindow;
+	Graphics::MacWindow *_exitsWindow;
+	Graphics::MacWindow *_diplomaWindow;
+	Common::Array<Graphics::MacWindow*> _inventoryWindows;
+	Graphics::Menu *_menu;
+	Dialog *_dialog;
+
+	Container *_graphics;
+	Common::HashMap<ObjID, ImageAsset*> _assets;
+
+	Graphics::ManagedSurface _draggedSurface;
+	DraggedObj _draggedObj;
+
+	Cursor *_cursor;
+
+	ConsoleText *_consoleText;
+
+private: // Methods
+
+	// Initializers
+	void initGUI();
+	void initWindows();
+	void assignObjReferences(); // Mainly guesswork
+
+	// Loaders
+	bool loadMenus();
+	bool loadWindows();
+	bool loadControls();
+	void loadBorders(Graphics::MacWindow *target, MVWindowType type);
+	void loadBorder(Graphics::MacWindow *target, MVWindowType type, bool active);
+	void loadGraphics();
+	void clearAssets();
+
+	// Drawers
+	void drawWindows();
+	void drawCommandsWindow();
+	void drawMainGameWindow();
+	void drawSelfWindow();
+	void drawInventories();
+	void drawExitsWindow();
+	void drawConsoleWindow();
+
+	void drawDraggedObject();
+	void drawObjectsInWindow(const WindowData &targetData, Graphics::ManagedSurface *surface);
+	void drawWindowTitle(WindowReference target, Graphics::ManagedSurface *surface);
+	void drawDialog();
+
+	void moveDraggedObject(Common::Point target);
+
+	// Finders
+	WindowReference findWindowAtPoint(Common::Point point);
+	Common::Point getGlobalScrolledSurfacePosition(WindowReference reference);
+	WindowData& findWindowData(WindowReference reference);
+	Graphics::MacWindow *findWindow(WindowReference reference);
+
+	// Utils
+	void checkSelect(const WindowData &data, Common::Point pos, const Common::Rect &clickRect, WindowReference ref);
+	bool canBeSelected(ObjID obj, const Common::Rect &clickRect, WindowReference ref);
+	bool isRectInsideObject(Common::Rect target, ObjID obj);
+	void selectDraggable(ObjID child, WindowReference origin, Common::Point startPos);
+	void handleDragRelease(bool shiftPressed, bool isDoubleClick);
+	Common::Rect calculateClickRect(Common::Point clickPos, Common::Rect windowBounds);
+	Common::Point localizeTravelledDistance(Common::Point point, WindowReference origin, WindowReference target);
+	void removeInventoryWindow(WindowReference ref);
+
+	void ensureAssetLoaded(ObjID obj);
+
+};
+
+enum ClickState {
+	kCursorIdle = 0,
+	kCursorSCStart = 1,
+	kCursorSCDrag = 2,
+	kCursorDCStart = 3,
+	kCursorDCDo = 4,
+	kCursorSCSink = 5,
+	kCursorStateCount
+};
+
+enum CursorInput { // Columns for the FSM transition table
+	kButtonDownCol = 0,
+	kButtonUpCol = 1,
+	kTickCol = 2,
+	kCursorInputCount
+};
+
+class Cursor {
+
+public:
+	Cursor(Gui *gui);
+	~Cursor();
+
+	void tick();
+	bool processEvent(const Common::Event &event);
+	Common::Point getPos();
+	bool canSelectDraggable();
+
+private:
+
+	void changeState(CursorInput input);
+	void executeStateIn();
+	void executeStateOut();
+
+
+private:
+	Gui *_gui;
+
+	Common::Point _pos;
+	ClickState _state;
+};
+
+
+
+enum {
+	kConsoleLeftOffset = 2
+};
+
+class ConsoleText {
+
+public:
+
+	ConsoleText(Gui *gui) {
+		_gui = gui;
+		_lines.push_back("");
+		updateScroll();
+	}
+
+	~ConsoleText() {
+
+	}
+
+	void printLine(const Common::String &str, int maxW) {
+		Common::StringArray wrappedLines;
+		int textW = maxW;
+		const Graphics::Font *font = &_gui->getCurrentFont();
+
+		font->wordWrapText(str, textW, wrappedLines);
+
+		if (wrappedLines.empty()) // Sometimes we have empty lines
+			_lines.push_back("");
+
+		for (Common::StringArray::const_iterator j = wrappedLines.begin(); j != wrappedLines.end(); ++j) {
+			_lines.push_back(*j);
+		}
+
+		updateScroll();
+	}
+
+	void renderInto(Graphics::ManagedSurface *target, const BorderBounds borders, int textOffset) {
+		target->fillRect(target->getBounds(), kColorWhite);
+
+		Graphics::ManagedSurface *composeSurface = new Graphics::ManagedSurface();
+		_gui->createInnerSurface(composeSurface, target, borders);
+		composeSurface->clear(kColorGreen);
+
+		const Graphics::Font *font = &_gui->getCurrentFont();
+		uint y = target->h - font->getFontHeight();
+		for (uint i = _scrollPos; i != 0; i--) {
+			font->drawString(target, _lines[i], textOffset, y, font->getStringWidth(_lines[i]), kColorBlack);
+			y -= font->getFontHeight();
+		}
+
+		Common::Point composePosition = Common::Point(borders.leftOffset, borders.topOffset);
+		target->transBlitFrom(*composeSurface, composePosition, kColorGreen);
+		delete composeSurface;
+	}
+
+	void updateScroll() {
+		_scrollPos = _lines.size() - 1;
+	}
+
+	void scrollDown() {
+		if (_scrollPos < (int)(_lines.size() - 1)) {
+			_scrollPos++;
+		}
+	}
+
+	void scrollUp() {
+		if (_scrollPos > 0) {
+			_scrollPos--;
+		}
+	}
+
+
+private:
+
+	Gui *_gui;
+
+	Common::StringArray _lines;
+	int _scrollPos;
+
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/hufflists.h b/engines/macventure/hufflists.h
new file mode 100644
index 0000000000..1ea4f21535
--- /dev/null
+++ b/engines/macventure/hufflists.h
@@ -0,0 +1,57 @@
+/* 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 MACVENTURE_HUFFLIST_H
+#define MACVENTURE_HUFFLIST_H
+
+namespace MacVenture {
+	
+// The engine uses a <= comparison instead of ==, so I can't use Common::Huffman
+class HuffmanLists {
+public:	
+	HuffmanLists() {
+		_numEntries = 0;
+	}
+	HuffmanLists(uint32 num, uint32 *lens, uint32 *masks, uint32 *symbols) {
+		_numEntries = num;
+		_lens = Common::Array<uint32>(lens, num);
+		_masks = Common::Array<uint32>(masks, num);
+		_symbols = Common::Array<uint32>(symbols, num);
+	}
+	~HuffmanLists() {}
+		
+
+	uint32 getNumEntries() const { return _numEntries; }
+	uint32 getLength(uint32 index) const { return _lens[index]; }
+	uint32 getMask(uint32 index) const { return _masks[index]; }
+	uint32 getSymbol(uint32 index) const { return _symbols[index]; }
+
+private: 
+	uint32 _numEntries;
+	Common::Array<uint32> _lens;
+	Common::Array<uint32> _masks;
+	Common::Array<uint32> _symbols;
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/image.cpp b/engines/macventure/image.cpp
new file mode 100644
index 0000000000..172121af0b
--- /dev/null
+++ b/engines/macventure/image.cpp
@@ -0,0 +1,553 @@
+/* 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 "macventure/image.h"
+
+namespace MacVenture {
+
+static const PPICHuff PPIC1Huff = {
+	// Masks
+	{ 0x0000,0x2000,0x4000,0x5000,0x6000,0x7000,0x8000,0x9000,0xa000,
+	0xb000,0xc000,0xd000,0xd800,0xe000,0xe800,0xf000,0xf800 },
+	// Lens
+	{ 3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5 },
+	// Symbols
+	{ 0x00,0x0f,0x03,0x05,0x06,0x07,0x08,0x09,0x0a,0x0c,0xff,0x01,
+	0x02,0x04,0x0b,0x0d,0xe }
+};
+
+static const PPICHuff PPIC2Huff = {
+	// Masks
+	{ 0x0000,0x4000,0x8000,0xc000,0xc800,0xd000,0xd800,0xe000,0xe800,
+	0xf000,0xf400,0xf600,0xf800,0xfa00,0xfc00,0xfe00,0xff00 },
+	// Lens
+	{ 2,2,2,5,5,5,5,5,5,6,7,7,7,7,7,8,8 },
+	// Symbols
+	{ 0xff,0x00,0x0f,0x01,0x03,0x07,0x0e,0x0c,0x08,0x06,0x02,0x04,
+	0x09,0x0d,0x0b,0x0a,0x05 }
+};
+
+// Used to load the huffman table in PPIC3 decoding
+static const byte loadBits[] = {
+	0x08, 0x0f, 0x02, 0xff, 0x00,
+	0x04, 0xff, 0x01,
+	0x07, 0x09, 0x08, 0xff, 0x03,
+	0x04, 0xff, 0x04,
+	0x0a, 0x07, 0x0a, 0x0b, 0x06, 0xff, 0x05,
+	0x06, 0x06, 0x0b, 0xff, 0x07,
+	0x03, 0xff, 0x09,
+	0x04, 0x03, 0x0e, 0xff, 0x0c,
+	0x02, 0xff, 0x0d,
+	0x01, 0xff, 0x0f,
+	0xff
+};
+
+ImageAsset::ImageAsset(ObjID original, Container *container) {
+	_id = (original * 2);
+	_mask = (original * 2) + 1;
+
+	uint imgRowBytes = 0;
+	uint imgBitWidth = 0;
+	uint imgBitHeight = 0;
+	uint maskRowBytes = 0;
+	uint maskBitWidth = 0;
+	uint maskBitHeight = 0;
+
+	_container = container;
+	decodePPIC(_id, _imgData, imgBitHeight, imgBitWidth, imgRowBytes);
+	_imgRowBytes = imgRowBytes;
+	_imgBitWidth = imgBitWidth;
+	_imgBitHeight = imgBitHeight;
+
+	if (_container->getItemByteSize(_mask)) {
+		decodePPIC(_mask, _maskData, maskBitHeight, maskBitWidth, maskRowBytes);
+	}
+	_maskRowBytes = maskRowBytes;
+	_maskBitWidth = maskBitWidth;
+	_maskBitHeight = maskBitHeight;
+}
+
+ImageAsset::~ImageAsset() {
+	debugC(3, kMVDebugImage, "~ImageAsset(%d)", _id / 2);
+}
+
+void ImageAsset::decodePPIC(ObjID id, Common::Array<byte> &data, uint &bitHeight, uint &bitWidth, uint &rowBytes) {
+	ObjID realID = id;
+	uint32 size = _container->getItemByteSize(id);
+	if (size < 2) {
+		rowBytes = 0;
+		bitHeight = 0;
+		bitWidth = 0;
+		return;
+	}
+	if (size == 2) {
+		Common::SeekableReadStream *newItemStream = _container->getItem(id);
+		realID = newItemStream->readUint16BE();
+		delete newItemStream;
+	}
+	Common::SeekableReadStream *baseStream = _container->getItem(realID);
+	Common::BitStream32BEMSB stream(baseStream);
+
+	uint8 mode = stream.getBits(3);
+	int w, h;
+	if (stream.getBit()) {
+		h = stream.getBits(10);
+	} else {
+		h = stream.getBits(6);
+	}
+
+	if (stream.getBit()) {
+		w = stream.getBits(10);
+	} else {
+		w = stream.getBits(6);
+	}
+
+	rowBytes = ((w + 0xF) >> 3) & 0xFFFE;
+	bitWidth = w;
+	bitHeight = h;
+
+	for (uint i = 0; i < rowBytes * h; i++) {
+		data.push_back(0);
+	}
+
+	switch (mode) {
+	case MacVenture::kPPIC0:
+		decodePPIC0(stream, data, bitHeight, bitWidth, rowBytes);
+		break;
+	case MacVenture::kPPIC1:
+		decodePPIC1(stream, data, bitHeight, bitWidth, rowBytes);
+		break;
+	case MacVenture::kPPIC2:
+		decodePPIC2(stream, data, bitHeight, bitWidth, rowBytes);
+		break;
+	case MacVenture::kPPIC3:
+		decodePPIC3(stream, data, bitHeight, bitWidth, rowBytes);
+		break;
+	}
+
+	delete baseStream;
+}
+
+void ImageAsset::decodePPIC0(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	uint words = bitWidth >> 4;
+	uint bytes = bitWidth & 0xF;
+	uint v = 0;
+	uint p = 0;
+	for (uint y = 0; y < bitHeight; y++) {
+		for (uint x = 0; x < words; x++) {
+			v = stream.peekBits(32);
+			stream.skip(16);
+			v >>= 16 - (stream.pos() % 8);
+			data[p] = (v >> 8) & 0xff; p++;
+			data[p] = v & 0xff; p++;
+		}
+		if (bytes) {
+			v = stream.getBits(bytes);
+			v <<= 16 - bytes;
+			data[p] = (v >> 8) & 0xff; p++;
+			data[p] = v & 0xff; p++;
+		}
+	}
+
+}
+
+void ImageAsset::decodePPIC1(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	decodeHuffGraphic(PPIC1Huff, stream, data, bitHeight, bitWidth, rowBytes);
+}
+
+void ImageAsset::decodePPIC2(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	decodeHuffGraphic(PPIC2Huff, stream, data, bitHeight, bitWidth, rowBytes);
+}
+
+void ImageAsset::decodePPIC3(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	// We need to load the huffman from the PPIC itself
+	PPICHuff huff;
+	uint16 v, bits;
+	uint16 load = 0;
+	while ((bits = loadBits[load++]) != 0xFF) {
+		v = stream.getBits(bits);
+		while ((bits = loadBits[load++]) != 0xFF) {
+			huff.symbols[loadBits[load++]] = v % bits;
+			v = (bits != 0) ? (v / bits) : 0;
+		}
+		huff.symbols[loadBits[load++]] = v;
+	}
+	huff.symbols[0x10] = 0;
+	for (uint i = 0x10; i > 0; i--) {
+		for (uint j = i; j <= 0x10; j++) {
+			if (huff.symbols[j] >= huff.symbols[i - 1]) {
+				huff.symbols[j]++;
+			}
+		}
+	}
+
+	for (int i = 0x10; i >= 0; i--) {
+		if (huff.symbols[i] == 0x10) {
+			huff.symbols[i] = 0xff;
+			break;
+		}
+	}
+
+	bits = stream.getBits(2) + 1;
+	uint16 mask = 0;
+	for (uint i = 0; i < 0xf; i++) {
+		if (i) {
+			while (!stream.getBit()) {
+				bits++;
+			}
+		}
+		huff.lens[i] = bits;
+		huff.masks[i] = mask;
+		mask += 1 << (16 - bits);
+	}
+	huff.masks[0xf] = mask;
+	while (mask&(1 << (16 - bits))) {
+		bits++;
+	}
+	huff.masks[0x10] = mask | (1 << (16 - bits));
+	huff.lens[0xf] = bits;
+	huff.lens[0x10] = bits;
+
+	decodeHuffGraphic(huff, stream, data, bitHeight, bitWidth, rowBytes);
+}
+
+void ImageAsset::decodeHuffGraphic(const PPICHuff &huff, Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	byte flags = 0;
+	_walkRepeat = 0;
+	_walkLast = 0;
+	if (bitWidth & 3) {
+		flags = stream.getBits(5);
+	} else {
+		flags = stream.getBits(4) << 1;
+	}
+
+	byte odd = 0;
+	byte blank = bitWidth & 0xf;
+	if (blank) {
+		blank >>= 2;
+		odd = blank & 1;
+		blank = 2 - (blank >> 1);
+	}
+
+	uint16 pos = 0;
+	for (uint y = 0; y < bitHeight; y++) {
+		uint16 x = 0;
+		for (; x < bitWidth >> 3; x++) {
+			byte hi = walkHuff(huff, stream) << 4;
+			data[pos++] = walkHuff(huff, stream) | hi;
+		}
+		if (odd) {
+			data[pos] = walkHuff(huff, stream) << 4;
+		}
+		pos += blank;
+	}
+
+	uint16 edge = bitWidth & 3;
+	if (edge) {
+		pos = rowBytes - blank;
+		uint16 bits = 0;
+		uint16 val = 0;
+		uint16 v;
+		for (uint y = 0; y < bitHeight; y++) {
+			if (flags & 1) {
+				if (bits < edge) {
+					v = walkHuff(huff, stream) << 4;
+					val |= v >> bits;
+					bits += 4;
+				}
+				bits -= edge;
+				v = val;
+				val <<= edge;
+				val &= 0xFF;
+			} else {
+				v = stream.getBits(edge);
+				v <<= 8 - edge;
+			}
+			if (odd)
+				v >>= 4;
+
+			data[pos] |= v & 0xff;
+			pos += rowBytes;
+		}
+	}
+	if (flags & 8) {
+		pos = 0;
+		for (uint y = 0; y < bitHeight; y++) {
+			uint16 v = 0;
+			if (flags & 2) {
+				for (uint x = 0; x < rowBytes; x++) {
+					data[pos] ^= v;
+					v = data[pos];
+					pos++;
+				}
+			} else {
+				for (uint x = 0; x < rowBytes; x++) {
+					uint16 val = data[pos] ^ v;
+					val ^= (val >> 4) & 0xf;
+					data[pos] = val;
+					pos++;
+					v = (val << 4) & 0xff;
+				}
+			}
+		}
+	}
+	if (flags & 4) {
+		uint16 delta = rowBytes * 4;
+		if (flags & 2) {
+			delta *= 2;
+		}
+		pos = 0;
+		uint q = delta;
+		for (uint i = 0; i < bitHeight * rowBytes - delta; i++) {
+			data[q] ^= data[pos];
+			q++;
+			pos++;
+		}
+	}
+}
+
+byte ImageAsset::walkHuff(const PPICHuff &huff, Common::BitStream &stream) {
+	if (_walkRepeat) {
+		_walkRepeat--;
+		_walkLast = ((_walkLast << 8) & 0xFF00) | (_walkLast >> 8);
+		return _walkLast & 0xFF;
+	}
+	uint16 dw = stream.peekBits(16);
+	uint16 i = 0;
+	for (;i < 16; i++) {
+		if (huff.masks[i + 1] > dw) {
+			break;
+		}
+	}
+	stream.skip(huff.lens[i]);
+	uint8 val = huff.symbols[i];
+	if (val == 0xFF) {
+		if (!stream.getBit()) {
+			_walkLast &= 0xFF;
+			_walkLast |= _walkLast << 8;
+		}
+		_walkRepeat = stream.getBits(3);
+		if (_walkRepeat < 3) {
+			_walkRepeat <<= 4;
+			_walkRepeat |= stream.getBits(4);
+			if (_walkRepeat < 8) {
+				_walkRepeat <<= 8;
+				_walkRepeat |= stream.getBits(8);
+			}
+		}
+		_walkRepeat -= 2;
+		_walkLast = ((_walkLast << 8) & 0xFF00) | (_walkLast >> 8);
+		return _walkLast & 0xFF;
+	} else {
+		_walkLast <<= 8;
+		_walkLast |= val;
+		_walkLast &= 0xFFFF;
+	}
+	return val;
+}
+
+void ImageAsset::blitInto(Graphics::ManagedSurface *target, int x, int y, BlitMode mode) {
+	if (mode == kBlitDirect) {
+		blitDirect(target, x, y, _imgData, _imgBitHeight, _imgBitWidth, _imgRowBytes);
+	} else if (mode < kBlitXOR) {
+		if (_container->getItemByteSize(_mask)) { // Has mask
+			switch (mode) {
+			case MacVenture::kBlitBIC:
+				blitBIC(target, x, y, _maskData, _maskBitHeight, _maskBitWidth, _maskRowBytes);
+				break;
+			case MacVenture::kBlitOR:
+				blitOR(target, x, y, _maskData, _maskBitHeight, _maskBitWidth, _maskRowBytes);
+				break;
+			default:
+				break;
+			}
+		} else if (_container->getItemByteSize(_id)) {
+			switch (mode) {
+			case MacVenture::kBlitBIC:
+				target->fillRect(Common::Rect(x, y, x + _imgBitWidth, y + _imgBitHeight), kColorWhite);
+				break;
+			case MacVenture::kBlitOR:
+				target->fillRect(Common::Rect(x, y, x + _imgBitWidth, y + _imgBitHeight), kColorBlack);
+				break;
+			default:
+				break;
+			}
+		}
+
+		if (_container->getItemByteSize(_id) && mode > 0) {
+			blitXOR(target, x, y, _imgData, _imgBitHeight, _imgBitWidth, _imgRowBytes);
+		}
+	}
+}
+
+bool ImageAsset::isPointInside(Common::Point point) {
+	if (point.x >= _maskBitWidth || point.y >= _maskBitHeight) {
+		return false;
+	}
+	if (_maskData.empty()) {
+		return false;
+	}
+	// We see if the point lands on the mask.
+	uint pix = _maskData[(point.y * _maskRowBytes) + (point.x >> 3)] & (1 << (7 - (point.x & 7)));
+	return pix != 0;
+}
+
+bool ImageAsset::isRectInside(Common::Rect rect) {
+	if (_maskData.empty()) {
+		return (rect.width() > 0 && rect.height() > 0);
+	}
+
+	for (int y = rect.top; y < rect.top + rect.height(); y++) {
+		uint bmpofs = y * _maskRowBytes;
+		byte pix;
+		for (int x = rect.left; x < rect.left + rect.width(); x++) {
+			pix = _maskData[bmpofs + (x >> 3)] & (1 << (7 - (x & 7)));
+			if (pix) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+int ImageAsset::getWidth() {
+	if (_imgData.size() == 0) {
+		return 0;
+	}
+	return MAX(0, (int)_imgBitWidth);
+}
+
+int ImageAsset::getHeight() {
+	if (_imgData.size() == 0) {
+		return 0;
+	}
+	return MAX(0, (int)_imgBitHeight);
+}
+
+void ImageAsset::blitDirect(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	uint sx, sy, w, h;
+	calculateSectionToDraw(target, ox, oy, bitWidth, bitHeight, sx, sy, w, h);
+
+	for (uint y = 0; y < h; y++) {
+		uint bmpofs = (y + sy) * rowBytes;
+		byte pix = 0;
+		for (uint x = 0; x < w; x++) {
+			assert(ox + x <= target->w);
+			assert(oy + y <= target->h);
+			pix = data[bmpofs + ((x + sx) >> 3)] & (1 << (7 - ((x + sx) & 7)));
+			pix = pix ? kColorBlack : kColorWhite;
+			*((byte *)target->getBasePtr(ox + x, oy + y)) = pix;
+		}
+	}
+}
+
+void ImageAsset::blitBIC(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	uint sx, sy, w, h;
+	calculateSectionToDraw(target, ox, oy, bitWidth, bitHeight, sx, sy, w, h);
+
+	for (uint y = 0; y < h; y++) {
+		uint bmpofs = (y + sy) * rowBytes;
+		byte pix = 0;
+		for (uint x = 0; x < w; x++) {
+			assert(ox + x <= target->w);
+			assert(oy + y <= target->h);
+			pix = data[bmpofs + ((x + sx) >> 3)] & (1 << (7 - ((x + sx) & 7)));
+			if (pix) {
+				*((byte *)target->getBasePtr(ox + x, oy + y)) = kColorWhite;
+			}
+		}
+	}
+}
+
+void ImageAsset::blitOR(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	uint sx, sy, w, h;
+	calculateSectionToDraw(target, ox, oy, bitWidth, bitHeight, sx, sy, w, h);
+
+	for (uint y = 0; y < h; y++) {
+		uint bmpofs = (y + sy) * rowBytes;
+		byte pix = 0;
+		for (uint x = 0; x < w; x++) {
+			assert(ox + x <= target->w);
+			assert(oy + y <= target->h);
+			pix = data[bmpofs + ((x + sx) >> 3)] & (1 << (7 - ((x + sx) & 7)));
+			if (pix) {
+				*((byte *)target->getBasePtr(ox + x, oy + y)) = kColorBlack;
+			}
+		}
+	}
+}
+
+void ImageAsset::blitXOR(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes) {
+	uint sx, sy, w, h;
+	calculateSectionToDraw(target, ox, oy, bitWidth, bitHeight, sx, sy, w, h);
+
+	for (uint y = 0; y < h; y++) {
+		uint bmpofs = (y + sy) * rowBytes;
+		byte pix = 0;
+		for (uint x = 0; x < w; x++) {
+			pix = data[bmpofs + ((x + sx) >> 3)] & (1 << (7 - ((x + sx) & 7)));
+			if (pix) { // We need to xor
+				assert(ox + x <= target->w);
+				assert(oy + y <= target->h);
+				byte p = *((byte *)target->getBasePtr(ox + x, oy + y));
+				*((byte *)target->getBasePtr(ox + x, oy + y)) =
+					(p == kColorWhite) ? kColorBlack : kColorWhite;
+			}
+		}
+	}
+}
+
+void ImageAsset::calculateSectionToDraw(Graphics::ManagedSurface *target, int &ox, int &oy, uint bitWidth, uint bitHeight, uint &sx, uint &sy, uint &w, uint &h) {
+
+	calculateSectionInDirection(target->w, bitWidth, ox, sx, w);
+	calculateSectionInDirection(target->h, bitHeight, oy, sy, h);
+
+	assert(w <= target->w);
+	assert((int)w >= 0);
+	assert(w <= bitWidth);
+	assert(h <= target->h);
+	assert((int)h >= 0);
+	assert(h <= bitHeight);
+}
+
+void ImageAsset::calculateSectionInDirection(uint targetWhole, uint originWhole, int &originPosition, uint &startPosition, uint &blittedWhole) {
+	startPosition = 0;
+	blittedWhole = originWhole;
+	if (originPosition < 0) {
+		if (ABS(originPosition) > (int)blittedWhole) {
+			blittedWhole = 0;
+		} else {
+			blittedWhole -= -originPosition;
+		}
+		startPosition = -originPosition;
+		originPosition = 0;
+	}
+	if (originPosition + blittedWhole > targetWhole) {
+		if (originPosition > (int)targetWhole) {
+			blittedWhole = 0;
+		} else {
+			blittedWhole = targetWhole - originPosition;
+		}
+	}
+}
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/image.h b/engines/macventure/image.h
new file mode 100644
index 0000000000..6f6b9600ac
--- /dev/null
+++ b/engines/macventure/image.h
@@ -0,0 +1,108 @@
+/* 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 MACVENTURE_IMAGE_H
+#define MACVENTURE_IMAGE_H
+
+#include "macventure/macventure.h"
+#include "macventure/container.h"
+
+namespace MacVenture {
+
+typedef uint32 ObjID;
+class Container;
+
+
+enum BlitMode {
+	kBlitDirect = 0,
+	kBlitBIC = 1,
+	kBlitOR = 2,
+	kBlitXOR = 3
+};
+
+enum GraphicsEncoding {
+	kPPIC0 = 0,
+	kPPIC1 = 1,
+	kPPIC2 = 2,
+	kPPIC3 = 3
+};
+
+struct PPICHuff {
+	uint16 masks[17];
+	uint16 lens[17];
+	uint8 symbols[17];
+};
+
+class ImageAsset {
+public:
+	ImageAsset(ObjID original, Container *container);
+	~ImageAsset();
+
+	void blitInto(Graphics::ManagedSurface *target, int x, int y, BlitMode mode);
+
+	bool isPointInside(Common::Point point);
+	bool isRectInside(Common::Rect rect);
+
+	int getWidth();
+	int getHeight();
+
+private:
+	void decodePPIC(ObjID id, Common::Array<byte> &data, uint &bitHeight, uint &bitWidth, uint &rowBytes);
+
+	void decodePPIC0(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void decodePPIC1(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void decodePPIC2(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void decodePPIC3(Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+
+	void decodeHuffGraphic(const PPICHuff &huff, Common::BitStream &stream, Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	byte walkHuff(const PPICHuff &huff, Common::BitStream &stream);
+
+	void blitDirect(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void blitBIC(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void blitOR(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+	void blitXOR(Graphics::ManagedSurface *target, int ox, int oy, const Common::Array<byte> &data, uint bitHeight, uint bitWidth, uint rowBytes);
+
+	void calculateSectionToDraw(Graphics::ManagedSurface *target, int &ox, int &oy, uint bitWidth, uint bitHeight, uint &sx, uint &sy, uint &w, uint &h);
+	void calculateSectionInDirection(uint targetWhole, uint originWhole, int &originPosition, uint &startPosition, uint &blittedWhole);
+
+private:
+	ObjID _id;
+	ObjID _mask;
+	Container *_container;
+
+	uint16 _walkRepeat;
+	uint16 _walkLast;
+
+	Common::Array<byte> _imgData;
+	uint16 _imgRowBytes;
+	uint16 _imgBitWidth;
+	uint16 _imgBitHeight;
+
+	Common::Array<byte> _maskData;
+	uint16 _maskRowBytes;
+	uint16 _maskBitWidth;
+	uint16 _maskBitHeight;
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/macventure.cpp b/engines/macventure/macventure.cpp
new file mode 100644
index 0000000000..826409f30b
--- /dev/null
+++ b/engines/macventure/macventure.cpp
@@ -0,0 +1,1185 @@
+/* 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/system.h"
+#include "common/debug-channels.h"
+#include "common/debug.h"
+#include "common/error.h"
+#include "common/config-manager.h"
+#include "engines/util.h"
+
+#include "macventure/macventure.h"
+
+// To move
+#include "common/file.h"
+
+namespace MacVenture {
+
+// HACK, see below
+void toASCII(Common::String &str) {
+	debugC(3, kMVDebugMain, "toASCII: %s", str.c_str());
+	Common::String::iterator it = str.begin();
+	for (; it != str.end(); it++) {
+		if (*it == '\216') {
+			str.replace(it, it + 1, "e");
+		}
+		if (*it == '\210') {
+			str.replace(it, it + 1, "a");
+		}
+	}
+}
+
+enum {
+	kMaxMenuTitleLength = 30
+};
+
+MacVentureEngine::MacVentureEngine(OSystem *syst, const ADGameDescription *gameDesc) : Engine(syst) {
+	_gameDescription = gameDesc;
+	_rnd = new Common::RandomSource("macventure");
+
+	initDebugChannels();
+
+	_debugger = NULL;
+	_resourceManager = NULL;
+	_globalSettings = NULL;
+	_gui = NULL;
+	_world = NULL;
+	_scriptEngine = NULL;
+	_filenames = NULL;
+
+	_decodingDirectArticles = NULL;
+	_decodingNamingArticles = NULL;
+	_decodingIndirectArticles = NULL;
+	_textHuffman = NULL;
+
+	_soundManager = NULL;
+
+	_dataBundle = NULL;
+
+	debug("MacVenture::MacVentureEngine()");
+}
+
+MacVentureEngine::~MacVentureEngine() {
+	debug("MacVenture::~MacVentureEngine()");
+
+	DebugMan.clearAllDebugChannels();
+
+	if (_rnd)
+		delete _rnd;
+
+	if (_debugger)
+		delete _debugger;
+
+	if (_resourceManager)
+		delete _resourceManager;
+
+	if (_globalSettings)
+		delete _globalSettings;
+
+	if (_gui)
+		delete _gui;
+
+	if (_world)
+		delete _world;
+
+	if (_scriptEngine)
+		delete _scriptEngine;
+
+	if (_filenames)
+		delete _filenames;
+
+	if (_decodingDirectArticles)
+		delete _decodingDirectArticles;
+
+	if (_decodingNamingArticles)
+		delete _decodingNamingArticles;
+
+	if (_decodingIndirectArticles)
+		delete _decodingIndirectArticles;
+
+	if (_textHuffman)
+		delete _textHuffman;
+
+	if (_soundManager)
+		delete _soundManager;
+
+	if (_dataBundle)
+		delete _dataBundle;
+}
+
+void MacVentureEngine::initDebugChannels() {
+	DebugMan.addDebugChannel(kMVDebugMain, "main", "Engine state");
+	DebugMan.addDebugChannel(kMVDebugGUI, "gui", "Gui");
+	DebugMan.addDebugChannel(kMVDebugText, "text", "Text decoders and printers");
+	DebugMan.addDebugChannel(kMVDebugImage, "image", "Image decoders and renderers");
+	DebugMan.addDebugChannel(kMVDebugScript, "script", "Script engine");
+	DebugMan.addDebugChannel(kMVDebugSound, "sound", "Sound decoders");
+	DebugMan.addDebugChannel(kMVDebugContainer, "container", "Containers");
+}
+
+Common::Error MacVentureEngine::run() {
+	debug("MacVenture::MacVentureEngine::init()");
+	initGraphics(kScreenWidth, kScreenHeight, true);
+
+	_debugger = new Console(this);
+
+	// Additional setup.
+	debug("MacVentureEngine::init");
+
+	_resourceManager = new Common::MacResManager();
+	if (!_resourceManager->open(getGameFileName()))
+		error("ENGINE: Could not open %s as a resource fork", getGameFileName());
+
+	// Engine-wide loading
+	if (!loadGlobalSettings())
+		error("ENGINE: Could not load the engine settings");
+
+	_oldTextEncoding = !loadTextHuffman();
+
+	_filenames = new StringTable(this, _resourceManager, kFilenamesStringTableID);
+	_decodingDirectArticles = new StringTable(this, _resourceManager, kCommonArticlesStringTableID);
+	_decodingNamingArticles = new StringTable(this, _resourceManager, kNamingArticlesStringTableID);
+	_decodingIndirectArticles = new StringTable(this, _resourceManager, kIndirectArticlesStringTableID);
+
+	loadDataBundle();
+
+	// Big class instantiation
+	_gui = new Gui(this, _resourceManager);
+	_world = new World(this, _resourceManager);
+	_scriptEngine = new ScriptEngine(this, _world);
+
+	_soundManager = new SoundManager(this, _mixer);
+
+	setInitialFlags();
+
+	int directSaveSlotLoading = ConfMan.getInt("save_slot");
+	if (directSaveSlotLoading >= 0) {
+		if (loadGameState(directSaveSlotLoading).getCode() != Common::kNoError) {
+			error("ENGINE: Could not load game from slot '%d'", directSaveSlotLoading);
+		}
+	} else {
+		setNewGameState();
+	}
+	selectControl(kStartOrResume);
+
+	_gui->addChild(kSelfWindow, 1);
+	_gui->updateWindow(kSelfWindow, false);
+
+	while (_gameState != kGameStateQuitting) {
+		processEvents();
+
+		if (_gameState != kGameStateQuitting && !_gui->isDialogOpen()) {
+
+			if (_prepared) {
+				_prepared = false;
+
+				if (!_halted)
+					updateState(false);
+
+				if (_cmdReady || _halted) {
+					_halted = false;
+					if (runScriptEngine()) {
+						_halted = true;
+						_paused = true;
+					} else {
+						_paused = false;
+						updateState(true);
+						updateControls();
+						updateExits();
+					}
+				}
+
+				if (_gameState == kGameStateWinnig || _gameState == kGameStateLosing) {
+					endGame();
+				}
+			}
+		}
+		refreshScreen();
+	}
+
+	return Common::kNoError;
+}
+
+void MacVentureEngine::refreshScreen() {
+	_gui->draw();
+	g_system->updateScreen();
+	g_system->delayMillis(50);
+}
+
+void MacVentureEngine::newGame() {
+	_world->startNewGame();
+	reset();
+	setInitialFlags();
+	setNewGameState();
+}
+
+void MacVentureEngine::setInitialFlags() {
+	_paused = false;
+	_halted = false;
+	_cmdReady = false;
+	_haltedAtEnd = false;
+	_haltedInSelection = false;
+	_clickToContinue = true;
+	_gameState = kGameStateInit;
+	_destObject = 0;
+	_prepared = true;
+}
+
+void MacVentureEngine::setNewGameState() {
+	_cmdReady = true;
+	ObjID playerParent = _world->getObjAttr(1, kAttrParentObject);
+	_currentSelection.push_back(playerParent);// Push the parent of the player
+	_world->setObjAttr(playerParent, kAttrContainerOpen, 1);
+}
+
+void MacVentureEngine::reset() {
+	resetInternals();
+	resetGui();
+}
+
+void MacVentureEngine::resetInternals() {
+	_scriptEngine->reset();
+	_currentSelection.clear();
+	_objQueue.clear();
+	_textQueue.clear();
+}
+
+void MacVentureEngine::resetGui() {
+	_gui->reloadInternals();
+	_gui->updateWindowInfo(kMainGameWindow, getParent(1), _world->getChildren(getParent(1), true));
+	// HACK! should update all inventories
+	_gui->ensureInventoryOpen(kInventoryStart, 1);
+	_gui->updateWindowInfo(kInventoryStart, 1, _world->getChildren(1, true));
+	updateControls();
+	updateExits();
+	refreshScreen();
+}
+
+void MacVentureEngine::requestQuit() {
+	// TODO: Display save game dialog and such
+	_gameState = kGameStateQuitting;
+}
+
+void MacVentureEngine::requestUnpause() {
+	_paused = false;
+	_gameState = kGameStatePlaying;
+}
+
+void MacVentureEngine::selectControl(ControlAction id) {
+	debugC(2, kMVDebugMain, "Select control %x", id);
+	if (id == kClickToContinue) {
+		_clickToContinue = false;
+		_paused = true;
+		return;
+	}
+
+	_selectedControl = id;
+	refreshReady();
+}
+
+void MacVentureEngine::refreshReady() {
+	switch (getInvolvedObjects()) {
+	case 0: // No selected object
+		_cmdReady = true;
+		break;
+	case 1: // We have some selected object
+		_cmdReady = _currentSelection.size() != 0;
+		break;
+	case 2:
+		if (_destObject > 0) // We have a destination seleted
+			_cmdReady = true;
+		break;
+	}
+}
+
+void MacVentureEngine::preparedToRun() {
+	_prepared = true;
+}
+
+void MacVentureEngine::gameChanged() {
+	_gameChanged = true;
+}
+
+void MacVentureEngine::winGame() {
+	_gui->showPrebuiltDialog(kWinGameDialog);
+	_gameState = kGameStateWinnig;
+}
+
+void MacVentureEngine::loseGame() {
+	_gui->showPrebuiltDialog(kLoseGameDialog);
+	_paused = true;
+	//_gameState = kGameStateLosing;
+}
+
+void MacVentureEngine::clickToContinue() {
+	_clickToContinue = true;
+}
+
+void MacVentureEngine::enqueueObject(ObjectQueueID type, ObjID objID, ObjID target) {
+	QueuedObject obj;
+	obj.id = type;
+
+	if (type == kUpdateObject && isObjEnqueued(objID)) {
+		return;
+	}
+
+	if (type == kUpdateWindow) {
+		obj.target = target;
+	}
+
+	if (type != kHightlightExits) {
+		obj.object = objID;
+		obj.parent = _world->getObjAttr(objID, kAttrParentObject);
+		obj.x = _world->getObjAttr(objID, kAttrPosX);
+		obj.y = _world->getObjAttr(objID, kAttrPosY);
+		obj.exitx = _world->getObjAttr(objID, kAttrExitX);
+		obj.exity = _world->getObjAttr(objID, kAttrExitY);
+		obj.hidden = _world->getObjAttr(objID, kAttrHiddenExit);
+		obj.offscreen = _world->getObjAttr(objID, kAttrInvisible);
+		obj.invisible = _world->getObjAttr(objID, kAttrUnclickable);
+	}
+	_objQueue.push_back(obj);
+}
+
+void MacVentureEngine::enqueueText(TextQueueID type, ObjID target, ObjID source, ObjID text) {
+	QueuedText newText;
+	newText.id = type;
+	newText.destination = target;
+	newText.source = source;
+	newText.asset = text;
+	_textQueue.push_back(newText);
+}
+
+void MacVentureEngine::enqueueSound(SoundQueueID type, ObjID target) {
+	QueuedSound newSound;
+	newSound.id = type;
+	newSound.reference = target;
+	_soundQueue.push_back(newSound);
+}
+
+void MacVentureEngine::handleObjectSelect(ObjID objID, WindowReference win, bool shiftPressed, bool isDoubleClick) {
+	if (win == kExitsWindow) {
+		win = kMainGameWindow;
+	}
+
+	const WindowData &windata = _gui->getWindowData(win);
+
+	if (shiftPressed) {
+		// TODO: Implement shift functionality.
+	} else {
+		if (_selectedControl && _currentSelection.size() > 0 && getInvolvedObjects() > 1) {
+			if (objID == 0) {
+				selectPrimaryObject(windata.objRef);
+			} else {
+				selectPrimaryObject(objID);
+			}
+			preparedToRun();
+		} else {
+			if (objID == 0) {
+				unselectAll();
+				objID = win;
+			}
+			if (objID > 0) {
+				int currentObjectIndex = findObjectInArray(objID, _currentSelection);
+
+				if (currentObjectIndex >= 0)
+					unselectAll();
+
+				if (isDoubleClick) {
+					selectObject(objID);
+					_destObject = objID;
+					setDeltaPoint(Common::Point(0, 0));
+					if (!_cmdReady) {
+						selectControl(kActivateObject);
+						_cmdReady = true;
+					}
+				} else {
+					selectObject(objID);
+					if (getInvolvedObjects() == 1)
+						_cmdReady = true;
+				}
+				preparedToRun();
+			}
+		}
+	}
+}
+
+void MacVentureEngine::handleObjectDrop(ObjID objID, Common::Point delta, ObjID newParent) {
+	_destObject = newParent;
+	setDeltaPoint(delta);
+	selectControl(kMoveObject);
+	refreshReady();
+	preparedToRun();
+}
+
+void MacVentureEngine::setDeltaPoint(Common::Point newPos) {
+	debugC(4, kMVDebugMain, "Update delta: Old(%d, %d), New(%d, %d)",
+		_deltaPoint.x, _deltaPoint.y,
+		newPos.x, newPos.y);
+	_deltaPoint = newPos;
+}
+
+void MacVentureEngine::focusObjWin(ObjID objID) {
+	_gui->bringToFront(getObjWindow(objID));
+}
+
+void MacVentureEngine::updateWindow(WindowReference winID) {
+	_gui->updateWindow(winID, true);
+}
+
+bool MacVentureEngine::showTextEntry(ObjID text, ObjID srcObj, ObjID destObj) {
+	debugC(3, kMVDebugMain, "Showing speech dialog, asset %d from %d to %d", text, srcObj, destObj);
+	_gui->getTextFromUser();
+
+	_prepared = false;
+	warning("Show text entry: not fully tested");
+	return true;
+}
+
+void MacVentureEngine::setTextInput(Common::String content) {
+	_prepared = true;
+	_userInput = content;
+	_clickToContinue = false;
+}
+
+Common::String MacVentureEngine::getUserInput() {
+	return _userInput;
+}
+
+
+Common::String MacVentureEngine::getStartGameFileName() {
+	Common::SeekableReadStream *res;
+	res = _resourceManager->getResource(MKTAG('S', 'T', 'R', ' '), kStartGameFilenameID);
+	if (!res)
+		return "";
+
+	byte length = res->readByte();
+	char *fileName = new char[length + 1];
+	res->read(fileName, length);
+	fileName[length] = '\0';
+	Common::String result = Common::String(fileName, length);
+	// HACK, see definition of toASCII
+	toASCII(result);
+
+	delete[] fileName;
+	delete res;
+
+	return result;
+}
+
+const GlobalSettings& MacVentureEngine::getGlobalSettings() const {
+	return *_globalSettings;
+}
+
+// Private engine methods
+void MacVentureEngine::processEvents() {
+	Common::Event event;
+
+	while (_eventMan->pollEvent(event)) {
+		if (_gui->processEvent(event))
+			continue;
+
+		switch (event.type) {
+		case Common::EVENT_QUIT:
+			_gameState = kGameStateQuitting;
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+bool MacVenture::MacVentureEngine::runScriptEngine() {
+	debugC(3, kMVDebugMain, "Running script engine");
+	if (_haltedAtEnd) {
+		_haltedAtEnd = false;
+		if (_scriptEngine->resume(false)) {
+			_haltedAtEnd = true;
+			return true;
+		}
+		return false;
+	}
+
+	if (_haltedInSelection) {
+		_haltedInSelection = false;
+		if (_scriptEngine->resume(false)) {
+			_haltedInSelection = true;
+			return true;
+		}
+		updateState(true);
+	}
+
+	while (!_currentSelection.empty()) {
+		ObjID obj = _currentSelection.front();
+		_currentSelection.remove_at(0);
+		if (isGameRunning() && _world->isObjActive(obj)) {
+			if (_scriptEngine->runControl(_selectedControl, obj, _destObject, _deltaPoint)) {
+				_haltedInSelection = true;
+				return true;
+			}
+			updateState(true);
+		}
+	}
+	if (_selectedControl == 1) {
+		_gameChanged = false;
+	} else if (isGameRunning()) {
+		if (_scriptEngine->runControl(kTick, _selectedControl, _destObject, _deltaPoint)) {
+			_haltedAtEnd = true;
+			return true;
+		}
+	}
+	return false;
+}
+
+void MacVentureEngine::endGame() {
+	requestQuit();
+}
+
+void MacVentureEngine::updateState(bool pause) {
+	_prepared = false;
+	runObjQueue();
+	printTexts();
+	playSounds(pause);
+}
+
+void MacVentureEngine::revert() {
+	_gui->invertWindowColors(kMainGameWindow);
+	preparedToRun();
+}
+
+void MacVentureEngine::runObjQueue() {
+	while (!_objQueue.empty()) {
+		uint32 biggest = 0;
+		uint32 index = 0;
+		uint32 temp;
+		for (uint i = 0; i < _objQueue.size(); i++) {
+			temp = _objQueue[i].id;
+			if (temp > biggest) {
+				biggest = temp;
+				index = i;
+			}
+		}
+		QueuedObject obj = _objQueue[index];
+		_objQueue.remove_at(index);
+		switch (obj.id) {
+		case 0x2:
+			focusObjectWindow(obj.object);
+			break;
+		case 0x3:
+			openObject(obj.object);
+			break;
+		case 0x4:
+			closeObject(obj.object);
+			break;
+		case 0x7:
+			checkObject(obj);
+			break;
+		case 0x8:
+			reflectSwap(obj.object, obj.target);
+			break;
+		case 0xc:
+			_world->setObjAttr(_gui->getWindowData(kMainGameWindow).refcon, kAttrContainerOpen, 0);
+			_world->setObjAttr(_world->getObjAttr(1, kAttrParentObject), kAttrContainerOpen, 1);
+			break;
+		case 0xd:
+			toggleExits();
+			break;
+		case 0xe:
+			zoomObject(obj.object);
+			break;
+		}
+	}
+}
+
+void MacVentureEngine::printTexts() {
+	for (uint i = 0; i < _textQueue.size(); i++) {
+		QueuedText text = _textQueue.front();
+		_textQueue.remove_at(0);
+		switch (text.id) {
+		case kTextNumber:
+			_gui->printText(Common::String(text.asset));
+			gameChanged();
+			break;
+		case kTextNewLine:
+			_gui->printText(Common::String(""));
+			gameChanged();
+			break;
+		case kTextPlain:
+			_gui->printText(_world->getText(text.asset, text.source, text.destination));
+			gameChanged();
+			break;
+		}
+	}
+}
+
+void MacVentureEngine::playSounds(bool pause) {
+	int delay = 0;
+	while (!_soundQueue.empty()) {
+		QueuedSound item = _soundQueue.front();
+		_soundQueue.remove_at(0);
+		switch (item.id) {
+		case kSoundPlay:
+			_soundManager->playSound(item.reference);
+			break;
+		case kSoundPlayAndWait:
+			delay = _soundManager->playSound(item.reference);
+			break;
+		case kSoundWait:
+			// Empty in the original.
+			break;
+		}
+	}
+	if (pause && delay > 0) {
+		warning("Sound pausing not yet tested. Pausing for %d", delay);
+		g_system->delayMillis(delay);
+		preparedToRun();
+	}
+}
+
+void MacVentureEngine::updateControls() {
+	selectControl(kNoCommand);
+	_gui->clearControls();
+	toggleExits();
+	resetVars();
+}
+
+void MacVentureEngine::resetVars() {
+	selectControl(kNoCommand);
+	_currentSelection.clear();
+	_destObject = 0;
+	setDeltaPoint(Common::Point(0, 0));
+	_cmdReady = false;
+}
+
+void MacVentureEngine::unselectAll() {
+	while (!_currentSelection.empty()) {
+		unselectObject(_currentSelection.front());
+	}
+}
+
+void MacVentureEngine::selectObject(ObjID objID) {
+	if (!_currentSelection.empty()) {
+		if (findParentWindow(objID) != findParentWindow(_currentSelection[0])) {
+			// TODO: Needs further testing, but it doesn't seem necessary.
+			//unselectAll();
+		}
+	}
+	if (findObjectInArray(objID, _currentSelection) == -1) {
+		_currentSelection.push_back(objID);
+		highlightExit(objID);
+	}
+}
+
+void MacVentureEngine::unselectObject(ObjID objID) {
+	int idxCur = findObjectInArray(objID, _currentSelection);
+	if (idxCur != -1) {
+		_currentSelection.remove_at(idxCur);
+		highlightExit(objID);
+	}
+}
+
+
+void MacVentureEngine::updateExits() {
+	_gui->clearExits();
+	_gui->unselectExits();
+
+	Common::Array<ObjID> exits = _world->getChildren(_world->getObjAttr(1, kAttrParentObject), true);
+	for (uint i = 0; i < exits.size(); i++)
+		_gui->updateExit(exits[i]);
+
+}
+
+int MacVentureEngine::findObjectInArray(ObjID objID, const Common::Array<ObjID> &list) {
+	// Find the object in the current selection
+	bool found = false;
+	uint i = 0;
+	while (i < list.size() && !found) {
+		if (list[i] == objID) {
+			found = true;
+		} else {
+			i++;
+		}
+	}
+	// HACK, should use iterator
+	return found ? i : -1;
+}
+
+uint MacVentureEngine::getPrefixNdx(ObjID obj) {
+	return _world->getObjAttr(obj, kAttrPrefixes);
+}
+
+Common::String MacVentureEngine::getPrefixString(uint flag, ObjID obj) {
+	uint ndx = getPrefixNdx(obj);
+	ndx = ((ndx) >> flag) & 3;
+	return _decodingNamingArticles->getString(ndx);
+}
+
+Common::String MacVentureEngine::getNoun(ObjID ndx) {
+	return _decodingIndirectArticles->getString(ndx);
+}
+
+void MacVentureEngine::highlightExit(ObjID objID) {
+	// TODO: It seems unnecessary since the GUI checks whether an object
+	//		is selected, which includes exits.
+	warning("STUB: highlightExit");
+}
+
+void MacVentureEngine::selectPrimaryObject(ObjID objID) {
+	if (objID == _destObject) {
+		return;
+	}
+	int idx;
+	debugC(4, kMVDebugMain, "Select primary object (%d)", objID);
+	if (_destObject > 0 &&
+		(idx = findObjectInArray(_destObject, _currentSelection)) != -1) {
+		unselectAll();
+	}
+	_destObject = objID;
+	if (findObjectInArray(_destObject, _currentSelection) == -1) {
+		selectObject(_destObject);
+	}
+
+	_cmdReady = true;
+}
+
+void MacVentureEngine::focusObjectWindow(ObjID objID) {
+	if (objID) {
+		WindowReference win = getObjWindow(objID);
+		if (win)
+			_gui->bringToFront(win);
+	}
+}
+
+void MacVentureEngine::openObject(ObjID objID) {
+	debugC(3, kMVDebugMain, "Open Object[%d] parent[%d] x[%d] y[%d]",
+		objID,
+		_world->getObjAttr(objID, kAttrParentObject),
+		_world->getObjAttr(objID, kAttrPosX),
+		_world->getObjAttr(objID, kAttrPosY));
+
+	if (getObjWindow(objID)) {
+		return;
+	}
+	if (objID == _world->getObjAttr(1, kAttrParentObject)) {
+		_gui->updateWindowInfo(kMainGameWindow, objID, _world->getChildren(objID, true));
+		_gui->updateWindow(kMainGameWindow, _world->getObjAttr(objID, kAttrContainerOpen));
+		updateExits();
+		_gui->setWindowTitle(kMainGameWindow, _world->getText(objID, objID, objID)); // it ignores source and target in the original
+	} else { // Open inventory window
+		Common::Point p(_world->getObjAttr(objID, kAttrPosX), _world->getObjAttr(objID, kAttrPosY));
+		WindowReference invID = _gui->createInventoryWindow(objID);
+		_gui->setWindowTitle(invID, _world->getText(objID, objID, objID));
+		_gui->updateWindowInfo(invID, objID, _world->getChildren(objID, true));
+		_gui->updateWindow(invID, _world->getObjAttr(objID, kAttrContainerOpen));
+	}
+}
+
+void MacVentureEngine::closeObject(ObjID objID) {
+	warning("closeObject: not fully implemented");
+	_gui->tryCloseWindow(getObjWindow(objID));
+	return;
+}
+
+void MacVentureEngine::checkObject(QueuedObject old) {
+	bool hasChanged = false;
+	debugC(3, kMVDebugMain, "Check Object[%d] parent[%d] x[%d] y[%d]",
+		old.object,
+		old.parent,
+		old.x,
+		old.y);
+	ObjID id = old.object;
+	if (id == 1) {
+		if (old.parent != _world->getObjAttr(id, kAttrParentObject)) {
+			enqueueObject(kSetToPlayerParent, id);
+		}
+		if (old.offscreen != _world->getObjAttr(id, kAttrInvisible) ||
+			old.invisible != _world->getObjAttr(id, kAttrUnclickable)) {
+			updateWindow(findParentWindow(id));
+		}
+	} else if (old.parent != _world->getObjAttr(id, kAttrParentObject) ||
+				old.x != _world->getObjAttr(id, kAttrPosX) ||
+				old.y != _world->getObjAttr(id, kAttrPosY)) {
+		WindowReference oldWin = getObjWindow(old.parent);
+		if (oldWin) {
+			_gui->removeChild(oldWin, id);
+			hasChanged = true;
+		}
+
+		WindowReference newWin = findParentWindow(id);
+		if (newWin) {
+			_gui->addChild(newWin, id);
+			hasChanged = true;
+		}
+	} else if (old.offscreen != _world->getObjAttr(id, kAttrInvisible) ||
+				old.invisible != _world->getObjAttr(id, kAttrUnclickable)) {
+		updateWindow(findParentWindow(id));
+	}
+
+	if (_world->getObjAttr(id, kAttrIsExit)) {
+		if (hasChanged ||
+			old.hidden != _world->getObjAttr(id, kAttrHiddenExit) ||
+			old.exitx != _world->getObjAttr(id, kAttrExitX) ||
+			old.exity != _world->getObjAttr(id, kAttrExitY))
+			_gui->updateExit(id);
+	}
+	WindowReference win = getObjWindow(id);
+	ObjID cur = id;
+	ObjID root = _world->getObjAttr(1, kAttrParentObject);
+	while (cur != root)	{
+		if (cur == 0 || !_world->getObjAttr(cur, kAttrContainerOpen)) {
+			break;
+		}
+		cur = _world->getObjAttr(cur, kAttrParentObject);
+	}
+	if (cur == root) {
+		if (win) {
+			return;
+		}
+		enqueueObject(kOpenWindow, id); //open
+	} else {
+		if (!win) {
+			return;
+		}
+		enqueueObject(kCloseWindow, id); //close
+	}
+
+	// Update children
+	Common::Array<ObjID> children = _world->getChildren(id, true);
+	for (uint i = 0; i < children.size(); i++) {
+		enqueueObject(kUpdateObject, children[i]);
+	}
+}
+
+void MacVentureEngine::reflectSwap(ObjID fromID, ObjID toID) {
+	WindowReference from = getObjWindow(fromID);
+	WindowReference to = getObjWindow(toID);
+	WindowReference tmp = to;
+	debugC(3, kMVDebugMain, "Swap Object[%d] to Object[%d], from win[%d] to win[%d] ",
+		fromID, toID, from, to);
+
+	if (!to) {
+		tmp = from;
+	}
+	if (tmp) {
+		Common::String newTitle = _world->getText(toID, 0, 0); // Ignores src and targ in the original
+		_gui->setWindowTitle(tmp, newTitle);
+		_gui->updateWindowInfo(tmp, toID, _world->getChildren(toID, true));
+		updateWindow(tmp);
+	}
+}
+
+void MacVentureEngine::toggleExits() {
+	Common::Array<ObjID> exits = _currentSelection;
+	while (!exits.empty()) {
+		ObjID obj = exits.front();
+		exits.remove_at(0);
+		highlightExit(obj);
+		updateWindow(findParentWindow(obj));
+	}
+}
+
+void MacVentureEngine::zoomObject(ObjID objID) {
+	warning("zoomObject: unimplemented");
+}
+
+bool MacVentureEngine::isObjEnqueued(ObjID objID) {
+	Common::Array<QueuedObject>::const_iterator it;
+	for (it = _objQueue.begin(); it != _objQueue.end(); it++) {
+		if ((*it).object == objID) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool MacVentureEngine::isGameRunning() {
+	return (_gameState == kGameStateInit || _gameState == kGameStatePlaying);
+}
+
+ControlAction MacVenture::MacVentureEngine::referenceToAction(ControlType id) {
+	switch (id) {
+	case MacVenture::kControlExitBox:
+		return kActivateObject;//?? Like this in the original
+	case MacVenture::kControlExamine:
+		return kExamine;
+	case MacVenture::kControlOpen:
+		return kOpen;
+	case MacVenture::kControlClose:
+		return kClose;
+	case MacVenture::kControlSpeak:
+		return kSpeak;
+	case MacVenture::kControlOperate:
+		return kOperate;
+	case MacVenture::kControlGo:
+		return kGo;
+	case MacVenture::kControlHit:
+		return kHit;
+	case MacVenture::kControlConsume:
+		return kConsume;
+	default:
+		return kNoCommand;
+	}
+}
+
+// Data retrieval
+
+bool MacVentureEngine::isPaused() {
+	return _paused;
+}
+
+bool MacVentureEngine::needsClickToContinue() {
+	return _clickToContinue;
+}
+
+Common::String MacVentureEngine::getCommandsPausedString() const {
+	return Common::String("Click to continue");
+}
+
+Common::String MacVentureEngine::getFilePath(FilePathID id) const {
+	if (id <= 3) { // We don't want a file in the subdirectory
+		return _filenames->getString(id);
+	} else { // We want a game file
+		return _filenames->getString(3) + "/" + _filenames->getString(id);
+	}
+}
+
+bool MacVentureEngine::isOldText() const {
+	return _oldTextEncoding;
+}
+
+const HuffmanLists *MacVentureEngine::getDecodingHuffman() const {
+	return _textHuffman;
+}
+
+uint32 MacVentureEngine::randBetween(uint32 min, uint32 max) {
+	return _rnd->getRandomNumber(max - min) + min;
+}
+
+uint32 MacVentureEngine::getInvolvedObjects() {
+	// If there is no valid control selected, we return a number too big
+	// to be useful. There is no control that uses that many objects.
+	return (_selectedControl ? getGlobalSettings()._cmdArgCnts[_selectedControl - 1] : 3000);
+}
+
+Common::Point MacVentureEngine::getObjPosition(ObjID objID) {
+	return Common::Point(_world->getObjAttr(objID, kAttrPosX), _world->getObjAttr(objID, kAttrPosY));
+}
+
+bool MacVentureEngine::isObjVisible(ObjID objID) {
+	return _world->getObjAttr(objID, kAttrInvisible) == 0;
+}
+
+bool MacVentureEngine::isObjClickable(ObjID objID) {
+	return _world->getObjAttr(objID, kAttrUnclickable) == 0;
+}
+
+bool MacVentureEngine::isObjSelected(ObjID objID) {
+	int idx = findObjectInArray(objID, _currentSelection);
+	return idx != -1;
+}
+
+bool MacVentureEngine::isObjExit(ObjID objID) {
+	return _world->getObjAttr(objID, kAttrIsExit);
+}
+
+bool MacVentureEngine::isHiddenExit(ObjID objID) {
+	return _world->getObjAttr(objID, kAttrHiddenExit);
+}
+
+Common::Point MacVentureEngine::getObjExitPosition(ObjID objID) {
+	uint x = _world->getObjAttr(objID, kAttrExitX);
+	uint y = _world->getObjAttr(objID, kAttrExitY);
+	return Common::Point(x, y);
+}
+
+ObjID MacVentureEngine::getParent(ObjID objID) {
+	return _world->getObjAttr(objID, kAttrParentObject);
+}
+
+Common::Rect MacVentureEngine::getObjBounds(ObjID objID) {
+	Common::Point pos = getObjPosition(objID);
+
+	WindowReference win = findParentWindow(objID);
+	if (win != kNoWindow) { // If it's not in a window YET, we don't really care about the border
+		BorderBounds bounds = borderBounds(_gui->getWindowData(win).type); // HACK
+		pos.x += bounds.leftOffset;
+		pos.y += bounds.topOffset;
+	}
+	Common::Point measures = _gui->getObjMeasures(objID);
+	uint w = measures.x;
+	uint h = measures.y;
+	return Common::Rect(pos.x, pos.y, pos.x + w, pos.y + h);
+}
+
+uint MacVentureEngine::getOverlapPercent(ObjID one, ObjID other) {
+	// If it's not the same parent, there's 0 overlap
+	if (_world->getObjAttr(one, kAttrParentObject) !=
+		_world->getObjAttr(other, kAttrParentObject))
+		return 0;
+
+	Common::Rect oneBounds = getObjBounds(one);
+	Common::Rect otherBounds = getObjBounds(other);
+	if (otherBounds.intersects(oneBounds) ||
+		oneBounds.intersects(otherBounds)) {
+		uint areaOne = oneBounds.width() * oneBounds.height();
+		uint areaOther = otherBounds.width() * otherBounds.height();
+		return (areaOne != 0) ? (areaOther * 100 / areaOne) : 0;
+	}
+	return 0;
+}
+
+WindowReference MacVentureEngine::getObjWindow(ObjID objID) {
+	return _gui->getObjWindow(objID);
+}
+
+WindowReference MacVentureEngine::findParentWindow(ObjID objID) {
+	if (objID == 1) {
+		return kSelfWindow;
+	}
+	ObjID parent = _world->getObjAttr(objID, kAttrParentObject);
+	if (parent == 0) {
+		return kNoWindow;
+	}
+	return getObjWindow(parent);
+}
+
+Common::Point MacVentureEngine::getDeltaPoint() {
+	return _deltaPoint;
+}
+
+ObjID MacVentureEngine::getDestObject() {
+	return _destObject;
+}
+
+ControlAction MacVentureEngine::getSelectedControl() {
+	return _selectedControl;
+}
+
+// Data loading
+
+bool MacVentureEngine::loadGlobalSettings() {
+	Common::MacResIDArray resArray;
+
+	if ((resArray = _resourceManager->getResIDArray(MKTAG('G', 'N', 'R', 'L'))).size() == 0)
+		return false;
+
+	Common::SeekableReadStream *res;
+	res = _resourceManager->getResource(MKTAG('G', 'N', 'R', 'L'), kGlobalSettingsID);
+	if (res) {
+		_globalSettings = new GlobalSettings();
+		_globalSettings->loadSettings(res);
+		delete res;
+		return true;
+	}
+	return false;
+}
+
+bool MacVentureEngine::loadTextHuffman() {
+	Common::MacResIDArray resArray;
+	Common::SeekableReadStream *res;
+
+	if ((resArray = _resourceManager->getResIDArray(MKTAG('G', 'N', 'R', 'L'))).size() == 0)
+		return false;
+
+	res = _resourceManager->getResource(MKTAG('G', 'N', 'R', 'L'), kTextHuffmanTableID);
+	if (res) {
+		uint32 numEntries = res->readUint16BE();
+		res->readUint16BE(); // Skip
+
+		uint32 *masks = new uint32[numEntries];
+		for (uint i = 0; i < numEntries - 1; i++) {
+			// For some reason there are one lass mask than entries
+			masks[i] = res->readUint16BE();
+		}
+
+		uint32 *lengths = new uint32[numEntries];
+		for (uint i = 0; i < numEntries; i++) {
+			lengths[i] = res->readByte();
+		}
+
+		uint32 *values = new uint32[numEntries];
+		for (uint i = 0; i < numEntries; i++) {
+			values[i] = res->readByte();
+		}
+
+		_textHuffman = new HuffmanLists(numEntries, lengths, masks, values);
+		debugC(4, kMVDebugMain, "Text is huffman-encoded");
+
+		delete res;
+		delete[] masks;
+		delete[] lengths;
+		delete[] values;
+		return true;
+	}
+	return false;
+}
+
+// Global Settings
+GlobalSettings::GlobalSettings() {
+}
+
+GlobalSettings::~GlobalSettings() {
+
+}
+
+void GlobalSettings::loadSettings(Common::SeekableReadStream *dataStream) {
+	_numObjects = dataStream->readUint16BE();
+	_numGlobals = dataStream->readUint16BE();
+	_numCommands = dataStream->readUint16BE();
+	_numAttributes = dataStream->readUint16BE();
+	_numGroups = dataStream->readUint16BE();
+	dataStream->readUint16BE(); // unknown
+	_invTop = dataStream->readUint16BE();
+	_invLeft = dataStream->readUint16BE();
+	_invWidth = dataStream->readUint16BE();
+	_invHeight = dataStream->readUint16BE();
+	_invOffsetY = dataStream->readUint16BE();
+	_invOffsetX = dataStream->readSint16BE();
+	_defaultFont = dataStream->readUint16BE();
+	_defaultSize = dataStream->readUint16BE();
+
+	uint8 *attrIndices = new uint8[_numAttributes];
+	dataStream->read(attrIndices, _numAttributes);
+	_attrIndices = Common::Array<uint8>(attrIndices, _numAttributes);
+	delete[] attrIndices;
+
+	for (int i = 0; i < _numAttributes; i++) {
+		_attrMasks.push_back(dataStream->readUint16BE());
+	}
+
+	uint8 *attrShifts = new uint8[_numAttributes];
+	dataStream->read(attrShifts, _numAttributes);
+	_attrShifts = Common::Array<uint8>(attrShifts, _numAttributes);
+	delete[] attrShifts;
+
+	uint8 *cmdArgCnts = new uint8[_numCommands];
+	dataStream->read(cmdArgCnts, _numCommands);
+	_cmdArgCnts = Common::Array<uint8>(cmdArgCnts, _numCommands);
+	delete[] cmdArgCnts;
+
+	uint8 *commands = new uint8[_numCommands];
+	dataStream->read(commands, _numCommands);
+	_commands = Common::Array<uint8>(commands, _numCommands);
+	delete[] commands;
+}
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/macventure.h b/engines/macventure/macventure.h
new file mode 100644
index 0000000000..6908bc6050
--- /dev/null
+++ b/engines/macventure/macventure.h
@@ -0,0 +1,369 @@
+/* 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 MACVENTURE_MACVENTURE_H
+#define MACVENTURE_MACVENTURE_H
+
+#include "engines/engine.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/debug.h"
+#include "common/random.h"
+#include "common/macresman.h"
+#include "common/huffman.h"
+#include "common/savefile.h"
+
+#include "gui/debugger.h"
+
+#include "macventure/debug.h"
+#include "macventure/gui.h"
+#include "macventure/world.h"
+#include "macventure/hufflists.h"
+#include "macventure/stringtable.h"
+#include "macventure/script.h"
+#include "macventure/controls.h"
+#include "macventure/windows.h"
+#include "macventure/sound.h"
+
+struct ADGameDescription;
+
+namespace MacVenture {
+
+class SaveFileManager;
+
+class Console;
+class World;
+class ScriptEngine;
+
+class SoundManager;
+
+typedef uint32 ObjID;
+
+// HACK, until I find a way to translate correctly
+extern void toASCII(Common::String &str);
+
+enum {
+	kScreenWidth = 512,
+	kScreenHeight = 342
+};
+
+enum {
+	kGlobalSettingsID = 0x80,
+	kDiplomaGeometryID = 0x81,
+	kTextHuffmanTableID = 0x83
+};
+
+enum {
+	kSaveGameStrID = 0x82,
+	kDiplomaFilenameID = 0x83,
+	kClickToContinueTextID = 0x84,
+	kStartGameFilenameID = 0x85
+};
+
+enum FilePathID {
+	kMCVID = 1,
+	kTitlePathID = 2,
+	kSubdirPathID = 3,
+	kObjectPathID = 4,
+	kFilterPathID = 5,
+	kTextPathID = 6,
+	kGraphicPathID = 7,
+	kSoundPathID = 8
+};
+
+
+class GlobalSettings {
+public:
+	GlobalSettings();
+	~GlobalSettings();
+
+	void loadSettings(Common::SeekableReadStream *dataStream);
+
+// HACK MAybe this should be private, but the class is only here to handle
+// memory allocation/deallocation
+public:
+	uint16 _numObjects;    // number of game objects defined
+	uint16 _numGlobals;    // number of globals defined
+	uint16 _numCommands;   // number of commands defined
+	uint16 _numAttributes; // number of attributes
+	uint16 _numGroups;     // number of object groups
+	uint16 _invTop;        // inventory window bounds
+	uint16 _invLeft;
+	uint16 _invHeight;
+	uint16 _invWidth;
+	uint16 _invOffsetY;    // positioning offset for
+	uint16 _invOffsetX;    // new inventory windows
+	uint16 _defaultFont;   // default font
+	uint16 _defaultSize;   // default font size
+	Common::Array<uint8> _attrIndices; // attribute indices into attribute table
+	Common::Array<uint16> _attrMasks;   // attribute masks
+	Common::Array<uint8> _attrShifts;  // attribute bit shifts
+	Common::Array<uint8> _cmdArgCnts;  // command argument counts
+	Common::Array<uint8> _commands;    // command buttons
+};
+
+enum GameState {
+	kGameStateInit,
+	kGameStatePlaying,
+	kGameStateWinnig,
+	kGameStateLosing,
+	kGameStateQuitting
+};
+
+enum ObjectQueueID {
+	kFocusWindow = 2,
+	kOpenWindow = 3,
+	kCloseWindow = 4,
+	kUpdateObject = 7,
+	kUpdateWindow = 8,
+	kSetToPlayerParent = 12,
+	kHightlightExits = 13,
+	kAnimateBack = 14
+};
+
+struct QueuedObject {
+	ObjectQueueID id;
+	ObjID object;
+	ObjID parent;
+	uint x;
+	uint y;
+	uint exitx;
+	uint exity;
+	bool hidden;
+	bool offscreen;
+	bool invisible;
+	ObjID target; // For swapping
+};
+
+enum TextQueueID {
+	kTextNumber = 1,
+	kTextNewLine = 2,
+	kTextPlain = 3
+};
+
+struct QueuedText {
+	TextQueueID id;
+	ObjID source;
+	ObjID destination;
+	ObjID asset;
+};
+
+enum SoundQueueID {
+	kSoundPlay = 1,
+	kSoundPlayAndWait = 2,
+	kSoundWait = 3
+};
+
+struct QueuedSound {
+	SoundQueueID id;
+	ObjID reference;
+};
+
+class MacVentureEngine : public Engine {
+
+public:
+	MacVentureEngine(OSystem *syst, const ADGameDescription *gameDesc);
+	~MacVentureEngine();
+
+	virtual bool hasFeature(EngineFeature f) const;
+
+	virtual Common::Error run();
+
+	bool scummVMSaveLoadDialog(bool isSave);
+	bool canLoadGameStateCurrently();
+	bool canSaveGameStateCurrently();
+	virtual Common::Error loadGameState(int slot);
+	virtual Common::Error saveGameState(int slot, const Common::String &desc);
+	void newGame();
+	void setInitialFlags();
+	void setNewGameState();
+
+	void initDebugChannels();
+	void reset();
+	void resetInternals();
+	void resetGui();
+	void refreshScreen();
+
+	// datafiles.cpp
+	void loadDataBundle();
+	Common::SeekableReadStream *getBorderFile(MVWindowType windowType, bool isActive);
+
+	void requestQuit();
+	void requestUnpause();
+	void selectControl(ControlAction action);
+	void refreshReady();
+	void preparedToRun();
+	void gameChanged();
+	void winGame();
+	void loseGame();
+	void clickToContinue();
+
+	void updateState(bool pause);
+	void revert();
+
+	void enqueueObject(ObjectQueueID type, ObjID objID, ObjID target = 0);
+	void enqueueText(TextQueueID type, ObjID target, ObjID source, ObjID text);
+	void enqueueSound(SoundQueueID type, ObjID target);
+
+	void runObjQueue();
+	void printTexts();
+	void playSounds(bool pause);
+
+	void handleObjectSelect(ObjID objID, WindowReference win, bool shiftPressed, bool isDoubleClick);
+	void handleObjectDrop(ObjID objID, Common::Point delta, ObjID newParent);
+	void setDeltaPoint(Common::Point newPos);
+	void focusObjWin(ObjID objID);
+	void updateWindow(WindowReference winID);
+
+	bool showTextEntry(ObjID text, ObjID srcObj, ObjID destObj);
+	void setTextInput(Common::String content);
+	Common::String getUserInput();
+
+	// Data retrieval
+	Common::String getStartGameFileName();
+	bool isPaused();
+	bool needsClickToContinue();
+	Common::String getCommandsPausedString() const;
+	const GlobalSettings &getGlobalSettings() const;
+	Common::String getFilePath(FilePathID id) const;
+	bool isOldText() const;
+	const HuffmanLists *getDecodingHuffman() const;
+	uint32 randBetween(uint32 min, uint32 max);
+	uint32 getInvolvedObjects();
+	int findObjectInArray(ObjID objID, const Common::Array<ObjID> &list);
+	uint getPrefixNdx(ObjID obj);
+	Common::String getPrefixString(uint flag, ObjID obj);
+	Common::String getNoun(ObjID ndx);
+
+	// Attributes consult
+	Common::Point getObjPosition(ObjID objID);
+	bool isObjVisible(ObjID objID);
+	bool isObjClickable(ObjID objID);
+	bool isObjSelected(ObjID objID);
+	bool isObjExit(ObjID objID);
+	bool isHiddenExit(ObjID objID);
+	Common::Point getObjExitPosition(ObjID objID);
+	ObjID getParent(ObjID objID);
+
+	// Utils
+	ControlAction referenceToAction(ControlType id);
+
+	// Encapsulation HACK
+	Common::Rect getObjBounds(ObjID objID);
+	uint getOverlapPercent(ObjID one, ObjID other);
+
+	WindowReference getObjWindow(ObjID objID);
+	WindowReference findParentWindow(ObjID objID);
+
+	Common::Point getDeltaPoint();
+	ObjID getDestObject();
+	ControlAction getSelectedControl();
+
+private:
+	void processEvents();
+
+	bool runScriptEngine();
+	void endGame();
+	void updateControls();
+	void resetVars();
+
+	void unselectAll();
+	void selectObject(ObjID objID);
+	void unselectObject(ObjID objID);
+	void highlightExit(ObjID objID);
+	void selectPrimaryObject(ObjID objID);
+	void updateExits();
+
+	// Object queue methods
+	void focusObjectWindow(ObjID objID);
+	void openObject(ObjID objID);
+	void closeObject(ObjID objID);
+	void checkObject(QueuedObject objID);
+	void reflectSwap(ObjID fromID, ObjID toID);
+	void toggleExits();
+	void zoomObject(ObjID objID);
+
+	bool isObjEnqueued(ObjID obj);
+
+	bool isGameRunning();
+
+	// Data loading
+	bool loadGlobalSettings();
+	bool loadTextHuffman();
+
+	const char *getGameFileName() const;
+
+private: // Attributes
+
+	const ADGameDescription *_gameDescription;
+	Common::RandomSource *_rnd;
+
+	Common::MacResManager *_resourceManager;
+
+	Console *_debugger;
+	Gui *_gui;
+	World *_world;
+	ScriptEngine *_scriptEngine;
+
+	// String tables
+	StringTable *_filenames;
+	StringTable *_decodingDirectArticles;
+	StringTable *_decodingNamingArticles;
+	StringTable *_decodingIndirectArticles;
+
+	SoundManager *_soundManager;
+
+	Common::Archive *_dataBundle;
+
+	// Engine state
+	GameState _gameState;
+	GlobalSettings *_globalSettings;
+	HuffmanLists *_textHuffman;
+	bool _oldTextEncoding;
+	bool _paused, _halted, _cmdReady, _prepared;
+	bool _haltedAtEnd, _haltedInSelection;
+	bool _gameChanged;
+	bool _clickToContinue;
+
+	Common::Array<QueuedObject> _objQueue;
+	Common::Array<QueuedObject> _inQueue;
+	Common::Array<QueuedSound> _soundQueue;
+	Common::Array<QueuedText> _textQueue;
+
+	// Selections
+	ObjID _destObject;
+	ControlAction _selectedControl;
+	Common::Array<ObjID> _currentSelection;
+	Common::Point _deltaPoint;
+	Common::String _userInput;
+
+};
+
+
+class Console : public GUI::Debugger {
+public:
+	Console(MacVentureEngine *vm) {}
+	virtual ~Console(void) {}
+};
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/module.mk b/engines/macventure/module.mk
new file mode 100644
index 0000000000..227eb41e28
--- /dev/null
+++ b/engines/macventure/module.mk
@@ -0,0 +1,31 @@
+MODULE := engines/macventure
+
+MODULE_OBJS := \
+	container.o \
+	controls.o \
+	cursor.o \
+	datafiles.o \
+	detection.o \
+	dialog.o \
+	gui.o \
+	image.o \
+	macventure.o \
+	prebuilt_dialogs.o \
+	saveload.o \
+	script.o \
+	sound.o \
+	text.o \
+	windows.o \
+	world.o
+
+
+MODULE_DIRS += \
+	engines/macventure
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_MACVENTURE), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/macventure/prebuilt_dialogs.cpp b/engines/macventure/prebuilt_dialogs.cpp
new file mode 100644
index 0000000000..6137fed219
--- /dev/null
+++ b/engines/macventure/prebuilt_dialogs.cpp
@@ -0,0 +1,76 @@
+/* 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 "macventure/prebuilt_dialogs.h"
+
+namespace MacVenture {
+
+const PrebuiltDialog g_prebuiltDialogs[kPrebuiltDialogCount] = {
+
+	{/* kSaveAsDialog */
+		{0, 146, 456, 254},
+		{
+			{kDEButton, "YES", kDASaveAs, 24, 68, 120, 22},
+			{kDEButton, "NO", kDACloseDialog, 168, 68, 120, 22},
+			{kDEButton, "CANCEL", kDACloseDialog, 312, 68, 120, 22},
+			{kDEPlainText, "Save As...", kDANone, 100, 10, 340, 38},
+			{kDETextInput, "", kDANone, 100, 30, 340, 20},
+			{kDEEnd, "", kDANone, 0, 0, 0, 0}
+		}
+	},
+
+	{ /* kSpeakDialog */
+		{20, 92, 400, 200},
+		{
+			{kDEButton, "OK", kDASubmit, 10, 70, 50, 20},
+			{kDEButton, "CANCEL", kDACloseDialog, 96, 70, 50, 20},
+			{kDEPlainText, "What would you like to say?", kDANone, 10, 10, 400, 20},
+			{kDETextInput, "", kDANone, 10, 25, 350, 40},
+			{kDEEnd, "", kDANone, 0, 0, 0, 0}
+		}
+	},
+
+	{ /* kWinGameDialog */
+		{20, 100, 320, 200},
+		{
+			{kDEPlainText, "You Won!", kDANone, 20, 16, 280, 20},
+			{kDEPlainText, "What do you want to do?", kDANone, 20, 30, 280, 20},
+			{kDEButton, "New Game", kDANewGame, 20, 60, 70, 20},
+			{kDEButton, "Load", kDALoadGame, 110, 60, 70, 20},
+			{kDEButton, "Quit", kDAQuit, 200, 60, 70, 20},
+			{kDEEnd, "", kDANone, 0, 0, 0, 0}
+		}
+	},
+
+	{ /* kLoseGameDialog */
+		{20, 100, 320, 200},
+		{
+			{kDEPlainText, "You Died", kDANone, 20, 16, 280, 20},
+			{kDEPlainText, "What do you want to do?", kDANone, 20, 30, 280, 20},
+			{kDEButton, "New Game", kDANewGame, 20, 60, 70, 20},
+			{kDEButton, "Load", kDALoadGame, 110, 60, 70, 20},
+			{kDEButton, "Quit", kDAQuit, 200, 60, 70, 20},
+			{kDEEnd, "", kDANone, 0, 0, 0, 0}
+		}
+	}
+};
+} // End of namespace MacVenture
diff --git a/engines/macventure/prebuilt_dialogs.h b/engines/macventure/prebuilt_dialogs.h
new file mode 100644
index 0000000000..9cd8f4c1a4
--- /dev/null
+++ b/engines/macventure/prebuilt_dialogs.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 MACVENTURE_PREBUIT_DIALOGS_H
+#define MACVENTURE_PREBUIT_DIALOGS_H
+
+#include "common/rect.h"
+
+namespace MacVenture {
+
+enum DialogAction {
+	kDANone,
+	kDACloseDialog,
+	kDASubmit,
+	kDASaveAs,
+	kDALoadGame,
+	kDAQuit,
+	kDANewGame
+};
+
+enum PrebuiltDialogs {
+	kSaveAsDialog = 0, //TODO: Currently unused, we are using ScummVM dialogs instead.
+	kSpeakDialog = 1,
+	kWinGameDialog = 2,
+	kLoseGameDialog = 3,
+	kPrebuiltDialogCount
+};
+
+enum PrebuiltElementType {
+	kDEPlainText,
+	kDEButton,
+	kDETextInput,
+	kDEEnd
+};
+
+struct PrebuiltDialogBounds {
+	uint left;
+	uint top;
+	uint right;
+	uint bottom;
+};
+
+struct PrebuiltDialogElement {
+	PrebuiltElementType type;
+	const char *title;
+	DialogAction action;
+	uint left;
+	uint top;
+	uint width;
+	uint height;
+};
+
+// Prebuilt dialogs
+enum {
+	// HACK
+	kMaxPrebuiltDialogElements = 10
+};
+
+struct PrebuiltDialog {
+	PrebuiltDialogBounds bounds;
+	PrebuiltDialogElement elements[kMaxPrebuiltDialogElements];
+};
+
+extern const PrebuiltDialog g_prebuiltDialogs[];
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/saveload.cpp b/engines/macventure/saveload.cpp
new file mode 100644
index 0000000000..53736302d2
--- /dev/null
+++ b/engines/macventure/saveload.cpp
@@ -0,0 +1,197 @@
+/* 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 "macventure/macventure.h"
+
+#include "common/error.h"
+#include "common/savefile.h"
+#include "engines/savestate.h"
+#include "gui/saveload.h"
+#include "graphics/thumbnail.h"
+
+namespace MacVenture {
+
+#define MACVENTURE_SAVE_HEADER MKTAG('M', 'V', 'S', 'S') // (M)ac(V)enture (S)cummVM (S)ave (0x4d565353, uint32)
+#define MACVENTURE_SAVE_VERSION 1 //1 BYTE
+#define MACVENTURE_DESC_LENGTH 4 //4 BYTE for the metadata length
+
+SaveStateDescriptor loadMetaData(Common::SeekableReadStream *s, int slot) {
+	// Metadata is stored at the end of the file
+	// |THUMBNAIL						|
+	// |								|
+	// |DESCSIZE| DESCRIPTION			|
+	// |HEADER			|VERSION|DESCLEN|
+	s->seek(-(5 + MACVENTURE_DESC_LENGTH), SEEK_END);
+	uint32 sig = s->readUint32BE();
+	byte version = s->readByte();
+
+	SaveStateDescriptor desc(-1, "");	// init to an invalid save slot
+
+	if (sig != MACVENTURE_SAVE_HEADER || version > MACVENTURE_SAVE_VERSION)
+		return desc;
+
+	// Save is valid, set its slot number
+	desc.setSaveSlot(slot);
+
+	// Depends on MACVENTURE_DESC_LENGTH
+	uint32 metaSize = s->readUint32BE();
+	s->seek(-(5 + MACVENTURE_DESC_LENGTH + metaSize), SEEK_END);
+
+	// Load the thumbnail
+	Graphics::Surface *thumb = Graphics::loadThumbnail(*s);
+	desc.setThumbnail(thumb);
+
+	// Load the description
+	Common::String name;
+	uint32 descSize = s->readUint32BE();
+	for (uint32 i = 0; i < descSize; ++i) {
+		name += s->readByte();
+	}
+	desc.setDescription(name);
+
+	// Load date
+	uint32 saveDate = s->readUint32LE();
+	int day = (saveDate >> 24) & 0xFF;
+	int month = (saveDate >> 16) & 0xFF;
+	int year = saveDate & 0xFFFF;
+	desc.setSaveDate(year, month, day);
+
+	uint16 saveTime = s->readUint16LE();
+	int hour = (saveTime >> 8) & 0xFF;
+	int minutes = saveTime & 0xFF;
+	desc.setSaveTime(hour, minutes);
+
+	// Load playtime
+	uint32 playTime = s->readUint32LE();
+	desc.setPlayTime(playTime * 1000);
+
+	return desc;
+}
+
+uint saveCurrentDate(Common::OutSaveFile *file) {
+	TimeDate curTime;
+	g_system->getTimeAndDate(curTime);
+
+	uint32 saveDate = ((curTime.tm_mday & 0xFF) << 24) | (((curTime.tm_mon + 1) & 0xFF) << 16) | ((curTime.tm_year + 1900) & 0xFFFF);
+	uint16 saveTime = ((curTime.tm_hour & 0xFF) << 8) | ((curTime.tm_min) & 0xFF);
+
+	file->writeUint32LE(saveDate);
+	file->writeUint16LE(saveTime);
+
+	// Return the number of bytes occupied
+	return 6;
+}
+
+uint savePlayTime(Common::OutSaveFile *file) {
+	uint32 playTime = g_engine->getTotalPlayTime() / 1000;
+	file->writeUint32LE(playTime);
+	// Return the number of bytes occupied
+	return 4;
+}
+
+void writeMetaData(Common::OutSaveFile *file, Common::String desc) {
+
+	// Write thumbnail
+	uint thumbSize = file->pos();
+	Graphics::saveThumbnail(*file);
+	thumbSize = file->pos() - thumbSize;
+
+	// Write description
+	file->writeUint32BE(desc.size());
+	file->writeString(desc);
+
+	uint dateSize = saveCurrentDate(file);
+	uint playTimeSize = savePlayTime(file);
+
+	file->writeUint32BE(MACVENTURE_SAVE_HEADER);
+	file->writeByte(MACVENTURE_SAVE_VERSION);
+	file->writeUint32BE(4 + desc.size() + dateSize + playTimeSize + thumbSize);
+}
+
+Common::Error MacVentureEngine::loadGameState(int slot) {
+	Common::String saveFileName = Common::String::format("%s.%03d", _targetName.c_str(), slot);
+	Common::InSaveFile *file;
+	if(!(file = getSaveFileManager()->openForLoading(saveFileName))) {
+		error("ENGINE: Missing savegame file %s", saveFileName.c_str());
+	}
+	_world->loadGameFrom(file);
+	reset();
+	return Common::kNoError;
+}
+
+Common::Error MacVentureEngine::saveGameState(int slot, const Common::String &desc) {
+	Common::String saveFileName = Common::String::format("%s.%03d", _targetName.c_str(), slot);
+	Common::SaveFileManager *manager = getSaveFileManager();
+	// HACK Get a real name!
+	Common::OutSaveFile *file = manager->openForSaving(saveFileName);
+	_world->saveGameInto(file);
+	writeMetaData(file, desc);
+
+	file->finalize();
+	if (file->err()) {
+		warning("Could not save '%s' correctly.", saveFileName.c_str());
+	}
+	delete file;
+	return Common::kNoError;
+}
+
+bool MacVentureEngine::scummVMSaveLoadDialog(bool isSave) {
+	if (!isSave) {
+		// do loading
+		GUI::SaveLoadChooser dialog = GUI::SaveLoadChooser(Common::String("Load game:"), Common::String("Load"), false);
+		int slot = dialog.runModalWithCurrentTarget();
+
+		if (slot < 0)
+			return true;
+
+		return loadGameState(slot).getCode() == Common::kNoError;
+	}
+
+	// do saving
+	GUI::SaveLoadChooser dialog = GUI::SaveLoadChooser(Common::String("Save game:"), Common::String("Save"), true);
+	int slot = dialog.runModalWithCurrentTarget();
+	Common::String desc = dialog.getResultString();
+
+	if (desc.empty()) {
+		// create our own description for the saved game, the user didnt enter it
+		desc = dialog.createDefaultSaveDescription(slot);
+	}
+
+	/*
+	if (desc.size() > (1 << MACVENTURE_DESC_LENGTH * 8) - 1)
+		desc = Common::String(desc.c_str(), (1 << MACVENTURE_DESC_LENGTH * 8) - 1);
+	*/
+	if (slot < 0)
+		return true;
+
+	return saveGameState(slot, desc).getCode() == Common::kNoError;
+}
+
+bool MacVentureEngine::canLoadGameStateCurrently() {
+	return true;
+}
+
+bool MacVentureEngine::canSaveGameStateCurrently() {
+	return true;
+}
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/script.cpp b/engines/macventure/script.cpp
new file mode 100644
index 0000000000..d3731489e4
--- /dev/null
+++ b/engines/macventure/script.cpp
@@ -0,0 +1,1251 @@
+/* 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/system.h"
+
+#include "macventure/macventure.h"
+#include "macventure/script.h"
+#include "macventure/world.h"
+#include "macventure/container.h"
+
+namespace MacVenture {
+
+ScriptEngine::ScriptEngine(MacVentureEngine *engine, World *world) {
+	_engine = engine;
+	_world = world;
+	_scripts = new Container(_engine->getFilePath(kFilterPathID));
+}
+
+ScriptEngine::~ScriptEngine() {
+	if (_scripts)
+		delete _scripts;
+}
+
+bool ScriptEngine::runControl(ControlAction action, ObjID source, ObjID destination, Common::Point delta) {
+	EngineFrame frame;
+	frame.action = action;
+	frame.src = source;
+	frame.dest = destination;
+	frame.x = delta.x;
+	frame.y = delta.y;
+	frame.haltedInSaves = false;
+	frame.haltedInFirst = false;
+	frame.haltedInFamily = false;
+	_frames.push_back(frame);
+	debugC(3, kMVDebugScript, "Stored frame %d, action: %d src: %d dest: %d point: (%d, %d)",
+		_frames.size() - 1, frame.action, frame.src, frame.dest, frame.x, frame.y);
+
+	return resume(true);
+}
+
+bool ScriptEngine::resume(bool execAll) {
+	debugC(3, kMVDebugScript, "Resume Script");
+	while (_frames.size()) {
+		bool fail = execFrame(execAll);
+		if (fail) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void ScriptEngine::reset() {
+	_frames.clear();
+}
+
+bool ScriptEngine::execFrame(bool execAll) {
+	bool doFirst = execAll;
+	bool doFamily = false;
+	bool fail;
+
+	EngineFrame *frame = &_frames.front();
+
+	// Do first dispatch script (script 0)
+	if (frame->haltedInFirst || doFirst) { // We were stuck or it's the first time
+		frame->haltedInFirst = false;
+		if (doFirst) {
+			fail = loadScript(frame, 0);
+		} else {
+			fail = resumeFunc(frame);
+		}
+		if (fail) {
+			frame->haltedInFirst = true;
+			_engine->preparedToRun();
+			return true;
+		}
+		doFamily = true;
+		frame->familyIdx = 0;
+	}
+
+	// Do scripts in the family of player (ObjID 1)
+	if (frame->haltedInFamily || doFamily) { // We have to do the family or we were stuck here
+		frame->haltedInFamily = false;
+		Common::Array<ObjID> family = _world->getFamily(_world->getObjAttr(1, kAttrParentObject), false);
+		for (uint32 i = frame->familyIdx; i < family.size(); i++) {
+			if (doFamily) {
+				fail = loadScript(frame, family[i]);
+			} else {
+				fail = resumeFunc(frame);
+			}
+			if (fail) { // We are stuck, so we don't shift the frame
+				frame->haltedInFamily = true;
+				frame->familyIdx = i;
+				_engine->preparedToRun();
+				return true;
+			}
+			doFamily = true;
+		}
+	}
+
+	// Halted in saves
+	if (frame->haltedInSaves) {
+		frame->haltedInSaves = false;
+		if (resumeFunc(frame)) {
+			frame->haltedInSaves = true;
+			_engine->preparedToRun();
+			return true;
+		}
+	}
+
+	int highest = 0;
+	uint localHigh = 0;
+	do { // Saved function calls
+		highest = 0;
+		for (uint i = 0; i < frame->saves.size(); i++) {
+			if (highest < frame->saves[i].rank) {
+				highest = frame->saves[i].rank;
+				localHigh = i;
+			}
+		}
+		if (highest) {
+			frame->saves[localHigh].rank = 0;
+			if (loadScript(frame, frame->saves[localHigh].func)) {
+				frame->haltedInSaves = true;
+				_engine->preparedToRun();
+				return true;
+			}
+		}
+	} while (highest);
+
+	_frames.pop_front();
+	return false;
+}
+
+bool ScriptEngine::loadScript(EngineFrame *frame, uint32 scriptID) {
+	if (_scripts->getItemByteSize(scriptID) > 0) {
+		debugC(2, kMVDebugScript, "Loading function %d", scriptID);
+		// Insert the new script at the front
+		frame->scripts.push_front(ScriptAsset(scriptID, _scripts));
+		return runFunc(frame);
+	}
+	return false;
+}
+
+bool ScriptEngine::resumeFunc(EngineFrame *frame) {
+	bool fail = runFunc(frame);
+	if (fail) {
+		return fail;
+	}
+	frame->scripts.pop_front();
+	if (frame->scripts.size())
+		return resumeFunc(frame);
+	return false;
+}
+
+bool ScriptEngine::runFunc(EngineFrame *frame) {
+	ScriptAsset &script = frame->scripts.front();
+	EngineState *state = &frame->state;
+	byte op;
+	while (script.hasNext()) {
+		op = script.fetch();
+		debugC(4, kMVDebugScript, "Running operation %d", op);
+		if (!(op & 0x80)) {
+			state->push(op);
+		} else {
+			switch (op) {
+			case 0x80: //get attribute
+				op80GATT(state, frame);
+				break;
+			case 0x81: //set attribute
+				op81SATT(state, frame);
+				break;
+			case 0x82: //sum children attribute
+				op82SUCH(state, frame);
+				break;
+			case 0x83: //push selected control
+				op83PUCT(state, frame);
+				break;
+			case 0x84: //push selected object
+				op84PUOB(state, frame);
+				break;
+			case 0x85: //push target
+				op85PUTA(state, frame);
+				break;
+			case 0x86: //push deltax
+				op86PUDX(state, frame);
+				break;
+			case 0x87: //push deltay
+				op87PUDY(state, frame);
+				break;
+			case 0x88: //push immediate.b
+				op88PUIB(state, frame, &script);
+				break;
+			case 0x89: //push immediate
+				op89PUI(state, frame, &script);
+				break;
+			case 0x8a: //get global
+				op8aGGLO(state, frame);
+				break;
+			case 0x8b: //set global
+				op8bSGLO(state, frame);
+				break;
+			case 0x8c: //random
+				op8cRAND(state, frame);
+				break;
+			case 0x8d: //copy
+				op8dCOPY(state, frame);
+				break;
+			case 0x8e: //copyn
+				op8eCOPYN(state, frame);
+				break;
+			case 0x8f: //swap
+				op8fSWAP(state, frame);
+				break;
+			case 0x90: //swapn
+				op90SWAPN(state, frame);
+				break;
+			case 0x91: //pop
+				op91POP(state, frame);
+				break;
+			case 0x92: //copy+1
+				op92COPYP(state, frame);
+				break;
+			case 0x93: //copy+n
+				op93COPYPN(state, frame);
+				break;
+			case 0x94: //shuffle
+				op94SHUFF(state, frame);
+				break;
+			case 0x95: //sort
+				op95SORT(state, frame);
+				break;
+			case 0x96: //clear stack
+				op96CLEAR(state, frame);
+				break;
+			case 0x97: //get stack size
+				op97SIZE(state, frame);
+				break;
+			case 0x98: //add
+				op98ADD(state, frame);
+				break;
+			case 0x99: //subtract
+				op99SUB(state, frame);
+				break;
+			case 0x9a: //multiply
+				op9aMUL(state, frame);
+				break;
+			case 0x9b: //divide
+				op9bDIV(state, frame);
+				break;
+			case 0x9c: //mod
+				op9cMOD(state, frame);
+				break;
+			case 0x9d: //divmod
+				op9dDMOD(state, frame);
+				break;
+			case 0x9e: //abs
+				op9eABS(state, frame);
+				break;
+			case 0x9f: //neg
+				op9fNEG(state, frame);
+				break;
+			case 0xa0: //and
+				opa0AND(state, frame);
+				break;
+			case 0xa1: //or
+				opa1OR(state, frame);
+				break;
+			case 0xa2: //xor
+				opa2XOR(state, frame);
+				break;
+			case 0xa3: //not
+				opa3NOT(state, frame);
+				break;
+			case 0xa4: //logical and
+				opa4LAND(state, frame);
+				break;
+			case 0xa5: //logical or
+				opa5LOR(state, frame);
+				break;
+			case 0xa6: //logical xor
+				opa6LXOR(state, frame);
+				break;
+			case 0xa7: //logical not
+				opa7LNOT(state, frame);
+				break;
+			case 0xa8: //gt? unsigned
+				opa8GTU(state, frame);
+				break;
+			case 0xa9: //lt? unsigned
+				opa9LTU(state, frame);
+				break;
+			case 0xaa: //gt? signed
+				opaaGTS(state, frame);
+				break;
+			case 0xab: //lt? signed
+				opabLTS(state, frame);
+				break;
+			case 0xac: //eq?
+				opacEQ(state, frame);
+				break;
+			case 0xad: //eq string?
+				opadEQS(state, frame);
+				break;
+			case 0xae: //contains
+				opaeCONT(state, frame);
+				break;
+			case 0xaf: //contains word
+				opafCONTW(state, frame);
+				break;
+			case 0xb0: //bra
+				opb0BRA(state, frame, &script);
+				break;
+			case 0xb1: //bra.b
+				opb1BRAB(state, frame, &script);
+				break;
+			case 0xb2: //beq
+				opb2BEQ(state, frame, &script);
+				break;
+			case 0xb3: //beq.b
+				opb3BEQB(state, frame, &script);
+				break;
+			case 0xb4: //bne
+				opb4BNE(state, frame, &script);
+				break;
+			case 0xb5: //bne.b
+				opb5BNEB(state, frame, &script);
+				break;
+			case 0xb6: //call later
+				opb6CLAT(state, frame);
+				break;
+			case 0xb7: //cancel call
+				opb7CCA(state, frame);
+				break;
+			case 0xb8: //cancel low priority
+				opb8CLOW(state, frame);
+				break;
+			case 0xb9: //cancel high priority
+				opb9CHI(state, frame);
+				break;
+			case 0xba: //cancel priority range
+				opbaCRAN(state, frame);
+				break;
+			case 0xbb: //fork
+				if (opbbFORK(state, frame))
+					return true;
+				break;
+			case 0xbc: //call
+				if (opbcCALL(state, frame, script))
+					return true;
+				break;
+			case 0xbd: //focus object
+				opbdFOOB(state, frame);
+				break;
+			case 0xbe: //swap objects
+				opbeSWOB(state, frame);
+				break;
+			case 0xbf: //snap object
+				opbfSNOB(state, frame);
+				break;
+			case 0xc0: //toggle exits
+				opc0TEXI(state, frame);
+				break;
+			case 0xc1: //print text
+				opc1PTXT(state, frame);
+				break;
+			case 0xc2: //print newline
+				opc2PNEW(state, frame);
+				break;
+			case 0xc3: //print text+nl
+				opc3PTNE(state, frame);
+				break;
+			case 0xc4: //print nl+text+nl
+				opc4PNTN(state, frame);
+				break;
+			case 0xc5: //print number
+				opc5PNUM(state, frame);
+				break;
+			case 0xc6: //push 2
+				opc6P2(state, frame);
+				break;
+			case 0xc7: //play sound in background
+				opc7PLBG(state, frame);
+				break;
+			case 0xc8: //play sound and wait
+				opc8PLAW(state, frame);
+				break;
+			case 0xc9: //wait for sound to finish?
+				opc9WAIT(state, frame);
+				break;
+			case 0xca: //get current time
+				opcaTIME(state, frame);
+				break;
+			case 0xcb: //get current day
+				opcbDAY(state, frame);
+				break;
+			case 0xcc: //get children
+				opccCHLD(state, frame);
+				break;
+			case 0xcd: //get num children
+				opcdNCHLD(state, frame);
+				break;
+			case 0xce: //get engine version
+				opceVERS(state, frame);
+				break;
+			case 0xcf: //push scenario number
+				opcfPSCE(state, frame);
+				break;
+			case 0xd0: //push 1
+				opd0P1(state, frame);
+				break;
+			case 0xd1: //get object dimensions
+				opd1GOBD(state, frame);
+				break;
+			case 0xd2: //get overlap percent
+				opd2GOVP(state, frame);
+				break;
+			case 0xd3: //capture children
+				opd3CAPC(state, frame);
+				break;
+			case 0xd4: //release children
+				opd4RELC(state, frame);
+				break;
+			case 0xd5: //show speech dialog
+				opd5DLOG(state, frame);
+				return true;
+			case 0xd6: //activate command
+				opd6ACMD(state, frame);
+				break;
+			case 0xd7: //lose game
+				opd7LOSE(state, frame);
+				break;
+			case 0xd8: //win game
+				opd8WIN(state, frame);
+				break;
+			case 0xd9: //sleep
+				opd9SLEEP(state, frame);
+				return true;
+			case 0xda: //click to continue
+				opdaCLICK(state, frame);
+				return true;
+			case 0xdb: //run queue
+				opdbROBQ(state, frame);
+				break;
+			case 0xdc: //run sound queue
+				opdcRSQ(state, frame);
+				break;
+			case 0xdd: //run text queue
+				opddRTQ(state, frame);
+				break;
+			case 0xde: //update screen
+				opdeUPSC(state, frame);
+				break;
+			case 0xdf: //flash main window
+				opdfFMAI(state, frame);
+				return true;
+			case 0xe0: //cache graphic and object
+				ope0CHGR(state, frame);
+				break;
+			case 0xe1: //cache sound
+				ope1CHSO(state, frame);
+				break;
+			case 0xe2: //muldiv
+				ope2MDIV(state, frame);
+				break;
+			case 0xe3: //update object
+				ope3UPOB(state, frame);
+				break;
+			case 0xe4: //currently playing event?
+				ope4PLEV(state, frame);
+				break;
+			case 0xe5: //wait for event to finish
+				ope5WEV(state, frame);
+				break;
+			case 0xe6: //get fibonacci (joke)
+				ope6GFIB(state, frame);
+				break;
+			case 0xe7: //calc fibonacci
+				ope7CFIB(state, frame);
+				break;
+			default:
+				op00NOOP(op);
+			}
+		}
+	}
+	return false;
+}
+
+int16 ScriptEngine::neg16(int16 val) {
+	if (val & 0x8000)
+		val = -((val ^ 0xFFFF) + 1);
+	return val;
+}
+
+int16 ScriptEngine::neg8(int16 val) {
+	if (val & 0x80)
+		val = -((val ^ 0xff) + 1);
+	return val;
+}
+
+int16 ScriptEngine::sumChildrenAttr(int16 obj, int16 attr, bool recursive) {
+	int16 sum = 0;
+	Common::Array<ObjID> children = _world->getChildren(obj, recursive);
+	for (Common::Array<ObjID>::const_iterator it = children.begin(); it != children.end(); it++) {
+		sum += _world->getObjAttr(*it, attr);
+	}
+	return sum;
+}
+
+void ScriptEngine::ensureNonzeroDivisor(int16 divisor, byte opcode) {
+	// TODO Untested, since that occassion rarely comes up.
+	if (divisor == 0) {
+		error("SCRIPT: Attempt to divide by 0 in operation %x", opcode);
+	}
+}
+
+void MacVenture::ScriptEngine::op80GATT(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	int16 attr = state->pop();
+	state->push(_world->getObjAttr(obj, attr));
+}
+
+void ScriptEngine::op81SATT(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	int16 attr = state->pop();
+	int16 val = neg16(state->pop());
+	_world->setObjAttr(obj, attr, val);
+}
+
+void ScriptEngine::op82SUCH(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	int16 attr = state->pop();
+	int16 recursive = neg16(state->pop());
+	state->push(sumChildrenAttr(obj, attr, recursive));
+}
+
+void ScriptEngine::op83PUCT(EngineState *state, EngineFrame *frame) {
+	state->push(frame->action);
+}
+
+void ScriptEngine::op84PUOB(EngineState *state, EngineFrame *frame) {
+	state->push(frame->src);
+}
+
+void ScriptEngine::op85PUTA(EngineState *state, EngineFrame *frame) {
+	state->push(frame->dest);
+}
+
+void ScriptEngine::op86PUDX(EngineState *state, EngineFrame *frame) {
+	state->push(frame->x);
+}
+
+void ScriptEngine::op87PUDY(EngineState *state, EngineFrame *frame) {
+	state->push(frame->y);
+}
+
+void ScriptEngine::op88PUIB(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	state->push(script->fetch());
+}
+
+void ScriptEngine::op89PUI(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val <<= 8;
+	val = val | script->fetch();
+	state->push(val);
+}
+
+void ScriptEngine::op8aGGLO(EngineState *state, EngineFrame *frame) {
+	int16 idx = state->pop();
+	state->push(_world->getGlobal(idx));
+}
+
+void ScriptEngine::op8bSGLO(EngineState *state, EngineFrame *frame) {
+	int16 idx = state->pop();
+	int16 val = neg16(state->pop());
+	_world->setGlobal(idx, val);
+	_engine->gameChanged();
+}
+
+void ScriptEngine::op8cRAND(EngineState *state, EngineFrame *frame) {
+	int16 max = state->pop();
+	state->push(_engine->randBetween(0, max));
+}
+
+void ScriptEngine::op8dCOPY(EngineState *state, EngineFrame *frame) {
+	int16 val = state->pop();
+	state->push(val);
+	state->push(val);
+}
+
+void ScriptEngine::op8eCOPYN(EngineState *state, EngineFrame *frame) {
+	int16 n = state->pop();
+	int16 offs = n - 1;
+	int16 val;
+	while (n) {
+		val = state->peek(offs);
+		state->push(val);
+		n--;
+	}
+}
+
+void ScriptEngine::op8fSWAP(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(b);
+	state->push(a);
+}
+
+void ScriptEngine::op90SWAPN(EngineState *state, EngineFrame *frame) {
+	int16 idx = state->pop();
+	int16 a = state->peek(idx);
+	int16 b = state->peek(0);
+	state->poke(idx, b);
+	state->poke(0, a);
+}
+
+void ScriptEngine::op91POP(EngineState *state, EngineFrame *frame) {
+	state->pop();
+}
+
+void ScriptEngine::op92COPYP(EngineState *state, EngineFrame *frame) {
+	int16 val = state->peek(1);
+	state->push(val);
+}
+
+void ScriptEngine::op93COPYPN(EngineState *state, EngineFrame *frame) {
+	int16 idx = state->pop();
+	int16 val = state->peek(idx);
+	state->push(val);
+}
+
+void ScriptEngine::op94SHUFF(EngineState *state, EngineFrame *frame) {
+	int16 a = state->pop();
+	int16 b = state->pop();
+	int16 c = state->pop();
+	state->push(a);
+	state->push(c);
+	state->push(b);
+}
+
+void ScriptEngine::op95SORT(EngineState *state, EngineFrame *frame) {
+	int16 step = neg16(state->pop());
+	int16 num = neg16(state->pop());
+	step %= num;
+	if (step < 0) {
+		step += num;
+	}
+	int16 end = 0;
+	int16 start = 0;
+	for (int16 i = 1; i < num; i++) {
+		start += step;
+		if (start >= num) {
+			start -= num;
+		}
+		if (start == end) {
+			end++;
+			start = end;
+		} else {
+			int16 a = state->peek(end);
+			int16 b = state->peek(start);
+			state->poke(end, b);
+			state->poke(start, a);
+		}
+	}
+}
+
+void ScriptEngine::op96CLEAR(EngineState *state, EngineFrame *frame) {
+	state->clear();
+}
+
+void ScriptEngine::op97SIZE(EngineState *state, EngineFrame *frame) {
+	state->push(state->size());
+}
+
+void ScriptEngine::op98ADD(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a + b);
+}
+
+void ScriptEngine::op99SUB(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a - b);
+}
+
+void ScriptEngine::op9aMUL(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a * b);
+}
+
+void ScriptEngine::op9bDIV(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	ensureNonzeroDivisor(b, 0x9b);
+	state->push(a / b);
+}
+
+void ScriptEngine::op9cMOD(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a % b);
+}
+
+void ScriptEngine::op9dDMOD(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	ensureNonzeroDivisor(b, 0x9d);
+	state->push(a % b);
+	state->push(a / b);
+}
+
+void ScriptEngine::op9eABS(EngineState *state, EngineFrame *frame) {
+	int16 val = neg16(state->pop());
+	if (val < 0) {
+		val = -val;
+	}
+	state->push(val);
+}
+
+void ScriptEngine::op9fNEG(EngineState *state, EngineFrame *frame) {
+	int16 val = -neg16(state->pop());
+	state->push(val);
+}
+
+void ScriptEngine::opa0AND(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a & b);
+}
+
+void ScriptEngine::opa1OR(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a | b);
+}
+
+void ScriptEngine::opa2XOR(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(a ^ b);
+}
+
+void ScriptEngine::opa3NOT(EngineState *state, EngineFrame *frame) {
+	int16 a = state->pop();
+	state->push(a ^ 0xFFFF);
+}
+
+void ScriptEngine::opa4LAND(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push((a && b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opa5LOR(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push((a || b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opa6LXOR(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push((!a != !b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opa7LNOT(EngineState *state, EngineFrame *frame) {
+	int16 a = state->pop();
+	state->push((a == 0) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opa8GTU(EngineState *state, EngineFrame *frame) {
+	uint16 b = state->pop();
+	uint16 a = state->pop();
+	state->push((a > b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opa9LTU(EngineState *state, EngineFrame *frame) {
+	uint16 b = state->pop();
+	uint16 a = state->pop();
+	state->push((a < b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opaaGTS(EngineState *state, EngineFrame *frame) {
+	// HACK !!! May not need the neg16, since it's already a signed int!!
+	int16 b = neg16(state->pop());
+	int16 a = neg16(state->pop());
+	state->push((a > b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opabLTS(EngineState *state, EngineFrame *frame) {
+	// HACK !!! May not need the neg16, since it's already a signed int!!
+	int16 b = neg16(state->pop());
+	int16 a = neg16(state->pop());
+	state->push((a < b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opacEQ(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push((a == b) ? 0xFFFF : 0);
+}
+
+void ScriptEngine::opadEQS(EngineState *state, EngineFrame *frame) {
+	Common::String b = _world->getText(state->pop(), 0, 0); // HACK, these destinations might be wrong
+	Common::String a = _world->getText(state->pop(), 0, 0);
+	state->push((a == b) ? 1 : 0);
+}
+
+void ScriptEngine::opaeCONT(EngineState *state, EngineFrame *frame) {
+	Common::String needle = _world->getText(state->pop(), 0, 0);
+	Common::String haystack = _world->getText(state->pop(), 0, 0);
+	haystack.toLowercase();
+	state->push(haystack.contains(needle) ? 1 : 0);
+}
+
+void ScriptEngine::opafCONTW(EngineState *state, EngineFrame *frame) {
+	Common::String needle = _world->getText(state->pop(), 0, 0);
+	Common::String haystack = _world->getText(state->pop(), 0, 0);
+	haystack.toLowercase();
+	state->push(haystack.contains(needle) ? 1 : 0);
+}
+
+void ScriptEngine::opb0BRA(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val <<= 8;
+	val = val | script->fetch();
+	val = neg16(val);
+	script->branch(val);
+}
+
+void ScriptEngine::opb1BRAB(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val = neg8(val);
+	script->branch(val);
+}
+
+void ScriptEngine::opb2BEQ(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val <<= 8;
+	val = val | script->fetch();
+	val = neg16(val);
+	int16 b = state->pop();
+	if (b != 0) {
+		script->branch(val);
+	}
+}
+
+void ScriptEngine::opb3BEQB(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val = neg8(val);
+	int16 b = state->pop();
+	if (b != 0) {
+		script->branch(val);
+	}
+}
+
+void ScriptEngine::opb4BNE(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val <<= 8;
+	val = val | script->fetch();
+	val = neg16(val);
+	int16 b = state->pop();
+	if (b == 0) {
+		script->branch(val);
+	}
+}
+
+void ScriptEngine::opb5BNEB(EngineState *state, EngineFrame *frame, ScriptAsset *script) {
+	int16 val = script->fetch();
+	val = neg8(val);
+	int16 b = state->pop();
+	if (b == 0) {
+		script->branch(val);
+	}
+}
+
+void ScriptEngine::opb6CLAT(EngineState *state, EngineFrame *frame) {
+	int16 rank = state->pop();
+	int16 func = state->pop();
+	frame->saves.push_back(FunCall(func, rank));
+}
+
+void ScriptEngine::opb7CCA(EngineState *state, EngineFrame *frame) {
+	int16 func = state->pop();
+	for (uint i = 0; i < frame->saves.size(); i++) {
+		if (frame->saves[i].func == func)
+			frame->saves[i].rank = 0;
+	}
+}
+
+void ScriptEngine::opb8CLOW(EngineState *state, EngineFrame *frame) {
+	int16 hi = state->pop();
+	for (uint i = 0; i < frame->saves.size(); i++)
+		if (frame->saves[i].rank <= hi)
+			frame->saves[i].rank = 0;
+}
+
+void ScriptEngine::opb9CHI(EngineState *state, EngineFrame *frame) {
+	int16 lo = state->pop();
+	for (uint i = 0; i < frame->saves.size(); i++) {
+		if (frame->saves[i].rank >= lo) {
+			frame->saves[i].rank = 0;
+		}
+	}
+}
+
+void ScriptEngine::opbaCRAN(EngineState *state, EngineFrame *frame) {
+	int16 hi = state->pop();
+	int16 lo = state->pop();
+	for (uint i = 0; i < frame->saves.size(); i++) {
+		if (frame->saves[i].rank >= lo &&
+			frame->saves[i].rank <= hi) {
+			frame->saves[i].rank = 0;
+		}
+	}
+}
+
+bool ScriptEngine::opbbFORK(EngineState *state, EngineFrame *frame) {
+	EngineFrame newframe;
+	newframe.action = (ControlAction)state->pop();
+	newframe.src = state->pop();
+	newframe.dest = state->pop();
+	newframe.x = state->pop();
+	newframe.y = state->pop();
+	newframe.haltedInFamily = false;
+	newframe.haltedInFirst = false;
+	newframe.haltedInSaves = false;
+	_frames.push_front(newframe);
+	if (execFrame(true)) {
+		return true;
+	}
+	return false;
+}
+
+bool ScriptEngine::opbcCALL(EngineState *state, EngineFrame *frame, ScriptAsset &script) {
+	int16 id = state->pop();
+	ScriptAsset newfun = ScriptAsset(id, _scripts);
+	ScriptAsset current = script;
+	debugC(2, kMVDebugScript, "Call function: %d", id);
+	if (loadScript(frame, id))
+		return true;
+	frame->scripts.pop_front();
+	script = frame->scripts.front();
+	debugC(2, kMVDebugScript, "Return from fuction %d", id);
+	return false;
+}
+
+void ScriptEngine::opbdFOOB(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	_engine->enqueueObject(kFocusWindow, obj);
+}
+
+void ScriptEngine::opbeSWOB(EngineState *state, EngineFrame *frame) {
+	ObjID from = state->pop();
+	ObjID to = state->pop();
+	_engine->enqueueObject(kUpdateWindow, from, to);
+	_world->setObjAttr(to, kAttrContainerOpen, _world->getObjAttr(from, 6));
+	_world->setObjAttr(from, kAttrContainerOpen, 0);
+	Common::Array<ObjID> children = _world->getChildren(from, true);
+	for (uint i = 0; i < children.size(); i++) {
+		_world->setObjAttr(children[i], 0, to);
+	}
+}
+
+void ScriptEngine::opbfSNOB(EngineState *state, EngineFrame *frame) {
+	_engine->enqueueObject(kAnimateBack, frame->src);
+}
+
+void ScriptEngine::opc0TEXI(EngineState *state, EngineFrame *frame) {
+	_engine->enqueueObject(kHightlightExits, 0);
+}
+
+void ScriptEngine::opc1PTXT(EngineState *state, EngineFrame *frame) {
+	int16 tid = state->pop();
+	_engine->enqueueText(kTextPlain, frame->dest, frame->src, tid);
+}
+
+void ScriptEngine::opc2PNEW(EngineState *state, EngineFrame *frame) {
+	_engine->enqueueText(kTextNewLine, frame->dest, frame->src, 0);
+}
+
+void ScriptEngine::opc3PTNE(EngineState *state, EngineFrame *frame) {
+	int16 tid = state->pop();
+	_engine->enqueueText(kTextPlain, frame->dest, frame->src, tid);
+	_engine->enqueueText(kTextNewLine, frame->dest, frame->src, 0);
+}
+
+void ScriptEngine::opc4PNTN(EngineState *state, EngineFrame *frame) {
+	int16 tid = state->pop();
+	_engine->enqueueText(kTextNewLine, frame->dest, frame->src, 0);
+	_engine->enqueueText(kTextPlain, frame->dest, frame->src, tid);
+	_engine->enqueueText(kTextNewLine, frame->dest, frame->src, 0);
+}
+
+void ScriptEngine::opc5PNUM(EngineState *state, EngineFrame *frame) {
+	int16 tid = state->pop();
+	_engine->enqueueText(kTextNumber, frame->dest, frame->src, tid);
+}
+
+void ScriptEngine::opc6P2(EngineState *state, EngineFrame *frame) {
+	state->push(2);
+}
+
+void ScriptEngine::opc7PLBG(EngineState *state, EngineFrame *frame) {
+	int16 target = state->pop();
+	_engine->enqueueSound(kSoundPlay, target);
+}
+
+void ScriptEngine::opc8PLAW(EngineState *state, EngineFrame *frame) {
+	int16 target = state->pop();
+	_engine->enqueueSound(kSoundPlayAndWait, target);
+}
+
+void ScriptEngine::opc9WAIT(EngineState *state, EngineFrame *frame) {
+	_engine->enqueueSound(kSoundWait, 0);
+}
+
+void ScriptEngine::opcaTIME(EngineState *state, EngineFrame *frame) {
+	for (uint i = 0; i < 3; i++) {// We skip year, month and date
+		state->push(0x00);
+	}
+
+	uint32 totalPlayTime = _engine->getTotalPlayTime() / 1000; // In seconds
+	int16 hours = totalPlayTime / 3600;
+	totalPlayTime %= 3600;
+	state->push(hours);
+	int16 minutes = totalPlayTime / 60;
+	totalPlayTime %= 60;
+	state->push(minutes);
+	state->push(totalPlayTime);
+	debugC(2, kMVDebugScript, "Saved time: h[%d] m[%d] s[%d]", hours, minutes, totalPlayTime);
+}
+
+void ScriptEngine::opcbDAY(EngineState *state, EngineFrame *frame) {
+	// Probaby irrelevant, so we push Day [9]
+	state->push(9);
+}
+
+void ScriptEngine::opccCHLD(EngineState *state, EngineFrame *frame) {
+	bool recursive = state->pop() != 0;
+	int16 obj = state->pop();
+	Common::Array<ObjID> children = _world->getChildren(obj, recursive);
+	for (Common::Array<ObjID>::const_iterator it = children.begin(); it != children.end(); it++) {
+		state->push(*it);
+	}
+	state->push(children.size());
+}
+
+void ScriptEngine::opcdNCHLD(EngineState *state, EngineFrame *frame) {
+	bool recursive = state->pop() != 0;
+	int16 obj = state->pop();
+	Common::Array<ObjID> children = _world->getChildren(obj, recursive);
+	state->push(children.size());
+}
+
+void ScriptEngine::opceVERS(EngineState *state, EngineFrame *frame) {
+	state->push(86); // Engine version is irrelevant. Like this in the original.
+}
+
+void ScriptEngine::opcfPSCE(EngineState *state, EngineFrame *frame) {
+	state->push(0); // Any value greater than 0 indicates "Release".
+}
+
+void ScriptEngine::opd0P1(EngineState *state, EngineFrame *frame) {
+	state->push(1);
+}
+
+void ScriptEngine::opd1GOBD(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	Common::Rect bounds = _engine->getObjBounds(obj);
+	state->push(bounds.width());
+	state->push(bounds.height());
+}
+
+void ScriptEngine::opd2GOVP(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	state->push(_engine->getOverlapPercent(b, a));
+}
+
+void ScriptEngine::opd3CAPC(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	_world->captureChildren(obj);
+}
+
+void ScriptEngine::opd4RELC(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	_world->releaseChildren(obj);
+}
+
+void ScriptEngine::opd5DLOG(EngineState *state, EngineFrame *frame) {
+	int16 txt = state->pop();
+	if (_engine->showTextEntry(txt, frame->src, frame->dest)) {
+		state->push(0xFF);
+	} else {
+		state->push(0x00);
+	}
+}
+
+void ScriptEngine::opd6ACMD(EngineState *state, EngineFrame *frame) {
+	_engine->selectControl((ControlAction)state->pop());
+}
+
+void ScriptEngine::opd7LOSE(EngineState *state, EngineFrame *frame) {
+	_engine->loseGame();
+}
+
+void ScriptEngine::opd8WIN(EngineState *state, EngineFrame *frame) {
+	_engine->winGame();
+}
+
+void ScriptEngine::opd9SLEEP(EngineState *state, EngineFrame *frame) {
+	int16 ticks = state->pop();
+	g_system->delayMillis((ticks / 60) * 1000);
+	_engine->preparedToRun();
+}
+
+void ScriptEngine::opdaCLICK(EngineState *state, EngineFrame *frame) {
+	_engine->updateState(false);
+	_engine->clickToContinue();
+}
+
+void ScriptEngine::opdbROBQ(EngineState *state, EngineFrame *frame) {
+	_engine->runObjQueue();
+}
+
+void ScriptEngine::opdcRSQ(EngineState *state, EngineFrame *frame) {
+	_engine->playSounds(true);
+}
+
+void ScriptEngine::opddRTQ(EngineState *state, EngineFrame *frame) {
+	_engine->printTexts();
+}
+
+void ScriptEngine::opdeUPSC(EngineState *state, EngineFrame *frame) {
+	_engine->updateState(true);
+}
+
+void ScriptEngine::opdfFMAI(EngineState *state, EngineFrame *frame) {
+	int16 ticks = state->pop();
+	g_system->delayMillis((ticks / 60) * 1000);
+	_engine->revert();
+}
+
+void ScriptEngine::ope0CHGR(EngineState *state, EngineFrame *frame) {
+	state->pop();
+}
+
+void ScriptEngine::ope1CHSO(EngineState *state, EngineFrame *frame) {
+	state->pop();
+}
+
+void ScriptEngine::ope2MDIV(EngineState *state, EngineFrame *frame) {
+	int16 b = state->pop();
+	int16 a = state->pop();
+	a *= b;
+	int16 c = state->pop();
+	ensureNonzeroDivisor(c, 0xe2);
+	a /= c;
+	state->push(a);
+}
+
+void ScriptEngine::ope3UPOB(EngineState *state, EngineFrame *frame) {
+	int16 obj = state->pop();
+	_world->updateObj(obj);
+}
+
+void ScriptEngine::ope4PLEV(EngineState *state, EngineFrame *frame) {
+	state->push(0);
+}
+
+void ScriptEngine::ope5WEV(EngineState *state, EngineFrame *frame) {
+	op00NOOP(0xe5);
+}
+
+void ScriptEngine::ope6GFIB(EngineState *state, EngineFrame *frame) {
+	state->push(0);
+	op00NOOP(0xe6);
+}
+
+void ScriptEngine::ope7CFIB(EngineState *state, EngineFrame *frame) {
+	state->pop();
+	op00NOOP(0xe7);
+}
+
+void ScriptEngine::op00NOOP(byte op) {
+	warning("SCRIPT: Opcode not implemented => %x", op);
+}
+
+
+
+ScriptAsset::ScriptAsset(ObjID id, Container *container) {
+	_id = id;
+	_container = container;
+	_ip = 0x0;
+	loadInstructions();
+}
+
+void ScriptAsset::reset() {
+	_ip = 0x0;
+}
+
+uint8 ScriptAsset::fetch() {
+	uint8 ins = _instructions[_ip];
+	_ip++;
+	return ins;
+}
+
+bool ScriptAsset::hasNext() {
+	return _ip < _instructions.size();
+}
+
+void ScriptAsset::branch(int16 amount) {
+	_ip += amount;
+}
+
+ObjID ScriptAsset::getId() {
+	return _id;
+}
+
+void ScriptAsset::loadInstructions() {
+	uint32 amount = _container->getItemByteSize(_id);
+	Common::SeekableReadStream *res = _container->getItem(_id);
+	for (uint i = 0; i < amount; i++) {
+		_instructions.push_back(res->readByte());
+	}
+	delete res;
+	debugC(2, kMVDebugScript, "Load %d instructions for script %d", amount, _id);
+}
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/script.h b/engines/macventure/script.h
new file mode 100644
index 0000000000..0e81e41168
--- /dev/null
+++ b/engines/macventure/script.h
@@ -0,0 +1,285 @@
+/* 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 MACVENTURE_SCRIPT_H
+#define MACVENTURE_SCRIPT_H
+
+#include "macventure/container.h"
+#include "macventure/world.h"
+#include "macventure/macventure.h"
+#include "macventure/controls.h"
+
+namespace MacVenture {
+
+class Container;
+class World;
+
+typedef uint32 ObjID;
+
+class ScriptAsset {
+public:
+	ScriptAsset(ObjID id, Container *container);
+	~ScriptAsset() {}
+
+	void reset();
+	uint8 fetch();
+	bool hasNext();
+	void branch(int16 amount);
+
+	ObjID getId();
+
+private:
+
+	void loadInstructions();
+
+private:
+	ObjID _id;
+	Container *_container;
+
+	Common::Array<uint8> _instructions;
+	uint32 _ip; // Instruction pointer
+};
+
+class EngineState {
+public:
+	EngineState() {
+		clear();
+	}
+
+	void push(int16 data) {
+		sp--;
+		stack[sp] = unneg16(data);
+	}
+
+	int16 pop() {
+		int16 v = stack[sp];
+		sp++;
+		return v;
+	}
+
+	int16 peek(int16 off) {
+		return stack[sp + off];
+	}
+
+	void poke(int16 off, int16 val) {
+		stack[sp + off] = unneg16(val);
+	}
+
+	void clear() {
+		sp = 0x80;
+		for (int i = 0; i < sp; i++) {
+			stack[i] = 0;
+		}
+	}
+
+	int16 size() {
+		return 0x80 - sp;
+	}
+
+private:
+	int16 unneg16(int16 data) {
+		if (data < 0)
+			data = ((-data) ^ 0xFFFF) + 1;
+
+		return data;
+	}
+
+private:
+
+	int16 stack[0x80];
+	int16 sp;
+};
+
+struct FunCall {
+	int16 func;
+	int16 rank;
+
+	FunCall(int16 f, int16 r) {
+		func = f;
+		rank = r;
+	}
+};
+
+struct EngineFrame {
+	ControlAction action;
+	ObjID src;
+	ObjID dest;
+	int x;
+	int y;
+	EngineState state;
+	Common::List<ScriptAsset> scripts;
+	Common::Array<FunCall> saves;
+	uint32 familyIdx;
+
+	bool haltedInFirst;
+	bool haltedInFamily;
+	bool haltedInSaves;
+};
+
+class ScriptEngine {
+public:
+	ScriptEngine(MacVentureEngine *engine, World *world);
+	~ScriptEngine();
+
+public:
+	bool runControl(ControlAction action, ObjID source, ObjID destination, Common::Point delta);
+	bool resume(bool execAll);
+	void reset();
+
+private:
+	bool execFrame(bool execAll);
+	bool loadScript(EngineFrame *frame, uint32 scriptID);
+	bool resumeFunc(EngineFrame *frame);
+	bool runFunc(EngineFrame *frame);
+
+private:
+
+	// Aux
+	int16 neg16(int16 val);
+	int16 neg8(int16 val);
+	int16 sumChildrenAttr(int16 obj, int16 attr, bool recursive);
+	void ensureNonzeroDivisor(int16 divisor, byte opcode);
+
+	// Opcodes
+	void op80GATT(EngineState *state, EngineFrame *frame);	//get attribute
+	void op81SATT(EngineState *state, EngineFrame *frame);	//set attribute
+	void op82SUCH(EngineState *state, EngineFrame *frame);	//sum children attribute
+	void op83PUCT(EngineState *state, EngineFrame *frame);	//push selected control
+	void op84PUOB(EngineState *state, EngineFrame *frame);	//push selected object
+	void op85PUTA(EngineState *state, EngineFrame *frame);	//push target
+	void op86PUDX(EngineState *state, EngineFrame *frame);	//push deltax
+	void op87PUDY(EngineState *state, EngineFrame *frame);	//push deltay
+	void op88PUIB(EngineState *state, EngineFrame *frame, ScriptAsset *script);//push immediate.b
+	void op89PUI(EngineState *state, EngineFrame *frame, ScriptAsset *script);//push immediate
+	void op8aGGLO(EngineState *state, EngineFrame *frame);	//get global
+	void op8bSGLO(EngineState *state, EngineFrame *frame);	//set global
+	void op8cRAND(EngineState *state, EngineFrame *frame);	//random
+	void op8dCOPY(EngineState *state, EngineFrame *frame);	//copy
+	void op8eCOPYN(EngineState *state, EngineFrame *frame);	//copyn
+	void op8fSWAP(EngineState *state, EngineFrame *frame);	//swap
+
+	void op90SWAPN(EngineState *state, EngineFrame *frame);	//swapn
+	void op91POP(EngineState *state, EngineFrame *frame);	//pop
+	void op92COPYP(EngineState *state, EngineFrame *frame);	//copy+1
+	void op93COPYPN(EngineState *state, EngineFrame *frame);//copy+n
+	void op94SHUFF(EngineState *state, EngineFrame *frame);	//shuffle
+	void op95SORT(EngineState *state, EngineFrame *frame);	//sort
+	void op96CLEAR(EngineState *state, EngineFrame *frame);	//clear stack
+	void op97SIZE(EngineState *state, EngineFrame *frame);	//get stack size
+	void op98ADD(EngineState *state, EngineFrame *frame);	//add
+	void op99SUB(EngineState *state, EngineFrame *frame);	//subtract
+	void op9aMUL(EngineState *state, EngineFrame *frame);	//multiply
+	void op9bDIV(EngineState *state, EngineFrame *frame);	//divide
+	void op9cMOD(EngineState *state, EngineFrame *frame);	//mod
+	void op9dDMOD(EngineState *state, EngineFrame *frame);	//divmod
+	void op9eABS(EngineState *state, EngineFrame *frame);	//abs
+	void op9fNEG(EngineState *state, EngineFrame *frame);	//neg
+
+	void opa0AND(EngineState *state, EngineFrame *frame);	//and
+	void opa1OR(EngineState *state, EngineFrame *frame);	//or
+	void opa2XOR(EngineState *state, EngineFrame *frame);	//xor
+	void opa3NOT(EngineState *state, EngineFrame *frame);	//not
+	void opa4LAND(EngineState *state, EngineFrame *frame);	//logical and
+	void opa5LOR(EngineState *state, EngineFrame *frame);	//logical or
+	void opa6LXOR(EngineState *state, EngineFrame *frame);	//logical xor
+	void opa7LNOT(EngineState *state, EngineFrame *frame);	//logical not
+	void opa8GTU(EngineState *state, EngineFrame *frame);	//gt? unsigned
+	void opa9LTU(EngineState *state, EngineFrame *frame);	//lt? unsigned
+	void opaaGTS(EngineState *state, EngineFrame *frame);	//gt? signed
+	void opabLTS(EngineState *state, EngineFrame *frame);	//lt? signed
+	void opacEQ(EngineState *state, EngineFrame *frame);	//eq?
+	void opadEQS(EngineState *state, EngineFrame *frame);	//eq string?
+	void opaeCONT(EngineState *state, EngineFrame *frame);	//contains
+	void opafCONTW(EngineState *state, EngineFrame *frame); //contains word
+
+	void opb0BRA(EngineState *state, EngineFrame *frame, ScriptAsset *script);	//bra
+	void opb1BRAB(EngineState *state, EngineFrame *frame, ScriptAsset *script);	//bra.b
+	void opb2BEQ(EngineState *state, EngineFrame *frame, ScriptAsset *script);	//beq
+	void opb3BEQB(EngineState *state, EngineFrame *frame, ScriptAsset *script); //beq.b
+	void opb4BNE(EngineState *state, EngineFrame *frame, ScriptAsset *script);	//bne
+	void opb5BNEB(EngineState *state, EngineFrame *frame, ScriptAsset *script);	//bne.b
+	void opb6CLAT(EngineState *state, EngineFrame *frame);	//call later
+	void opb7CCA(EngineState *state, EngineFrame *frame);	//cancel call
+	void opb8CLOW(EngineState *state, EngineFrame *frame);	//cancel low priority
+	void opb9CHI(EngineState *state, EngineFrame *frame);	//cancel high priority
+	void opbaCRAN(EngineState *state, EngineFrame *frame);	//cancel priority range
+	bool opbbFORK(EngineState *state, EngineFrame *frame);	//fork
+	bool opbcCALL(EngineState *state, EngineFrame *frame, ScriptAsset &script);	//call
+	void opbdFOOB(EngineState *state, EngineFrame *frame);	//focus object
+	void opbeSWOB(EngineState *state, EngineFrame *frame);	//swap objects
+	void opbfSNOB(EngineState *state, EngineFrame *frame);	//snap object
+
+	void opc0TEXI(EngineState *state, EngineFrame *frame);	//toggle exits
+	void opc1PTXT(EngineState *state, EngineFrame *frame);	//print text
+	void opc2PNEW(EngineState *state, EngineFrame *frame);	//print newline
+	void opc3PTNE(EngineState *state, EngineFrame *frame);	//print text+nl
+	void opc4PNTN(EngineState *state, EngineFrame *frame);	//print nl+text+nl
+	void opc5PNUM(EngineState *state, EngineFrame *frame);	//print number
+	void opc6P2(EngineState *state, EngineFrame *frame);	//push 2
+	void opc7PLBG(EngineState *state, EngineFrame *frame);	//play sound in background
+	void opc8PLAW(EngineState *state, EngineFrame *frame);	//play sound and wait
+	void opc9WAIT(EngineState *state, EngineFrame *frame);	//wait for sound to finish?
+	void opcaTIME(EngineState *state, EngineFrame *frame);	//get current time
+	void opcbDAY(EngineState *state, EngineFrame *frame);	//get current day
+	void opccCHLD(EngineState *state, EngineFrame *frame);	//get children
+	void opcdNCHLD(EngineState *state, EngineFrame *frame); //get num children
+	void opceVERS(EngineState *state, EngineFrame *frame);	//get engine version
+	void opcfPSCE(EngineState *state, EngineFrame *frame);	//push scenario number
+
+	void opd0P1(EngineState *state, EngineFrame *frame);	//push 1
+	void opd1GOBD(EngineState *state, EngineFrame *frame);	//get object dimensions
+	void opd2GOVP(EngineState *state, EngineFrame *frame);	//get overlap percent
+	void opd3CAPC(EngineState *state, EngineFrame *frame);	//capture children
+	void opd4RELC(EngineState *state, EngineFrame *frame);	//release children
+	void opd5DLOG(EngineState *state, EngineFrame *frame);	//show speech dialog
+	void opd6ACMD(EngineState *state, EngineFrame *frame);	//activate command
+	void opd7LOSE(EngineState *state, EngineFrame *frame);	//lose game
+	void opd8WIN(EngineState *state, EngineFrame *frame);	//win game
+	void opd9SLEEP(EngineState *state, EngineFrame *frame);	//sleep
+	void opdaCLICK(EngineState *state, EngineFrame *frame);	//click to continue
+	void opdbROBQ(EngineState *state, EngineFrame *frame);	//run queue
+	void opdcRSQ(EngineState *state, EngineFrame *frame);	//run sound queue
+	void opddRTQ(EngineState *state, EngineFrame *frame);	//run text queue
+	void opdeUPSC(EngineState *state, EngineFrame *frame);	//update screen
+	void opdfFMAI(EngineState *state, EngineFrame *frame);	//flash main window
+
+	void ope0CHGR(EngineState *state, EngineFrame *frame);	//cache graphic and object
+	void ope1CHSO(EngineState *state, EngineFrame *frame);	//cache sound
+	void ope2MDIV(EngineState *state, EngineFrame *frame);	//muldiv
+	void ope3UPOB(EngineState *state, EngineFrame *frame);	//update object
+	void ope4PLEV(EngineState *state, EngineFrame *frame);	//currently playing event?
+	void ope5WEV(EngineState *state, EngineFrame *frame);	//wait for event to finish
+	void ope6GFIB(EngineState *state, EngineFrame *frame);	//get fibonacci (joke)
+	void ope7CFIB(EngineState *state, EngineFrame *frame);	//calc fibonacci
+
+	void op00NOOP(byte op);
+
+private:
+	MacVentureEngine *_engine;
+	World *_world;
+	Common::List<EngineFrame> _frames;
+	Container *_scripts;
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/sound.cpp b/engines/macventure/sound.cpp
new file mode 100644
index 0000000000..422e365790
--- /dev/null
+++ b/engines/macventure/sound.cpp
@@ -0,0 +1,282 @@
+/* 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 "macventure/sound.h"
+
+#include "audio/mixer.h"
+#include "audio/audiostream.h"
+#include "audio/decoders/raw.h"
+
+namespace MacVenture {
+
+// SoundManager
+SoundManager::SoundManager(MacVentureEngine *engine, Audio::Mixer *mixer) {
+	_container = NULL;
+	Common::String filename = engine->getFilePath(kSoundPathID);
+	_container = new Container(filename);
+	_mixer = mixer;
+	debugC(1, kMVDebugSound, "Created sound manager with file %s", filename.c_str());
+}
+
+SoundManager::~SoundManager() {
+	if (_container)
+		delete _container;
+
+	Common::HashMap<ObjID, SoundAsset*>::iterator it;
+	Common::HashMap<ObjID, SoundAsset*>::iterator end = _assets.end();
+	for (it = _assets.begin(); it != end; it++) {
+		delete it->_value;
+	}
+}
+
+uint32 SoundManager::playSound(ObjID sound) {
+	ensureLoaded(sound);
+	_assets[sound]->play(_mixer, &_handle);
+	return _assets[sound]->getPlayLength();
+}
+
+void SoundManager::ensureLoaded(ObjID sound) {
+	if (!_assets.contains(sound))
+		_assets[sound] = new SoundAsset(_container, sound);
+}
+
+SoundAsset::SoundAsset(Container *container, ObjID id) :
+	_container(container), _id(id), _length(0), _frequency(1) {
+	if (_container->getItemByteSize(_id) == 0)
+		warning("Trying to load an empty sound asset (%d).", _id);
+
+	Common::SeekableReadStream *stream = _container->getItem(_id);
+
+	stream->seek(5, SEEK_SET);
+	SoundType type = (SoundType)stream->readByte();
+	debugC(2, kMVDebugSound, "Decoding sound of type %x", type);
+	switch(type) {
+	case kSound10:
+		decode10(stream);
+		break;
+	case kSound12:
+		decode12(stream);
+		break;
+	case kSound18:
+		decode18(stream);
+		break;
+	case kSound1a:
+		decode1a(stream);
+		break;
+	case kSound44:
+		decode44(stream);
+		break;
+	case kSound78:
+		decode78(stream);
+		break;
+	case kSound7e:
+		decode7e(stream);
+		break;
+	default:
+		warning("Unrecognized sound type: %x", type);
+		break;
+	}
+
+	delete stream;
+}
+
+SoundAsset::~SoundAsset() {
+	debugC(3, kMVDebugSound, "~SoundAsset(%d)", _id);
+}
+
+void SoundAsset::play(Audio::Mixer *mixer, Audio::SoundHandle *soundHandle) {
+	if (_data.size() == 0) {
+		return;
+	}
+	Audio::AudioStream *sound = Audio::makeRawStream(&_data.front(), _length, _frequency, Audio::FLAG_UNSIGNED, DisposeAfterUse::NO);
+	mixer->playStream(Audio::Mixer::kPlainSoundType, soundHandle, sound);
+}
+
+uint32 SoundAsset::getPlayLength() {
+	// Transform to milliseconds
+	return _length * 1000 / _frequency;
+}
+
+void SoundAsset::decode10(Common::SeekableReadStream *stream) {
+	warning("Decode sound 0x10 untested");
+	Common::Array<byte> wavtable;
+	stream->seek(0x198, SEEK_SET);
+	for (uint i = 0; i < 16; i++) {
+		wavtable.push_back(stream->readByte());
+	}
+	_length = stream->readUint32BE() * 2;
+	//Unused
+	stream->readUint16BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	byte ch = 0;
+	for (uint i = 0; i < _length; i++) {
+		if (i & 1) {
+			ch >>= 4;
+		} else {
+			ch = stream->readByte();
+		}
+		_data.push_back(wavtable[ch & 0xf]);
+	}
+}
+
+void SoundAsset::decode12(Common::SeekableReadStream *stream) {
+	warning("Decode sound 0x12 untested");
+	stream->seek(0xc, SEEK_SET);
+	uint32 repeat = stream->readUint16BE();
+	stream->seek(0x34, SEEK_SET);
+	uint32 base = stream->readUint16BE() + 0x34;
+	stream->seek(base, SEEK_SET);
+	_length = stream->readUint32BE() - 6;
+	stream->readUint16BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	stream->seek(0xe2, SEEK_SET);
+	// TODO: Possible source of bugs, the original just assigns the seek to the scales
+	uint32 scales = stream->pos() + 0xe2;
+	for (uint i = 0; i < repeat; i++) {
+		stream->seek(scales + i * 2, SEEK_SET);
+		uint32 scale = stream->readUint16BE();
+		stream->seek(base + 0xa, SEEK_SET);
+		for (uint j = 0; j < _length; j++) {
+			byte ch = stream->readByte();
+			if (ch & 0x80) {
+				ch -= 0x80;
+				uint32 env = ch * scale;
+				ch = (env >> 8) & 0xff;
+				if (ch & 0x80) {
+					ch = 0x7f;
+				}
+				ch += 0x80;
+			} else {
+				ch = (ch ^ 0xff) + 1;
+				ch -= 0x80;
+				uint32 env = ch * scale;
+				ch = (env >> 8) & 0xff;
+				if (ch & 0x80) {
+					ch = 0x7f;
+				}
+				ch += 0x80;
+				ch = (ch ^ 0xff) + 1;
+			}
+			_data.push_back(ch);
+		}
+	}
+}
+
+void SoundAsset::decode18(Common::SeekableReadStream *stream) {
+	warning("Decode sound 0x18 untested");
+	Common::Array<byte> wavtable;
+	stream->seek(0x252, SEEK_SET);
+	for (uint i = 0; i < 16; i++) {
+		wavtable.push_back(stream->readByte());
+	}
+	_length = stream->readUint32BE() * 2;
+	//Unused
+	stream->readUint16BE();
+	// TODO: It had `| 0` at the end of this line, possible source of bugs.
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	byte ch = 0;
+	for (uint i = 0; i < _length; i++) {
+		if (i & 1) {
+			ch >>= 4;
+		} else {
+			ch = stream->readByte();
+		}
+		_data.push_back(wavtable[ch & 0xf]);
+	}
+}
+
+void SoundAsset::decode1a(Common::SeekableReadStream *stream) {
+	warning("Decode sound 0x1a untested");
+	Common::Array<byte> wavtable;
+	stream->seek(0x220, SEEK_SET);
+	for (uint i = 0; i < 16; i++) {
+		wavtable.push_back(stream->readByte());
+	}
+	_length = stream->readUint32BE();
+	//Unused
+	stream->readUint16BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	byte ch = 0;
+	for (uint i = 0; i < _length; i++) {
+		if (i & 1) {
+			ch >>= 4;
+		} else {
+			ch = stream->readByte();
+		}
+		_data.push_back(wavtable[ch & 0xf]);
+	}
+}
+
+void SoundAsset::decode44(Common::SeekableReadStream *stream) {
+	stream->seek(0x5e, SEEK_SET);
+	_length = stream->readUint32BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	for (uint i = 0; i < _length; i++) {
+		_data.push_back(stream->readByte());
+	}
+}
+
+void SoundAsset::decode78(Common::SeekableReadStream *stream) {
+	Common::Array<byte> wavtable;
+	stream->seek(0xba, SEEK_SET);
+	for (uint i = 0; i < 16; i++) {
+		wavtable.push_back(stream->readByte());
+	}
+	//Unused
+	stream->readUint32BE();
+	_length = stream->readUint32BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	byte ch = 0;
+	for (uint i = 0; i < _length; i++) {
+		if (i & 1) {
+			ch <<= 4;
+		} else {
+			ch = stream->readByte();
+		}
+		_data.push_back(wavtable[(ch >> 4) & 0xf]);
+	}
+}
+
+void SoundAsset::decode7e(Common::SeekableReadStream *stream) {
+	Common::Array<byte> wavtable;
+	stream->seek(0xc2, SEEK_SET);
+	for (uint i = 0; i < 16; i++) {
+		wavtable.push_back(stream->readByte());
+	}
+	//Unused
+	stream->readUint32BE();
+	_length = stream->readUint32BE();
+	_frequency = (stream->readUint32BE() * 22100 / 0x10000);
+	uint32 last = 0x80;
+	byte ch = 0;
+	for (uint i = 0; i < _length; i++) {
+		if (i & 1) {
+			ch <<= 4;
+		} else {
+			ch = stream->readByte();
+		}
+		last += wavtable[(ch >> 4) & 0xf];
+		_data.push_back(last & 0xff);
+	}
+}
+
+} //End of namespace MacVenture
diff --git a/engines/macventure/sound.h b/engines/macventure/sound.h
new file mode 100644
index 0000000000..d1b1bb8a37
--- /dev/null
+++ b/engines/macventure/sound.h
@@ -0,0 +1,95 @@
+/* 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 MACVENTURE_SOUND_H
+#define MACVENTURE_SOUND_H
+
+#include "macventure/macventure.h"
+#include "macventure/container.h"
+
+#include "common/file.h"
+#include "common/hashmap.h"
+
+#include "audio/mixer.h"
+
+namespace MacVenture {
+
+enum SoundType {
+	kSound10 = 0x10,
+	kSound12 = 0x12,
+	kSound18 = 0x18,
+	kSound1a = 0x1a,
+	kSound44 = 0x44,
+	kSound78 = 0x78,
+	kSound7e = 0x7e
+};
+
+class SoundAsset {
+
+public:
+	SoundAsset(Container *container, ObjID id);
+	~SoundAsset();
+
+	void play(Audio::Mixer *mixer, Audio::SoundHandle *soundHandle);
+	uint32 getPlayLength();
+
+private:
+
+	void decode10(Common::SeekableReadStream *stream);
+	void decode12(Common::SeekableReadStream *stream);
+	void decode18(Common::SeekableReadStream *stream);
+	void decode1a(Common::SeekableReadStream *stream);
+	void decode44(Common::SeekableReadStream *stream);
+	void decode78(Common::SeekableReadStream *stream);
+	void decode7e(Common::SeekableReadStream *stream);
+
+private:
+
+	Container *_container;
+	ObjID _id;
+
+	Common::Array<byte> _data;
+	uint32 _length;
+	uint32 _frequency;
+};
+
+class SoundManager {
+public:
+	SoundManager(MacVentureEngine *engine, Audio::Mixer *mixer);
+	~SoundManager();
+
+	uint32 playSound(ObjID sound);
+
+private:
+	void ensureLoaded(ObjID sound);
+
+private:
+
+	Container *_container;
+	Common::HashMap<ObjID, SoundAsset*> _assets;
+	Audio::SoundHandle _handle;
+	Audio::Mixer *_mixer;
+
+};
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/stringtable.h b/engines/macventure/stringtable.h
new file mode 100644
index 0000000000..2f1d671696
--- /dev/null
+++ b/engines/macventure/stringtable.h
@@ -0,0 +1,109 @@
+/* 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 MACVENTURE_STRINGTABLE_H
+#define MACVENTURE_STRINGTABLE_H
+
+#include "macventure/macventure.h"
+
+#include "common/file.h"
+
+namespace MacVenture {
+
+extern void toASCII(Common::String &str);
+
+enum StringTableID {
+	kErrorStringTableID = 0x80,
+	kFilenamesStringTableID = 0x81,
+	kCommonArticlesStringTableID = 0x82,
+	kNamingArticlesStringTableID = 0x83,
+	kIndirectArticlesStringTableID = 0x84
+};
+
+class StringTable {
+public:
+	StringTable(MacVentureEngine *engine, Common::MacResManager *resMan, StringTableID id) {
+		_engine = engine;
+		_resourceManager = resMan;
+		_id = id;
+
+		if (!loadStrings())
+			error("ENGINE: Could not load string table %x", id);
+	}
+
+	~StringTable() {
+
+	}
+
+	const Common::Array<Common::String> &getStrings() {
+		return _strings;
+	}
+
+	Common::String getString(uint ndx) {
+		assert(ndx < _strings.size());
+		return _strings[ndx];
+	}
+
+private:
+
+	bool loadStrings() {
+		Common::MacResIDArray resArray;
+		Common::SeekableReadStream *res;
+
+		if ((resArray = _resourceManager->getResIDArray(MKTAG('S', 'T', 'R', '#'))).size() == 0)
+			return false;
+
+		res = _resourceManager->getResource(MKTAG('S', 'T', 'R', '#'), _id);
+
+		_strings.push_back("dummy"); // String tables are 1-indexed
+		uint16 numStrings = res->readUint16BE();
+		uint8 strLength = 0;
+		for (uint i = 0; i < numStrings; ++i) {
+			strLength = res->readByte();
+			char *str = new char[strLength + 1];
+			res->read(str, strLength);
+			str[strLength] = '\0';
+			// HACK until a proper special char implementation is found, this will have to do.
+			Common::String result = Common::String(str);
+			toASCII(result);
+			debugC(4, kMVDebugText, "Loaded string %s", str);
+			_strings.push_back(Common::String(result));
+			delete[] str;
+		}
+
+		delete res;
+		return true;
+	}
+
+private:
+
+	MacVentureEngine *_engine;
+	Common::MacResManager *_resourceManager;
+
+	StringTableID _id;
+
+	Common::Array<Common::String> _strings;
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/text.cpp b/engines/macventure/text.cpp
new file mode 100644
index 0000000000..6671c28750
--- /dev/null
+++ b/engines/macventure/text.cpp
@@ -0,0 +1,201 @@
+/* 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 "macventure/text.h"
+
+namespace MacVenture {
+TextAsset::TextAsset(MacVentureEngine *engine, ObjID objid, ObjID source, ObjID target, Container *container, bool isOld, const HuffmanLists *huffman) {
+	_id = objid;
+	_sourceObj = source;
+	_targetObj = target;
+	_container = container;
+	_huffman = huffman;
+	_isOld = isOld;
+	_engine = engine;
+
+	if (_isOld) {
+		decodeOld();
+	} else {
+		decodeHuffman();
+	}
+}
+
+void TextAsset::decodeOld() {
+	Common::SeekableReadStream *res = _container->getItem(_id);
+	uint16 strLen = res->readUint16BE();
+	Common::BitStream32BELSB stream(res, true);
+	char *str = new char[strLen + 1];
+	bool lowercase = false;
+	char c;
+	for (uint16 i = 0; i < strLen; i++) {
+		char val = stream.getBits(5);
+		if (val == 0x0) { // Space
+			c = ' ';
+		} else if (val >= 0x1 && val <= 0x1A) {
+			if (lowercase) { // Ascii a-z
+				c = val + 0x60;
+			} else { // Ascii A-Z
+				c = val + 0x40;
+			}
+			lowercase = true;
+		} else if (val == 0x1B) {
+			if (lowercase) {
+				c = '.';
+			} else {
+				c = ',';
+			}
+			lowercase = true;
+		} else if (val == 0x1C) {
+			if (lowercase) {
+				c = '\'';
+			} else {
+				c = '"';
+			}
+			lowercase = true;
+		} else if (val == 0x1D) { // Composite
+			ObjID subval = stream.getBits(16);
+			Common::String child;
+			if (subval & 0x8000) {
+				// Composite object id
+				subval ^= 0xFFFF;
+				child = getNoun(subval);
+			} else {
+				// Just another id
+				// HACK, see below in getNoun()
+				child = *TextAsset(_engine, subval, _sourceObj, _targetObj, _container, _isOld, _huffman).decode();
+			}
+			if (child.size() > 0) {
+				c = '?'; // HACK Will fix later, should append
+			}
+			lowercase = true;
+		} else if (val == 0x1E) {
+			c = stream.getBits(8);
+			lowercase = true;
+		} else if (val == 0x1F) {
+			lowercase = !lowercase;
+		} else {
+			warning("Unrecognized char in old text %d, pos %d", _id, i);
+		}
+		str[i] = c;
+	}
+
+	str[strLen] = '\0';
+	debugC(3, kMVDebugText, "Decoded string [%d] (old encoding): %s", _id, str);
+	_decoded = Common::String(str);
+}
+
+void TextAsset::decodeHuffman() {
+	_decoded = Common::String("");
+	Common::SeekableReadStream *res = _container->getItem(_id);
+	Common::BitStream8MSB stream(res, true);
+	uint16 strLen = 0;
+	if (stream.getBit()) {
+		strLen = stream.getBits(15);
+	} else {
+		strLen = stream.getBits(7);
+	}
+	uint32 mask = 0;
+	uint32 symbol = 0;
+	char c;
+	for (uint16 i = 0; i < strLen; i++) {
+		mask = stream.peekBits(16);
+
+		uint32 entry;
+		// Find the length index
+		for (entry = 0; entry < _huffman->getNumEntries(); entry++) {
+			if (mask < _huffman->getMask(entry)) {
+				break;
+			}
+		}
+
+		stream.skip(_huffman->getLength(entry));
+
+		symbol = _huffman->getSymbol(entry);
+
+		if (symbol == 1) { // 7-bit ascii
+			c = stream.getBits(7);
+			_decoded += c;
+		} else if (symbol == 2) { // Composite
+			if (stream.getBit()) { // TextID
+				ObjID embedId = stream.getBits(15);
+				uint pos = stream.pos(); // HACK, part 1
+				TextAsset embedded(_engine, embedId, _sourceObj, _targetObj, _container, _isOld, _huffman);
+				stream.rewind();// HACK, part 2
+				stream.skip(pos);
+
+				_decoded.replace(_decoded.end(), _decoded.end(), *embedded.decode());
+
+				// Another HACK, to get around that EOS char I insert at the end
+				_decoded.replace(_decoded.end() - 1, _decoded.end(), "");
+			} else { //Composite obj string
+				ObjID embedId = stream.getBits(8);
+				uint pos = stream.pos(); // HACK, part 1
+
+				_decoded.replace(_decoded.end(), _decoded.end(), getNoun(embedId));
+				stream.rewind();// HACK, part 2
+				stream.skip(pos);
+
+				// Another HACK, to get around that EOS char I insert at the end
+				_decoded.replace(_decoded.end() - 1, _decoded.end(), "");
+			}
+		} else { // Plain ascii
+			c = symbol & 0xFF;
+			_decoded.replace(_decoded.end(), _decoded.end(), Common::String(c));
+		}
+	}
+	_decoded += '\0';
+	debugC(3, kMVDebugText, "Decoded string [%d] (new encoding): %s", _id, _decoded.c_str());
+}
+Common::String TextAsset::getNoun(ObjID subval) {
+	ObjID obj;
+	Common::String name;
+	if (subval & 8) {
+		obj = _targetObj;
+	} else {
+		obj = _sourceObj;
+	}
+	if ((subval & 3) == 1) {
+		uint idx = _engine->getPrefixNdx(obj);
+		idx = ((idx >> 4) & 3) + 1;
+		name = _engine->getNoun(idx);
+	} else {
+		// HACK, there should be a pool of assets or something like in the GUI
+		name = *TextAsset(_engine, obj, _sourceObj, _targetObj, _container, _isOld, _huffman).decode();
+		switch (subval & 3) {
+		case 2:
+			name = _engine->getPrefixString(0, obj) + name;
+			break;
+		case 3:
+			name = _engine->getPrefixString(2, obj) + name;
+			break;
+		}
+	}
+	if (name.size() && (subval & 4)) {
+		Common::String tmp = name;
+		name.toUppercase();
+		name.replace(1, name.size() - 1, tmp, 1, tmp.size() - 1);
+	}
+
+	return name;
+}
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/text.h b/engines/macventure/text.h
new file mode 100644
index 0000000000..88dd112681
--- /dev/null
+++ b/engines/macventure/text.h
@@ -0,0 +1,64 @@
+/* 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 MACVENTURE_TEXT_H
+#define MACVENTURE_TEXT_H
+
+#include "macventure/macventure.h"
+#include "macventure/hufflists.h"
+
+namespace MacVenture {
+typedef uint32 ObjID;
+class MacVentureEngine;
+
+class TextAsset {
+public:
+	TextAsset(MacVentureEngine *engine, ObjID objid, ObjID source, ObjID target, Container *container, bool isOld, const HuffmanLists *huffman);
+	~TextAsset() {}
+
+	const Common::String *decode() {
+		return &_decoded;
+	}
+
+private:
+	void decodeOld();
+	void decodeHuffman();
+
+	Common::String getNoun(ObjID id);
+
+private:
+	MacVentureEngine *_engine;
+
+	Container *_container;
+	ObjID _id;
+	ObjID _targetObj;
+	ObjID _sourceObj;
+	const HuffmanLists *_huffman;
+	bool _isOld;
+
+	Common::String _decoded;
+
+};
+
+} // End of namespace MacVenture
+
+#endif
diff --git a/engines/macventure/windows.cpp b/engines/macventure/windows.cpp
new file mode 100644
index 0000000000..b3d544924f
--- /dev/null
+++ b/engines/macventure/windows.cpp
@@ -0,0 +1,61 @@
+/* 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 "macventure/windows.h"
+
+namespace MacVenture {
+
+BorderBounds borderBounds(MVWindowType type) {
+	switch (type) {
+	case MacVenture::kDocument:
+		break;
+	case MacVenture::kDBox:
+		break;
+	case MacVenture::kPlainDBox:
+		return BorderBounds(3, 3, 3, 3);
+	case MacVenture::kAltBox:
+		return BorderBounds(0, 0, 0, 0); // Hand-tested
+	case MacVenture::kNoGrowDoc:
+		return BorderBounds(1, 20, 1, 1);
+	case MacVenture::kMovableDBox:
+		break;
+	case MacVenture::kZoomDoc:
+		return BorderBounds(1, 20, 17, 1);
+	case MacVenture::kZoomNoGrow:
+		break;
+	case MacVenture::kInvWindow:
+		return BorderBounds(1, 20, 17, 17);
+	case MacVenture::kRDoc16:
+		break;
+	case MacVenture::kRDoc4:
+		return BorderBounds(1, 20, 1, 1);
+	case MacVenture::kRDoc6:
+		break;
+	case MacVenture::kRDoc10:
+		break;
+	default:
+		break;
+	}
+
+	return BorderBounds(0, 0, 0, 0);
+}
+} // End of namespace MacVenture
diff --git a/engines/macventure/windows.h b/engines/macventure/windows.h
new file mode 100644
index 0000000000..fd3acefa7b
--- /dev/null
+++ b/engines/macventure/windows.h
@@ -0,0 +1,99 @@
+/* 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 MACVENTURE_WINDOWS_H
+#define MACVENTURE_WINDOWS_H
+
+#include "common/rect.h"
+#include "common/array.h"
+
+namespace MacVenture {
+// massive HACK
+typedef uint32 ObjID;
+
+enum WindowReference {
+	kNoWindow = 0,
+	kInventoryStart = 1,
+	kCommandsWindow = 0x80,
+	kMainGameWindow = 0x81,
+	kOutConsoleWindow = 0x82,
+	kSelfWindow = 0x83,
+	kExitsWindow = 0x84,
+	kDiplomaWindow = 0x85
+};
+
+enum MVWindowType {
+	kDocument = 0x00,
+	kDBox = 0x01,
+	kPlainDBox = 0x02,
+	kAltBox = 0x03,
+	kNoGrowDoc = 0x04,
+	kMovableDBox = 0x05,
+	kZoomDoc = 0x08,
+	kZoomNoGrow = 0x0c,
+	// WebVenture assigns arbitrary kinds post-loading
+	kInvWindow = 0x0e,
+	kRDoc16 = 0x10,
+	kRDoc4 = 0x12,
+	kRDoc6 = 0x14,
+	kRDoc10 = 0x16,
+	kNoType = 0xFF
+};
+
+struct DrawableObject {
+	ObjID obj;
+	byte mode;
+	DrawableObject(ObjID id, byte md) {
+		obj = id;
+		mode = md;
+	}
+};
+
+enum {
+	kScrollAmount = 10
+};
+
+struct WindowData {
+	Common::Rect bounds;
+	MVWindowType type;
+	ObjID objRef;
+	uint16 visible;
+	uint16 hasCloseBox;
+	WindowReference refcon;
+	uint8 titleLength;
+	Common::String title;
+	Common::Array<DrawableObject> children;
+	bool updateScroll;
+	Common::Point scrollPos;
+};
+
+struct BorderBounds {
+	uint16 leftOffset;
+	uint16 topOffset;
+	uint16 rightOffset;
+	uint16 bottomOffset;
+
+	BorderBounds(uint16 l, uint16 t, uint16 r, uint16 b) :
+	leftOffset(l), topOffset(t), rightOffset(r), bottomOffset(b) {}
+};
+}
+#endif
diff --git a/engines/macventure/world.cpp b/engines/macventure/world.cpp
new file mode 100644
index 0000000000..7c14618f3e
--- /dev/null
+++ b/engines/macventure/world.cpp
@@ -0,0 +1,350 @@
+#include "macventure/world.h"
+#include "macventure/macventure.h"
+
+#include "common/file.h"
+
+namespace MacVenture {
+
+World::World(MacVentureEngine *engine, Common::MacResManager *resMan) {
+	_resourceManager = resMan;
+	_engine = engine;
+	_saveGame = NULL;
+	_gameText = NULL;
+
+	startNewGame();
+
+	_objectConstants = new Container(_engine->getFilePath(kObjectPathID));
+	calculateObjectRelations();
+
+	_gameText = new Container(_engine->getFilePath(kTextPathID));
+}
+
+
+World::~World()	{
+
+	if (_saveGame)
+		delete _saveGame;
+
+	if (_objectConstants)
+		delete _objectConstants;
+
+	if (_gameText)
+		delete _gameText;
+}
+
+void World::startNewGame() {
+	if (_saveGame)
+		delete _saveGame;
+
+	if ((_startGameFileName = _engine->getStartGameFileName()) == "")
+		error("WORLD: Could not load initial game configuration");
+
+	Common::File saveGameFile;
+	if (!saveGameFile.open(_startGameFileName))
+		error("WORLD: Could not load initial game configuration");
+
+	debugC(2, kMVDebugMain, "Loading save game state from %s", _startGameFileName.c_str());
+	Common::SeekableReadStream *saveGameRes = saveGameFile.readStream(saveGameFile.size());
+
+	_saveGame = new SaveGame(_engine, saveGameRes);
+
+	calculateObjectRelations();
+
+	delete saveGameRes;
+	saveGameFile.close();
+}
+
+uint32 World::getObjAttr(ObjID objID, uint32 attrID) {
+	uint res;
+	uint32 index = _engine->getGlobalSettings()._attrIndices[attrID];
+	// HACK, but if I try to initialize it in the else clause, it goes out of scope and segfaults
+	Common::SeekableReadStream *objStream = _objectConstants->getItem(objID);
+	if (!(index & 0x80)) { // It's not a constant
+		res = _saveGame->getAttr(objID, index);
+	} else {
+		index &= 0x7F;
+		if (objStream->size() == 0) {
+			return 0;
+		}
+		// Look for the right attribute inside the object
+		objStream->skip(index * 2);
+		res = objStream->readByte() << 8;
+		res |= objStream->readByte();
+	}
+	res &= _engine->getGlobalSettings()._attrMasks[attrID];
+	res >>= _engine->getGlobalSettings()._attrShifts[attrID];
+	if (res & 0x8000)
+		res = -((res ^ 0xffff) + 1);
+	debugC(5, kMVDebugMain, "Attribute %x from object %x is %x", attrID, objID, res);
+	delete objStream;
+	return res;
+}
+
+void World::setObjAttr(ObjID objID, uint32 attrID, Attribute value) {
+	if (attrID == kAttrPosX || attrID == kAttrPosY) {
+		// Round to scale
+		// Intentionally empty, we don't seem to require this functionality
+	}
+
+	if (attrID == kAttrParentObject)
+		setParent(objID, value);
+
+	if (attrID < kAttrOtherDoor)
+		_engine->enqueueObject(kUpdateObject, objID);
+
+	uint32 idx = _engine->getGlobalSettings()._attrIndices[attrID];
+	value <<= _engine->getGlobalSettings()._attrShifts[attrID];
+	value &= _engine->getGlobalSettings()._attrMasks[attrID];
+	Attribute oldVal = _saveGame->getAttr(objID, idx);
+	oldVal &= ~_engine->getGlobalSettings()._attrMasks[attrID];
+	_saveGame->setAttr(idx, objID, (value | oldVal));
+	_engine->gameChanged();
+}
+
+bool MacVenture::World::isObjActive(ObjID obj) {
+	ObjID destObj = _engine->getDestObject();
+	Common::Point p = _engine->getDeltaPoint();
+	ControlAction selectedControl = _engine->getSelectedControl();
+	if (!getAncestor(obj)) {
+		return false; // If our ancestor is the garbage (obj 0), we're inactive
+	}
+	if (_engine->getInvolvedObjects() >= 2 &&	// If (we need > 1 objs for the command) &&
+		destObj > 0 &&			// we have a destination object &&
+		!getAncestor(destObj)) {	// but that destination object is in the garbage
+		return false;
+	}
+	if (selectedControl != kMoveObject) {
+		return true; // We only need one
+	}
+	// Handle move object
+	if (!isObjDraggable(obj)) {
+		return false; // We can't move it
+	}
+	if (getObjAttr(1, kAttrParentObject) != destObj) {
+		return true; // if the target is not the player's parent, we can go
+	}
+	Common::Rect rect(kScreenWidth, kScreenHeight);
+	rect.top -= getObjAttr(obj, kAttrPosY) + p.y;
+	rect.left -= getObjAttr(obj, kAttrPosX) + p.x;
+	return intersects(obj, rect);
+}
+
+ObjID World::getAncestor(ObjID objID) {
+	ObjID root = getObjAttr(1, kAttrParentObject);
+	while (objID != 0 && objID != 1 && objID != root) {
+		objID = getObjAttr(objID, kAttrParentObject);
+	}
+	return objID;
+}
+
+Common::Array<ObjID> World::getFamily(ObjID objID, bool recursive) {
+	Common::Array<ObjID> res;
+	res.push_back(objID);
+	res.push_back(getChildren(objID, recursive));
+	return res;
+}
+
+Common::Array<ObjID> World::getChildren(ObjID objID, bool recursive) {
+	Common::Array<ObjID> res;
+	ObjID child = _relations[objID * 2];
+	while (child) {
+		res.push_back(child);
+		if (!recursive)
+			res.push_back(getChildren(child, false));
+		child = _relations[child * 2 + 1];
+	}
+	return res;
+}
+
+Attribute World::getGlobal(uint32 attrID) {
+	return _saveGame->getGlobals()[attrID];
+}
+
+void World::setGlobal(uint32 attrID, Attribute value) {
+	_saveGame->setGlobal(attrID, value);
+}
+
+void World::updateObj(ObjID objID) {
+	WindowReference win;
+	if (getObjAttr(1, kAttrParentObject) == objID) {
+		win = kMainGameWindow;
+	} else {
+		win = _engine->getObjWindow(objID);
+	}
+	if (win) {
+		_engine->focusObjWin(objID);
+		_engine->runObjQueue();
+		_engine->updateWindow(win);
+	}
+}
+
+void World::captureChildren(ObjID objID) {
+	warning("Capture children unimplemented!");
+}
+
+void World::releaseChildren(ObjID objID) {
+	warning("Release children unimplemented!");
+}
+
+Common::String World::getText(ObjID objID, ObjID source, ObjID target) {
+	if (objID & 0x8000) {
+		return _engine->getUserInput();
+	}
+	TextAsset text = TextAsset(_engine, objID, source, target, _gameText, _engine->isOldText(), _engine->getDecodingHuffman());
+
+	return *text.decode();
+}
+
+
+bool World::isObjDraggable(ObjID objID) {
+	return (getObjAttr(objID, kAttrInvisible) == 0 &&
+			getObjAttr(objID, kAttrUnclickable) == 0 &&
+			getObjAttr(objID, kAttrUndraggable) == 0);
+}
+
+bool World::intersects(ObjID objID, Common::Rect rect) {
+	return _engine->getObjBounds(objID).intersects(rect);
+}
+
+void World::calculateObjectRelations() {
+	_relations.clear();
+	ObjID val, next;
+	uint32 numObjs = _engine->getGlobalSettings()._numObjects;
+	const AttributeGroup &parents = *_saveGame->getGroup(0);
+	for (uint i = 0; i < numObjs * 2; i++) {
+		_relations.push_back(0);
+	}
+	for (uint i = numObjs - 1; i > 0; i--) {
+		val = parents[i];
+		next = _relations[val * 2];
+		if (next) {
+			_relations[i * 2 + 1] = next;
+		}
+		_relations[val * 2] = i;
+	}
+}
+
+void World::setParent(ObjID child, ObjID newParent) {
+	ObjID old = _saveGame->getAttr(child, kAttrParentObject);
+	if (newParent == child)
+		return;
+
+	ObjID oldNdx = old * 2;
+	old = _relations[oldNdx];
+	while (old != child) {
+		oldNdx = (old * 2) + 1;
+		old = _relations[oldNdx];
+	}
+	_relations[oldNdx] = _relations[(old * 2) + 1];
+	oldNdx = newParent * 2;
+	old = _relations[oldNdx];
+	while (old && old <= child) {
+		oldNdx = (old * 2) + 1;
+		old = _relations[oldNdx];
+	}
+	_relations[child * 2 + 1] = old;
+	_relations[oldNdx] = child;
+}
+
+void World::loadGameFrom(Common::InSaveFile *file) {
+	if (_saveGame) {
+		delete _saveGame;
+	}
+	_saveGame = new SaveGame(_engine, file);
+	calculateObjectRelations();
+}
+
+void World::saveGameInto(Common::OutSaveFile *file) {
+	_saveGame->saveInto(file);
+}
+
+// SaveGame
+SaveGame::SaveGame(MacVentureEngine *engine, Common::SeekableReadStream *res) {
+	_groups = Common::Array<AttributeGroup>();
+	loadGroups(engine, res);
+	_globals = Common::Array<uint16>();
+	loadGlobals(engine, res);
+	_text = Common::String();
+	loadText(engine, res);
+}
+
+SaveGame::~SaveGame() {
+}
+
+
+Attribute SaveGame::getAttr(ObjID objID, uint32 attrID) {
+	return _groups[attrID][objID];
+}
+
+void SaveGame::setAttr(uint32 attrID, ObjID objID, Attribute value) {
+	_groups[attrID][objID] = value;
+}
+
+const Common::Array<AttributeGroup> &MacVenture::SaveGame::getGroups() {
+	return _groups;
+}
+
+const AttributeGroup *SaveGame::getGroup(uint32 groupID) {
+	assert(groupID < _groups.size());
+	return &(_groups[groupID]);
+}
+
+void SaveGame::setGlobal(uint32 attrID, Attribute value) {
+	_globals[attrID] = value;
+}
+
+const Common::Array<uint16> &SaveGame::getGlobals() {
+	return _globals;
+}
+
+const Common::String &SaveGame::getText() {
+	return _text;
+}
+
+void SaveGame::saveInto(Common::OutSaveFile *file) {
+	warning("Saving the game not yet tested!");
+	// Save attibutes
+	Common::Array<AttributeGroup>::const_iterator itg;
+	for (itg = _groups.begin(); itg != _groups.end(); itg++) {
+		Common::Array<Attribute>::const_iterator ita;
+		for (ita = itg->begin(); ita != itg->end(); ita++) {
+			file->writeUint16BE((*ita));
+		}
+	}
+	// Save globals
+	Common::Array<uint16>::const_iterator global;
+	for (global = _globals.begin(); global != _globals.end(); global++) {
+		file->writeUint16BE((*global));
+	}
+	// Save text
+	// TODO: Insert text from GUI console
+	_text = "Hello";
+	file->write(_text.c_str(), _text.size());
+}
+
+void SaveGame::loadGroups(MacVentureEngine *engine, Common::SeekableReadStream *res) {
+	GlobalSettings settings = engine->getGlobalSettings();
+	for (int i = 0; i < settings._numGroups; ++i) {
+		AttributeGroup g;
+		for (int j = 0; j < settings._numObjects; ++j) {
+			g.push_back(res->readUint16BE());
+		}
+
+		_groups.push_back(g);
+	}
+}
+
+void SaveGame::loadGlobals(MacVentureEngine *engine, Common::SeekableReadStream *res) {
+	GlobalSettings settings = engine->getGlobalSettings();
+	for (int i = 0; i < settings._numGlobals; ++i) {
+		_globals.push_back(res->readUint16BE());
+	}
+}
+
+void SaveGame::loadText(MacVentureEngine *engine, Common::SeekableReadStream *res) {
+	// TODO: Load console text. For now, the GUI doesn't even look at this.
+	_text = "Placeholder Console Text";
+}
+
+
+} // End of namespace MacVenture
diff --git a/engines/macventure/world.h b/engines/macventure/world.h
new file mode 100644
index 0000000000..e78ab7f0db
--- /dev/null
+++ b/engines/macventure/world.h
@@ -0,0 +1,139 @@
+/* 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 MACVENTURE_WORLD_H
+#define MACVENTURE_WORLD_H
+
+#include "macventure/container.h"
+#include "macventure/text.h"
+
+namespace MacVenture {
+
+typedef uint32 ObjID;
+typedef uint16 Attribute;
+typedef Common::Array<Attribute> AttributeGroup;
+class TextAsset;
+
+enum ObjectAttributeID {
+	kAttrParentObject = 0,
+	kAttrPosX = 1,
+	kAttrPosY = 2,
+	kAttrInvisible = 3,
+	kAttrUnclickable = 4,
+	kAttrUndraggable = 5,
+	kAttrContainerOpen = 6,
+	kAttrPrefixes = 7,
+	kAttrIsExit = 8,
+	kAttrExitX = 9,
+	kAttrExitY = 10,
+	kAttrHiddenExit = 11,
+	kAttrOtherDoor = 12,
+	kAttrIsOpen = 13,
+	kAttrIsLocked = 14,
+	kAttrWeight = 16,
+	kAttrSize = 17,
+	kAttrHasDescription = 19,
+	kAttrIsDoor = 20,
+	kAttrIsContainer = 22,
+	kAttrIsOperable = 23,
+	kAttrIsEnterable = 24,
+	kAttrIsEdible = 25
+};
+
+class SaveGame {
+public:
+	SaveGame(MacVentureEngine *engine, Common::SeekableReadStream *res);
+	~SaveGame();
+
+	Attribute getAttr(ObjID objID, uint32 attrID);
+	void setAttr(uint32 attrID, ObjID objID, Attribute value);
+
+	void setGlobal(uint32 attrID, Attribute value);
+	const Common::Array<uint16> &getGlobals();
+
+	const Common::Array<AttributeGroup> &getGroups();
+	const AttributeGroup *getGroup(uint32 groupID);
+	const Common::String &getText();
+
+	void saveInto(Common::OutSaveFile *file);
+
+private:
+	void loadGroups(MacVentureEngine *engine, Common::SeekableReadStream *res);
+	void loadGlobals(MacVentureEngine *engine, Common::SeekableReadStream *res);
+	void loadText(MacVentureEngine *engine, Common::SeekableReadStream *res);
+
+private:
+	Common::Array<AttributeGroup> _groups;
+	Common::Array<uint16> _globals;
+	Common::String _text;
+};
+
+class World {
+public:
+	World(MacVentureEngine *engine, Common::MacResManager *resMan);
+	~World();
+
+	void startNewGame();
+
+	void setObjAttr(ObjID objID, uint32 attrID, Attribute value);
+	void setGlobal(uint32 attrID, Attribute value);
+	void updateObj(ObjID objID);
+	void captureChildren(ObjID objID);
+	void releaseChildren(ObjID objID);
+
+	uint32 getObjAttr(ObjID objID, uint32 attrID);
+	Attribute getGlobal(uint32 attrID);
+	Common::String getText(ObjID objID, ObjID source, ObjID target);
+
+	bool isObjActive(ObjID objID);
+
+	ObjID getAncestor(ObjID objID);
+	Common::Array<ObjID> getFamily(ObjID objID, bool recursive);
+	Common::Array<ObjID> getChildren(ObjID objID, bool recursive);
+
+	void loadGameFrom(Common::InSaveFile *file);
+	void saveGameInto(Common::OutSaveFile *file);
+
+private:
+	bool isObjDraggable(ObjID objID);
+	bool intersects(ObjID objID, Common::Rect rect);
+
+	void calculateObjectRelations();
+	void setParent(ObjID child, ObjID newParent);
+
+private:
+	MacVentureEngine *_engine;
+	Common::MacResManager *_resourceManager;
+
+	Common::String _startGameFileName;
+
+	SaveGame *_saveGame;
+
+	Container *_objectConstants;
+	Container *_gameText;
+
+	Common::Array<ObjID> _relations; // Parent-child relations, stored in Williams Heap format
+};
+
+} // End of namespace MacVenture
+
+#endif